fix(wave1): address augment review feedback

Author: Copilot

packages/config/mod.ts

@@ -41,7 +41,7 @@
  *
  * const config = await initConfig();
  * const report = inspectConfig(config);
- * await publishConfigSummary(report.summary);
+ * const summary = report.summary;
  * ```
  *
  * @see README.md

packages/config/src/diagnostics/inspect-config.ts

@@ -23,7 +23,7 @@ export interface InspectionReport {
  * import { inspectConfig } from "@netscript/config";
  *
  * const report = inspectConfig({ name: "app", version: "1.0.0" });
- * await publishConfigSummary(report.summary);
+ * const summary = report.summary;
  * ```
  */
 export function inspectConfig(target: Partial<NetScriptConfig> | string): InspectionReport {

packages/config/src/domain/schemas/netscript-config-schema.ts

@@ -1,6 +1,4 @@
 import { z } from 'zod';
-import type { SagasConfig, TriggersConfig } from '../../../types.ts';
-
 import { AppConfigSchema } from './app-schema.ts';
 
 import { AspireConfigSchema } from './aspire-schema.ts';
@@ -21,15 +19,104 @@ import { SdkConfigSchema } from './sdk-schema.ts';
 
 import { ServiceConfigSchema } from './service-schema.ts';
 
+const SagaRetryConfigSchema = z.object({
+  maxAttempts: z.number(),
+  initialDelay: z.number(),
+  maxDelay: z.number(),
+  backoffMultiplier: z.number(),
+  jitter: z.boolean(),
+});
+
+const SagaTimeoutConfigSchema = z.object({
+  completionTimeout: z.number().optional(),
+  minTimeout: z.number(),
+  maxTimeout: z.number(),
+});
+
+const SagaDefinitionSchema = z.object({
+  id: z.string(),
+  topic: z.string().optional(),
+  name: z.string(),
+  description: z.string().optional(),
+  entrypoint: z.string(),
+  enabled: z.boolean().default(true),
+  retry: SagaRetryConfigSchema.optional(),
+  timeout: SagaTimeoutConfigSchema.optional(),
+  tags: z.array(z.string()).optional(),
+  metadata: z.record(z.string(), z.unknown()).optional(),
+});
+
+const SagaScalingConfigSchema = z.object({
+  concurrency: z.number(),
+  mode: z.enum(['combined', 'distributed']),
+});
+
+const SagaRetentionConfigSchema = z.object({
+  activeDays: z.number(),
+  completedDays: z.number(),
+  archiveToDb: z.boolean(),
+});
+
+const SagaGroupSchema = z.object({
+  topic: z.string(),
+  scaling: SagaScalingConfigSchema.optional(),
+  retention: SagaRetentionConfigSchema.optional(),
+  sagas: z.array(SagaDefinitionSchema).default([]),
+});
+
 const SagasConfigSectionSchema = z
-  .unknown()
-  .optional()
-  .transform((value) => value as SagasConfig | undefined);
+  .object({
+    sagasDir: z.string().default('sagas'),
+    transportProvider: z.enum(['auto', 'redis', 'rabbitmq', 'inmemory']).default('auto'),
+    storeProvider: z.enum(['auto', 'redis', 'postgres', 'inmemory']).default('auto'),
+    concurrency: z.number().default(1),
+    retry: SagaRetryConfigSchema.optional(),
+    timeout: SagaTimeoutConfigSchema.optional(),
+    sagas: z.array(SagaDefinitionSchema).default([]),
+    groups: z.array(SagaGroupSchema).default([]),
+    enabled: z.boolean().default(true),
+  })
+  .optional();
+
+const TriggerDefinitionSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  type: z.enum(['file', 'webhook', 'cron', 'manual']).default('webhook'),
+  enabled: z.boolean().default(true),
+  entrypoint: z.string().optional(),
+  tags: z.array(z.string()).default([]),
+});
+
+const TriggerScalingConfigSchema = z.object({
+  concurrency: z.number(),
+});
+
+const TriggerRetentionConfigSchema = z.object({
+  kvDays: z.number(),
+  dbDays: z.number(),
+});
+
+const TriggerGroupSchema = z.object({
+  topic: z.string(),
+  scaling: TriggerScalingConfigSchema.default({ concurrency: 10 }),
+  retention: TriggerRetentionConfigSchema.default({ kvDays: 7, dbDays: 90 }),
+  triggers: z.array(TriggerDefinitionSchema).default([]),
+});
+
+const WebhookConfigSchema = z.object({
+  enabled: z.boolean().default(false),
+  basePath: z.string().default('/api/v1/webhooks'),
+  rateLimitPerMinute: z.number().default(60),
+});
 
 const TriggersConfigSectionSchema = z
