Fix historic SQL ingest setup and progress

packages/context/src/ingest/adapters/historic-sql/evidence-tool.test.ts

@@ -1,7 +1,16 @@
 import { describe, expect, it, vi } from 'vitest';
+import { asSchema } from 'ai';
 import { createEmitHistoricSqlEvidenceTool } from './evidence-tool.js';
 
 describe('emit_historic_sql_evidence tool', () => {
+  it('exposes an AI SDK v6 tool input schema with top-level object type', async () => {
+    const tool = createEmitHistoricSqlEvidenceTool();
+
+    expect(await asSchema(tool.inputSchema).jsonSchema).toMatchObject({
+      type: 'object',
+    });
+  });
+
   it('writes table usage evidence to the ignored run evidence directory', async () => {
     const writeFile = vi.fn(async () => ({ success: true, commitHash: null }));
     const tool = createEmitHistoricSqlEvidenceTool();

packages/context/src/ingest/adapters/historic-sql/evidence-tool.ts

@@ -6,6 +6,42 @@ import { patternOutputSchema, tableUsageOutputSchema } from './skill-schemas.js'
 const SYSTEM_AUTHOR = 'System User';
 const SYSTEM_EMAIL = 'system@example.com';
 
+const emitHistoricSqlEvidenceInputSchema = z
+  .object({
+    kind: z.enum(['table_usage', 'pattern']),
+    table: z.string().min(1).optional(),
+    rawPath: z.string().min(1),
+    usage: tableUsageOutputSchema.optional(),
+    pattern: patternOutputSchema.optional(),
+  })
+  .superRefine((input, ctx) => {
+    if (input.kind === 'table_usage') {
+      if (!input.table) {
+        ctx.addIssue({
+          code: 'custom',
+          path: ['table'],
+          message: 'table is required when kind is table_usage',
+        });
+      }
+      if (!input.usage) {
+        ctx.addIssue({
+          code: 'custom',
+          path: ['usage'],
+          message: 'usage is required when kind is table_usage',
+        });
+      }
+    }
+    if (input.kind === 'pattern' && !input.pattern) {
+      ctx.addIssue({
+        code: 'custom',
+        path: ['pattern'],
+        message: 'pattern is required when kind is pattern',
+      });
+    }
+  });
+
+type EmitHistoricSqlEvidenceInput = z.infer<typeof emitHistoricSqlEvidenceInputSchema>;
+
 interface EmitHistoricSqlEvidenceToolContext {
   connectionId?: string | null;
   session?: {
@@ -23,30 +59,42 @@ interface EmitHistoricSqlEvidenceToolContext {
   };
 }
 
-function unitKeyForEvidence(input: { kind: string; table?: string; pattern?: { slug: string } }): string {
+function unitKeyForEvidence(input: EmitHistoricSqlEvidenceInput): string {
   if (input.kind === 'table_usage') {
     return `historic-sql-table-${String(input.table).replace(/[^a-zA-Z0-9]+/g, '-').replace(/^-+|-+$/g, '')}`;
   }
   return `historic-sql-pattern-${String(input.pattern?.slug).replace(/[^a-zA-Z0-9]+/g, '-').replace(/^-+|-+$/g, '')}`;
 }
 
+function evidenceEnvelope(input: EmitHistoricSqlEvidenceInput, connectionId: string) {
+  if (input.kind === 'table_usage') {
+    if (!input.table || !input.usage) {
+      throw new Error('Invalid historic-SQL table usage evidence input.');
+    }
+    return {
+      kind: 'table_usage' as const,
+      connectionId,
+      table: input.table,
+      rawPath: input.rawPath,
+      usage: input.usage,
+    };
+  }
+  if (!input.pattern) {
+    throw new Error('Invalid historic-SQL pattern evidence input.');
+  }
+  return {
+    kind: 'pattern' as const,
+    connectionId,
+    rawPath: input.rawPath,
+    pattern: input.pattern,
+  };
+}
+
 export function createEmitHistoricSqlEvidenceTool(defaultContext?: EmitHistoricSqlEvidenceToolContext) {
   return tool({
     description:
       'Record typed historic-SQL evidence for deterministic projection. Use this instead of wiki_write, sl_write_source, sl_edit_source, or context_candidate_write during historic-SQL WorkUnits.',
-    inputSchema: z.discriminatedUnion('kind', [
-      z.object({
-        kind: z.literal('table_usage'),
-        table: z.string().min(1),
-        rawPath: z.string().min(1),
-        usage: tableUsageOutputSchema,
-      }),
-      z.object({
-        kind: z.literal('pattern'),
-        rawPath: z.string().min(1),
-        pattern: patternOutputSchema,
-      }),
-    ]),
+    inputSchema: emitHistoricSqlEvidenceInputSchema,
     execute: async (input, options): Promise<string> => {
       const context = (options.experimental_context as EmitHistoricSqlEvidenceToolContext | undefined) ?? defaultContext;
       const ingest = context?.session?.ingest;
@@ -56,7 +104,8 @@ export function createEmitHistoricSqlEvidenceTool(defaultContext?: EmitHistoricS
       }
 
       const unitKey = unitKeyForEvidence(input);
-      const content = serializeHistoricSqlEvidence({ ...input, connectionId: context.connectionId });
+      const evidence = evidenceEnvelope(input, context.connectionId);
+      const content = serializeHistoricSqlEvidence(evidence);
       await configService.writeFile(
         historicSqlEvidencePath(ingest.runId, unitKey),
         content,
@@ -65,7 +114,7 @@ export function createEmitHistoricSqlEvidenceTool(defaultContext?: EmitHistoricS
         `Record historic-SQL evidence: ${unitKey}`,
         { skipLock: true },
       );
-      const label = input.kind === 'table_usage' ? input.table : input.pattern.slug;
+      const label = evidence.kind === 'table_usage' ? evidence.table : evidence.pattern.slug;
       return `Recorded historic-SQL ${input.kind} evidence for ${label}.`;
     },
   });