@shipfox/api-logs 9.3.0 → 10.1.0

package/src/core/session/claude/rows.ts

@@ -5,6 +5,7 @@ import type {
   SessionViewToolCallRow,
   SessionViewToolResultRow,
 } from '@shipfox/api-logs-dto';
+import type {ClaudeParseContext} from '../claude-parser.js';
 import {asLooseObject} from '../entry-schema.js';
 import {
   booleanField,
@@ -12,20 +13,132 @@ import {
   formatNumber,
   isMeta,
   metaItem,
+  numberField,
   stringField,
   stringifyValue,
   toJson,
 } from '../object.js';
 import {lifecycleRow, messageRow, thinkingRow} from '../rows.js';
 
+export const PURE_PROGRESS_CLAUDE_SYSTEM_SUBTYPES = new Set<string>([
+  'thinking_tokens',
+  'status',
+  'session_state_changed',
+  'task_progress',
+  'hook_progress',
+  'hook_started',
+  'commands_changed',
+  'files_persisted',
+  'memory_recall',
+  'local_command_output',
+  'plugin_install',
+]);
+const OUTPUT_REPROMPT_PREFIX = 'The previous turn ended without setting required workflow outputs:';
+
+type SystemEventMapping = {
+  label: string | ((message: Record<string, unknown>) => string);
+  tone:
+    | SessionViewLifecycleRow['tone']
+    | ((message: Record<string, unknown>) => SessionViewLifecycleRow['tone']);
+  detail?: (message: Record<string, unknown>) => string | null;
+  meta?: (message: Record<string, unknown>) => readonly SessionViewRowMeta[];
+};
+
+const SYSTEM_EVENT_MAPPINGS: Record<string, SystemEventMapping> = {
+  permission_denied: {
+    label: 'Permission denied',
+    tone: 'error',
+    detail: (message) => stringField(message, 'tool_name') ?? null,
+    meta: (message) =>
+      [
+        metaItem(
+          'reason',
+          stringField(message, 'decision_reason') ?? stringField(message, 'message'),
+        ),
+      ].filter(isMeta),
+  },
+  api_retry: {
+    label: 'API retry',
+    tone: 'warning',
+    detail: (message) => {
+      const attempt = numberField(message, 'attempt');
+      const maxRetries = numberField(message, 'max_retries');
+      return attempt == null || maxRetries == null
+        ? null
+        : `attempt ${formatNumber(attempt)}/${formatNumber(maxRetries)}`;
+    },
+    meta: (message) =>
+      [
+        numberMeta(message, 'error_status', 'status'),
+        numberMeta(message, 'retry_delay_ms', 'retry delay', 'ms'),
+      ].filter(isMeta),
+  },
+  informational: {
+    label: (message) => titleCase(stringField(message, 'level') ?? 'informational'),
+    tone: (message) => (stringField(message, 'level') === 'warning' ? 'warning' : 'default'),
+    detail: (message) => stringField(message, 'content') ?? null,
+  },
+  compact_boundary: {
+    label: 'Context compacted',
+    tone: 'default',
+    meta: (message) => {
+      const compactMetadata = asLooseObject(field(message, 'compact_metadata')) ?? {};
+      return [
+        metaItem('trigger', stringField(compactMetadata, 'trigger')),
+        numberMeta(compactMetadata, 'pre_tokens', 'tokens before', 'tokens'),
+        numberMeta(compactMetadata, 'post_tokens', 'tokens after', 'tokens'),
+        numberMeta(compactMetadata, 'duration_ms', 'duration', 'ms'),
+      ].filter(isMeta);
+    },
+  },
+  model_refusal_fallback: {
+    label: 'Model refused, fell back',
+    tone: 'warning',
+  },
+  model_refusal_no_fallback: {
+    label: 'Model refused',
+    tone: 'error',
+  },
+  mirror_error: {
+    label: 'Session mirror failed',
+    tone: 'error',
+    detail: (message) => stringField(message, 'error') ?? null,
+  },
+  worker_shutting_down: {
+    label: 'Worker shutting down',
+    tone: 'warning',
+  },
+  elicitation_complete: {
+    label: 'Elicitation complete',
+    tone: 'default',
+  },
+  notification: {
+    label: 'Notification',
+    tone: 'default',
+  },
+  task_started: {
+    label: 'Task started',
+    tone: 'default',
+  },
+  task_updated: {
+    label: 'Task updated',
+    tone: 'default',
+  },
+  task_notification: {
+    label: 'Task notification',
+    tone: 'default',
+  },
+};
+
 export function systemRow(
   timestamp: number,
   message: Record<string, unknown>,
+  context: ClaudeParseContext,
 ): SessionViewLifecycleRow {
   const subtype = stringField(message, 'subtype');
-  const label = subtype === 'init' || message.type === 'init' ? 'Session started' : 'Session event';
-  const detail = stringField(message, 'session_id') ?? stringField(message, 'sessionId') ?? null;
-  const meta = [
+  const sessionId = stringField(message, 'session_id') ?? stringField(message, 'sessionId');
+  const isInit = subtype === 'init' || message.type === 'init';
+  const baseMeta = [
     metaItem('cwd', stringField(message, 'cwd'), false),
     metaItem('model', stringField(message, 'model')),
     metaItem(
@@ -34,7 +147,44 @@ export function systemRow(
     ),
   ].filter(isMeta);
 
-  return lifecycleRow(timestamp, label, detail, 'default', false, meta);
+  if (!isInit) {
+    const mapping = subtype === undefined ? undefined : SYSTEM_EVENT_MAPPINGS[subtype];
+    const label =
+      mapping === undefined
+        ? `Session event (${subtype ?? 'unknown'})`
+        : typeof mapping.label === 'function'
+          ? mapping.label(message)
+          : mapping.label;
+    const tone =
+      mapping === undefined
+        ? 'default'
+        : typeof mapping.tone === 'function'
+          ? mapping.tone(message)
+          : mapping.tone;
+    const detail = mapping?.detail?.(message) ?? null;
+    const meta = [...baseMeta, ...(mapping?.meta?.(message) ?? [])];
+
+    return lifecycleRow(timestamp, label, detail, tone, false, meta);
+  }
+
+  const isNewSession =
+    !context.hasInit || sessionId === undefined || sessionId !== context.sessionId;
+  context.hasInit = true;
+  context.sessionId = sessionId ?? null;
+  context.turn = isNewSession ? 1 : context.turn + 1;
+
+  const label = isNewSession ? 'Session started' : `Turn ${context.turn} started`;
+  const meta = [
+    metaItem('session', isNewSession ? sessionId : null),
+    metaItem('turn', isNewSession ? null : String(context.turn)),
+    ...baseMeta,
+  ].filter(isMeta);
+
+  return lifecycleRow(timestamp, label, null, 'default', false, meta);
+}
+
+function titleCase(value: string): string {
+  return value.length === 0 ? value : `${value[0]?.toUpperCase()}${value.slice(1)}`;
 }
 
 export function assistantRows(
@@ -92,11 +242,12 @@ export function userRows(
   message: Record<string, unknown>,
 ): readonly SessionViewRow[] {
   const sdkMessage = asLooseObject(message.message) ?? message;
+  const role = isPlatformMessage(sdkMessage) ? 'platform' : 'user';
   const rows: SessionViewRow[] = [];
   const textParts: string[] = [];
   const pushText = () => {
     if (textParts.length === 0) return;
-    rows.push(messageRow(timestamp, 'user', 'user', textParts.join('\n\n'), false));
+    rows.push(messageRow(timestamp, role, role, textParts.join('\n\n'), false));
     textParts.length = 0;
   };
 
@@ -117,12 +268,14 @@ export function userRows(
   if (rows.length > 0) return rows;
 
   const content = stringField(sdkMessage, 'content');
-  return [messageRow(timestamp, 'user', 'user', content ?? toJson(message), false)];
+  return [messageRow(timestamp, role, role, content ?? toJson(message), false)];
 }
 
 export function resultRow(
   timestamp: number,
   message: Record<string, unknown>,
+  turn: number,
+  isFinalResult: boolean,
 ): SessionViewLifecycleRow {
   const isError = booleanField(message, 'is_error') || booleanField(message, 'isError');
   const subtype = stringField(message, 'subtype');
@@ -133,6 +286,7 @@ export function resultRow(
     stringField(message, 'message') ??
     null;
   const meta = [
+    metaItem('turn', !terminalFailure && !isFinalResult && turn > 0 ? String(turn) : null),
     numberMeta(message, 'duration_ms', 'duration', 'ms'),
     numberMeta(message, 'duration_api_ms', 'api duration', 'ms'),
     numberMeta(message, 'num_turns', 'turns'),
@@ -141,7 +295,11 @@ export function resultRow(
 
   return lifecycleRow(
     timestamp,
-    terminalFailure ? 'Session failed' : 'Session completed',
+    terminalFailure
+      ? 'Session failed'
+      : isFinalResult || turn === 0
+        ? 'Session completed'
+        : `Turn ${turn} completed`,
     detail,
     terminalFailure ? 'error' : 'default',
     terminalFailure,
@@ -149,6 +307,17 @@ export function resultRow(
   );
 }
 
+function isPlatformMessage(message: Record<string, unknown>): boolean {
+  const content = field(message, 'content');
+  if (typeof content === 'string') return content.startsWith(OUTPUT_REPROMPT_PREFIX);
+  if (!Array.isArray(content)) return false;
+
+  return content.some((block) => {
+    const object = asLooseObject(block);
+    return stringField(object, 'text')?.startsWith(OUTPUT_REPROMPT_PREFIX) === true;
+  });
+}
+
 function contentBlocks(message: Record<string, unknown>): Record<string, unknown>[] {
   const content = message.content;
   if (!Array.isArray(content)) return [];

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

@@ -1,9 +1,152 @@
-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,
   data: typeof data === 'string' ? data : JSON.stringify(data),
 });
+const meta = (label: string, value: string, inline?: boolean) =>
+  inline == null ? {label, value} : {label, value, inline};
+
+const namedSystemEvents = [
+  {
+    subtype: 'permission_denied',
+    data: {tool_name: 'mcp__shipfox_outputs__set_output', decision_reason: 'Permission mode'},
+    expected: {
+      label: 'Permission denied',
+      detail: 'mcp__shipfox_outputs__set_output',
+      meta: [meta('reason', 'Permission mode')],
+      tone: 'error',
+    },
+  },
+  {
+    subtype: 'api_retry',
+    data: {attempt: 2, max_retries: 3, error_status: 429, retry_delay_ms: 1_500},
+    expected: {
+      label: 'API retry',
+      detail: 'attempt 2/3',
+      meta: [meta('status', '429'), meta('retry delay', '1,500 ms')],
+      tone: 'warning',
+    },
+  },
+  {
+    subtype: 'informational',
+    data: {level: 'warning', content: 'The hook blocked continuation.'},
+    expected: {
+      label: 'Warning',
+      detail: 'The hook blocked continuation.',
+      meta: [],
+      tone: 'warning',
+    },
+  },
+  {
+    subtype: 'compact_boundary',
+    data: {
+      compact_metadata: {trigger: 'auto', pre_tokens: 12_000, post_tokens: 4_000, duration_ms: 250},
+    },
+    expected: {
+      label: 'Context compacted',
+      detail: null,
+      meta: [
+        meta('trigger', 'auto'),
+        meta('tokens before', '12K tokens'),
+        meta('tokens after', '4,000 tokens'),
+        meta('duration', '250 ms'),
+      ],
+      tone: 'default',
+    },
+  },
+  {
+    subtype: 'model_refusal_fallback',
+    data: {},
+    expected: {
+      label: 'Model refused, fell back',
+      detail: null,
+      meta: [],
+      tone: 'warning',
+    },
+  },
+  {
+    subtype: 'model_refusal_no_fallback',
+    data: {},
+    expected: {
+      label: 'Model refused',
+      detail: null,
+      meta: [],
+      tone: 'error',
+    },
+  },
+  {
+    subtype: 'mirror_error',
+    data: {error: 'Session store unavailable'},
+    expected: {
+      label: 'Session mirror failed',
+      detail: 'Session store unavailable',
+      meta: [],
+      tone: 'error',
+    },
+  },
+  {
+    subtype: 'worker_shutting_down',
+    data: {},
+    expected: {
+      label: 'Worker shutting down',
+      detail: null,
+      meta: [],
+      tone: 'warning',
+    },
+  },
+  {
+    subtype: 'elicitation_complete',
+    data: {},
+    expected: {
+      label: 'Elicitation complete',
+      detail: null,
+      meta: [],
+      tone: 'default',
+    },
+  },
+  {
+    subtype: 'notification',
+    data: {},
+    expected: {
+      label: 'Notification',
+      detail: null,
+      meta: [],
+      tone: 'default',
+    },
+  },
+  {
+    subtype: 'task_started',
+    data: {},
+    expected: {
+      label: 'Task started',
+      detail: null,
+      meta: [],
+      tone: 'default',
+    },
+  },
+  {
+    subtype: 'task_updated',
+    data: {},
+    expected: {
+      label: 'Task updated',
+      detail: null,
+      meta: [],
+      tone: 'default',
+    },
+  },
+  {
+    subtype: 'task_notification',
+    data: {},
+    expected: {
+      label: 'Task notification',
+      detail: null,
+      meta: [],
+      tone: 'default',
+    },
+  },
+] as const;
 
 describe('parseClaudeSessionRecord', () => {
   it('returns a raw row for malformed JSON', () => {
@@ -43,8 +186,9 @@ describe('parseClaudeSessionRecord', () => {
         kind: 'lifecycle',
         timestamp: 1,
         label: 'Session started',
-        detail: 'session-1',
+        detail: null,
         meta: [
+          {label: 'session', value: 'session-1'},
           {label: 'cwd', value: '/workspace', inline: false},
           {label: 'model', value: 'claude-opus-4-8'},
         ],
@@ -54,6 +198,139 @@ 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.each(namedSystemEvents)('names and tones $subtype system events', ({
+    subtype,
+    data,
+    expected,
+  }) => {
+    const rows = parseClaudeSessionRecord(record({type: 'system', subtype, ...data}));
+
+    expect(rows).toEqual([
+      {
+        kind: 'lifecycle',
+        timestamp: 1,
+        ...expected,
+        terminalFailure: false,
+      },
+    ]);
+  });
+
+  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: null,
+        meta: [meta('session', 'session-1')],
+        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: null,
+        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('qualifies unmapped system events instead of using a bare generic label', () => {
+    const rows = parseClaudeSessionRecord(
+      record({type: 'system', subtype: 'custom_event', session_id: 'session-1'}),
+    );
+
+    expect(rows).toEqual([
+      {
+        kind: 'lifecycle',
+        timestamp: 1,
+        label: 'Session event (custom_event)',
+        detail: null,
+        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,