-  .unknown()
-  .optional()
-  .transform((value) => value as TriggersConfig | undefined);
+  .object({
+    triggersDir: z.string().default('triggers'),
+    groups: z.array(TriggerGroupSchema).default([]),
+    webhooks: WebhookConfigSchema.optional(),
+    enabled: z.boolean().default(true),
+  })
+  .optional();
 
 /**
  * Main NetScript configuration schema.

packages/config/tests/schema/netscript_config_test.ts

@@ -0,0 +1,44 @@
+import { assertEquals, assertThrows } from 'jsr:@std/assert@^1';
+import { defineConfig } from '../../mod.ts';
+
+Deno.test('defineConfig: applies defaults to validated saga and trigger sections', () => {
+  const config = defineConfig({
+    name: 'orders',
+    databases: { config: [] },
+    sagas: {
+      groups: [{ topic: 'orders' }],
+    },
+    triggers: {
+      groups: [{ topic: 'events' }],
+    },
+  });
+
+  assertEquals(config.sagas?.sagasDir, 'sagas');
+  assertEquals(config.sagas?.transportProvider, 'auto');
+  assertEquals(config.sagas?.groups[0]?.sagas, []);
+  assertEquals(config.triggers?.triggersDir, 'triggers');
+  assertEquals(config.triggers?.groups[0]?.scaling.concurrency, 10);
+  assertEquals(config.triggers?.enabled, true);
+});
+
+Deno.test('defineConfig: rejects unrelated saga and trigger section shapes', () => {
+  assertThrows(() =>
+    defineConfig(
+      {
+        name: 'orders',
+        databases: { config: [] },
+        sagas: ['not-a-saga-section'],
+      } as unknown as Parameters<typeof defineConfig>[0],
+    )
+  );
+
+  assertThrows(() =>
+    defineConfig(
+      {
+        name: 'orders',
+        databases: { config: [] },
+        triggers: ['not-a-trigger-section'],
+      } as unknown as Parameters<typeof defineConfig>[0],
+    )
+  );
+});

packages/runtime-config/src/application/loader.ts

@@ -53,8 +53,8 @@ async function readPointerFile(path: string): Promise<VersionPointer | null> {
   if (!text) return null;
 
   try {
-    const parsed = JSON.parse(text) as VersionPointer;
-    if (parsed && typeof parsed === 'object') {
+    const parsed = JSON.parse(text) as unknown;
+    if (isVersionPointer(parsed)) {
       return parsed;
     }
   } catch {
@@ -77,6 +77,15 @@ async function readPointerFile(path: string): Promise<VersionPointer | null> {
   };
 }
 
+function isVersionPointer(value: unknown): value is VersionPointer {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+
+  const pointer = value as Record<string, unknown>;
+  return ['version', 'jobs', 'sagas', 'tasks', 'triggers', 'features'].every((key) =>
+    pointer[key] === undefined || typeof pointer[key] === 'string'
+  );
+}
+
 /**
  * Load runtime overrides from the configured runtime config directory.
  *

packages/runtime-config/src/application/watcher.ts

@@ -38,11 +38,11 @@ export function watchRuntimeConfig(
 
         debounceTimer = setTimeout(async () => {
           debounceTimer = null;
-          const config = await loadRuntimeConfig();
           try {
+            const config = await loadRuntimeConfig();
             await onChange(config);
           } catch {
-            // Watch callbacks are owned by the consumer; presentation code decides how to report.
+            // Watch reloads and callbacks are owned by the consumer; presentation code decides how to report.
           }
         }, DEFAULT_DEBOUNCE_MS);
       }

packages/runtime-config/tests/loader_test.ts

@@ -71,6 +71,25 @@ Deno.test('loadRuntimeConfig: derives conventional topic files from plain pointe
   });
 });
 
+Deno.test('loadRuntimeConfig: returns empty defaults when JSON pointer paths are malformed', async () => {
+  await withRuntimeDir(async (dir) => {
+    await writeJson(join(dir, 'current'), {
+      version: '1.0.0',
+      jobs: 123,
+    });
+
+    const config = await loadRuntimeConfig();
+
+    assertEquals(config, {
+      jobs: [],
+      sagas: [],
+      triggers: [],
+      features: [],
+      tasks: [],
+    });
+  });
+});
+
 async function withRuntimeDir(test: (dir: string) => Promise<void>): Promise<void> {
   const previous = Deno.env.get('NETSCRIPT_RUNTIME_CONFIG_DIR');
   const dir = await Deno.makeTempDir();