@shipfox/api-logs 9.3.0 → 10.0.0

package/src/core/session/claude-parser.test.ts

@@ -1,4 +1,5 @@
-import {parseClaudeSessionRecord} from './claude-parser.js';
+import {PURE_PROGRESS_CLAUDE_SYSTEM_SUBTYPES} from './claude/rows.js';
+import {createClaudeParseContext, parseClaudeSessionRecord} from './claude-parser.js';
 
 const record = (data: unknown, ts = 1) => ({
   ts,
@@ -54,6 +55,122 @@ describe('parseClaudeSessionRecord', () => {
     ]);
   });
 
+  it.each([
+    ...PURE_PROGRESS_CLAUDE_SYSTEM_SUBTYPES,
+  ])('drops pure-progress system subtype %s', (subtype) => {
+    const rows = parseClaudeSessionRecord(record({type: 'system', subtype}));
+
+    expect(rows).toEqual([]);
+  });
+
+  it('reports repeated init and result records as turns within one session', () => {
+    const context = createClaudeParseContext();
+    const rows = [
+      ...parseClaudeSessionRecord(
+        record({type: 'system', subtype: 'init', session_id: 'session-1'}),
+        context,
+      ),
+      ...parseClaudeSessionRecord(
+        record({type: 'result', subtype: 'success', result: 'first response'}),
+        context,
+        false,
+      ),
+      ...parseClaudeSessionRecord(
+        record({type: 'system', subtype: 'init', session_id: 'session-1'}),
+        context,
+      ),
+      ...parseClaudeSessionRecord(
+        record({type: 'result', subtype: 'success', result: 'final response'}),
+        context,
+      ),
+    ];
+
+    expect(rows).toEqual([
+      {
+        kind: 'lifecycle',
+        timestamp: 1,
+        label: 'Session started',
+        detail: 'session-1',
+        meta: [],
+        tone: 'default',
+        terminalFailure: false,
+      },
+      {
+        kind: 'lifecycle',
+        timestamp: 1,
+        label: 'Turn 1 completed',
+        detail: 'first response',
+        meta: [{label: 'turn', value: '1'}],
+        tone: 'default',
+        terminalFailure: false,
+      },
+      {
+        kind: 'lifecycle',
+        timestamp: 1,
+        label: 'Turn 2 started',
+        detail: 'session-1',
+        meta: [{label: 'turn', value: '2'}],
+        tone: 'default',
+        terminalFailure: false,
+      },
+      {
+        kind: 'lifecycle',
+        timestamp: 1,
+        label: 'Session completed',
+        detail: 'final response',
+        meta: [],
+        tone: 'default',
+        terminalFailure: false,
+      },
+    ]);
+  });
+
+  it('keeps non-init system messages as session events', () => {
+    const rows = parseClaudeSessionRecord(
+      record({type: 'system', subtype: 'custom_event', session_id: 'session-1'}),
+    );
+
+    expect(rows).toEqual([
+      {
+        kind: 'lifecycle',
+        timestamp: 1,
+        label: 'Session event',
+        detail: 'session-1',
+        meta: [],
+        tone: 'default',
+        terminalFailure: false,
+      },
+    ]);
+  });
+
+  it('labels workflow-output re-prompts as platform messages', () => {
+    const rows = parseClaudeSessionRecord(
+      record({
+        type: 'user',
+        message: {
+          role: 'user',
+          content:
+            'The previous turn ended without setting required workflow outputs: answer. ' +
+            'Call set_output for each missing key, then provide your final response.',
+        },
+      }),
+    );
+
+    expect(rows).toEqual([
+      {
+        kind: 'message',
+        timestamp: 1,
+        role: 'platform',
+        label: 'platform',
+        meta: [],
+        text:
+          'The previous turn ended without setting required workflow outputs: answer. ' +
+          'Call set_output for each missing key, then provide your final response.',
+        terminalFailure: false,
+      },
+    ]);
+  });
+
   it('expands assistant text, thinking, and tool-use blocks in order', () => {
     const rows = parseClaudeSessionRecord(
       record({

package/src/core/session/claude-parser.ts

@@ -1,6 +1,13 @@
 import type {SessionViewRow} from '@shipfox/api-logs-dto';
 import {z} from 'zod';
-import {assistantRows, resultRow, systemRow, userRows} from './claude/rows.js';
+import {
+  assistantRows,
+  PURE_PROGRESS_CLAUDE_SYSTEM_SUBTYPES,
+  resultRow,
+  systemRow,
+  userRows,
+} from './claude/rows.js';
+import {stringField} from './object.js';
 import {rawRecordRow} from './rows.js';
 import type {AgentSessionRecord} from './session-record.js';
 
@@ -10,7 +17,43 @@ const claudeMessageSchema = z
   })
   .catchall(z.unknown());
 
-export function parseClaudeSessionRecord(record: AgentSessionRecord): readonly SessionViewRow[] {
+export interface ClaudeParseContext {
+  hasInit: boolean;
+  sessionId: string | null;
+  turn: number;
+}
+
+export function createClaudeParseContext(): ClaudeParseContext {
+  return {hasInit: false, sessionId: null, turn: 0};
+}
+
+export function claudeInitSessionId(record: AgentSessionRecord): string | undefined {
+  let json: unknown;
+  try {
+    json = JSON.parse(record.data);
+  } catch {
+    return undefined;
+  }
+
+  const parsed = claudeMessageSchema.safeParse(json);
+  if (!parsed.success) return undefined;
+
+  const message = parsed.data;
+  if (
+    message.type !== 'init' &&
+    !(message.type === 'system' && stringField(message, 'subtype') === 'init')
+  ) {
+    return undefined;
+  }
+
+  return stringField(message, 'session_id') ?? stringField(message, 'sessionId');
+}
+
+export function parseClaudeSessionRecord(
+  record: AgentSessionRecord,
+  context: ClaudeParseContext = createClaudeParseContext(),
+  isFinalResult = true,
+): readonly SessionViewRow[] {
   let json: unknown;
   try {
     json = JSON.parse(record.data);
@@ -22,16 +65,24 @@ export function parseClaudeSessionRecord(record: AgentSessionRecord): readonly S
   if (!parsed.success) return [rawRecordRow(record, 'Unsupported Claude message')];
 
   const message = parsed.data;
+  if (
+    message.type === 'system' &&
+    typeof message.subtype === 'string' &&
+    PURE_PROGRESS_CLAUDE_SYSTEM_SUBTYPES.has(message.subtype)
+  ) {
+    return [];
+  }
+
   switch (message.type) {
     case 'system':
     case 'init':
-      return [systemRow(record.ts, message)];
+      return [systemRow(record.ts, message, context)];
     case 'assistant':
       return assistantRows(record.ts, message);
     case 'user':
       return userRows(record.ts, message);
     case 'result':
-      return [resultRow(record.ts, message)];
+      return [resultRow(record.ts, message, context.turn, isFinalResult)];
     default:
       return [rawRecordRow(record, `Unknown Claude message: ${message.type}`)];
   }

package/src/core/session/parse-session.ts

@@ -1,15 +1,24 @@
 import type {SessionViewRow} from '@shipfox/api-logs-dto';
 import type {Harness} from '@shipfox/workflow-document';
+import type {ClaudeParseContext} from './claude-parser.js';
 import {parseClaudeSessionRecord} from './claude-parser.js';
 import {parsePiSessionRecord} from './pi-parser.js';
 import type {AgentSessionRecord} from './session-record.js';
 
+export interface SessionParseContext {
+  claude?: ClaudeParseContext;
+  isFinalResult?: boolean;
+}
+
 export function parseSessionRecord(
   record: AgentSessionRecord,
   harness: Harness,
+  context?: SessionParseContext,
 ): readonly SessionViewRow[] {
   try {
-    return harness === 'claude' ? parseClaudeSessionRecord(record) : parsePiSessionRecord(record);
+    return harness === 'claude'
+      ? parseClaudeSessionRecord(record, context?.claude, context?.isFinalResult ?? true)
+      : parsePiSessionRecord(record);
   } catch {
     return [
       {

package/src/db/schema/attempt-streams.ts

@@ -1,3 +1,4 @@
+import type {SessionViewLifecycleRow} from '@shipfox/api-logs-dto';
 import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';
 import {sql} from 'drizzle-orm';
 import {
@@ -5,6 +6,7 @@ import {
   boolean,
   index,
   integer,
+  jsonb,
   text,
   timestamp,
   uniqueIndex,
@@ -49,6 +51,10 @@ export const attemptStreams = pgTable(
       .default('open'),
     closeReason: text('close_reason', {enum: ['declared', 'timeout']}),
     declaredTotalBytes: bigint('declared_total_bytes', {mode: 'number'}),
+    claudeHasInit: boolean('claude_has_init').notNull().default(false),
+    claudeSessionId: text('claude_session_id'),
+    claudeTurn: integer('claude_turn').notNull().default(0),
+    claudePendingResult: jsonb('claude_pending_result').$type<SessionViewLifecycleRow>(),
     truncated: boolean('truncated').notNull().default(false),
     objectKey: text('object_key'),
     createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),
@@ -97,6 +103,10 @@ export function toAttemptStream(row: AttemptStreamDb): AttemptStream {
     state: row.state,
     closeReason: row.closeReason,
     declaredTotalBytes: row.declaredTotalBytes,
+    claudeHasInit: row.claudeHasInit,
+    claudeSessionId: row.claudeSessionId,
+    claudeTurn: row.claudeTurn,
+    claudePendingResult: row.claudePendingResult ?? null,
     truncated: row.truncated,
     objectKey: row.objectKey,
     createdAt: row.createdAt,

package/src/db/streams.ts

@@ -1,3 +1,4 @@
+import type {SessionViewLifecycleRow} from '@shipfox/api-logs-dto';
 import {and, asc, eq, getTableColumns, isNull, lt, notInArray, sql} from 'drizzle-orm';
 import type {AttemptStream, StreamCloseReason} from '#core/entities/attempt-stream.js';
 import {LeaseStreamMismatchError} from '#core/errors.js';
@@ -160,17 +161,46 @@ export async function setDeclaredTotalBytes(
     .where(eq(attemptStreams.id, params.streamId));
 }
 
+export async function setClaudeParseContext(
+  tx: Transaction,
+  params: {
+    streamId: string;
+    hasInit: boolean;
+    sessionId: string | null;
+    turn: number;
+    pendingResult: SessionViewLifecycleRow | null;
+  },
+): Promise<void> {
+  await tx
+    .update(attemptStreams)
+    .set({
+      claudeHasInit: params.hasInit,
+      claudeSessionId: params.sessionId,
+      claudeTurn: params.turn,
+      claudePendingResult: params.pendingResult,
+      updatedAt: sql`now()`,
+    })
+    .where(eq(attemptStreams.id, params.streamId));
+}
+
 /**
- * Guarded close: flips `open → closed` and stamps `closed_at` iff the stream is
- * still open, returning the closed row (or null when another path already closed
- * it). The `WHERE state='open'` predicate is both the row lock and the
- * exactly-once gate. `committed_length` is left untouched; it stays equal to the
- * runner spool bytes. `truncated` is set only on the timeout path.
+ * Guarded close: locks the open row, flips `open → closed`, clears any pending Claude result,
+ * and stamps `closed_at`. The pending result is returned separately so the caller can
+ * materialize it before publishing the close event. Returns null when another path already
+ * closed the stream. `committed_length` is left untouched; it stays equal to the runner spool
+ * bytes. `truncated` is set only on the timeout path.
  */
 export async function markStreamClosed(
   tx: Transaction,
   params: {streamId: string; reason: StreamCloseReason; markTruncated: boolean},
-): Promise<AttemptStream | null> {
+): Promise<{stream: AttemptStream; pendingClaudeResult: SessionViewLifecycleRow | null} | null> {
+  const [open] = await tx
+    .select()
+    .from(attemptStreams)
+    .where(and(eq(attemptStreams.id, params.streamId), eq(attemptStreams.state, 'open')))
+    .for('update');
+  if (!open) return null;
+
   const [row] = await tx
     .update(attemptStreams)
     .set({
@@ -178,12 +208,18 @@ export async function markStreamClosed(
       closeReason: params.reason,
       closedAt: sql`now()`,
       updatedAt: sql`now()`,
+      claudePendingResult: null,
       ...(params.markTruncated ? {truncated: true} : {}),
     })
     .where(and(eq(attemptStreams.id, params.streamId), eq(attemptStreams.state, 'open')))
     .returning();
 
-  return row ? toAttemptStream(row) : null;
+  return row
+    ? {
+        stream: toAttemptStream(row),
+        pendingClaudeResult: open.claudePendingResult ?? null,
+      }
+    : null;
 }
 
 /** Open streams of a job, for the timeout sweep to force-close after the grace period. */