@shipfox/api-logs 9.2.0 → 10.0.0

package/src/core/append-logs.test.ts

@@ -213,10 +213,9 @@ describe('appendLogs', () => {
       await appendLogs({...ctx, attempt: 1, offset: 0, body}, workflows);
 
       const stream = await findStream({...ctx, attempt: 1});
-      const rows = recordsFromChunks(await listChunks(stream?.id as string)).map((record) => {
-        expect(record.type).toBe('agent_session');
-        return record.type === 'agent_session' ? record.row : null;
-      });
+      const rows = recordsFromChunks(await listChunks(stream?.id as string)).flatMap((record) =>
+        record.type === 'agent_session' ? [record.row] : [],
+      );
       expect(rows).toEqual([
         {
           kind: 'tool-call',
@@ -228,6 +227,147 @@ describe('appendLogs', () => {
       ]);
     });
 
+    it('reports Claude re-prompts as turns and labels the re-prompt as platform input', async () => {
+      const ctx = newCtx();
+      await jobAccountingFactory.create({
+        jobId: ctx.jobId,
+        workspaceId: ctx.workspaceId,
+        startedAt: new Date(Date.now() - 60 * 60_000),
+      });
+      const workflows = createFakeInterModuleClients({
+        workflows: defineInterModulePresentation(workflowsInterModuleContract, {
+          startRunFromTrigger: vi.fn(),
+          deliverEventToJobListener: vi.fn(),
+          getStepLogContext: () => ({harness: 'claude' as const}),
+          getLeasedAgentToolContext: vi.fn(),
+        }),
+      }).workflows;
+      const init = sessionLine(
+        JSON.stringify({type: 'system', subtype: 'init', session_id: 'session-1'}),
+      );
+      const result = (text: string) =>
+        sessionLine(JSON.stringify({type: 'result', subtype: 'success', result: text}));
+      const reprompt = sessionLine(
+        JSON.stringify({
+          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.',
+          },
+        }),
+      );
+      const body = ndjsonBody(
+        init,
+        result('first response'),
+        reprompt,
+        init,
+        result('second response'),
+        reprompt,
+        init,
+        result('final response'),
+        endLine(0),
+      );
+
+      await appendLogs({...ctx, attempt: 1, offset: 0, body}, workflows);
+
+      const stream = await findStream({...ctx, attempt: 1});
+      const rows = recordsFromChunks(await listChunks(stream?.id as string)).flatMap((record) =>
+        record.type === 'agent_session' ? [record.row] : [],
+      );
+      const lifecycleRows = rows.filter(
+        (row): row is Extract<NonNullable<(typeof rows)[number]>, {kind: 'lifecycle'}> =>
+          row?.kind === 'lifecycle',
+      );
+      const messageRows = rows.filter(
+        (row): row is Extract<NonNullable<(typeof rows)[number]>, {kind: 'message'}> =>
+          row?.kind === 'message',
+      );
+
+      expect(lifecycleRows.map((row) => row.label)).toEqual([
+        'Session started',
+        'Turn 1 completed',
+        'Turn 2 started',
+        'Turn 2 completed',
+        'Turn 3 started',
+        'Session completed',
+      ]);
+      expect(
+        lifecycleRows.filter((row) => row.label.startsWith('Turn ')).map((row) => row.meta),
+      ).toEqual([
+        [{label: 'turn', value: '1'}],
+        [{label: 'turn', value: '2'}],
+        [{label: 'turn', value: '2'}],
+        [{label: 'turn', value: '3'}],
+      ]);
+      expect(messageRows.map((row) => ({role: row.role, label: row.label}))).toEqual([
+        {role: 'platform', label: 'platform'},
+        {role: 'platform', label: 'platform'},
+      ]);
+    });
+
+    it('continues Claude turn context across append requests', async () => {
+      const ctx = newCtx();
+      await jobAccountingFactory.create({
+        jobId: ctx.jobId,
+        workspaceId: ctx.workspaceId,
+        startedAt: new Date(Date.now() - 60 * 60_000),
+      });
+      const workflows = createFakeInterModuleClients({
+        workflows: defineInterModulePresentation(workflowsInterModuleContract, {
+          startRunFromTrigger: vi.fn(),
+          deliverEventToJobListener: vi.fn(),
+          getStepLogContext: () => ({harness: 'claude' as const}),
+          getLeasedAgentToolContext: vi.fn(),
+        }),
+      }).workflows;
+      const init = sessionLine(
+        JSON.stringify({type: 'system', subtype: 'init', session_id: 'session-1'}),
+      );
+      const result = sessionLine(
+        JSON.stringify({type: 'result', subtype: 'success', result: 'response'}),
+      );
+      const reprompt = sessionLine(
+        JSON.stringify({
+          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.',
+          },
+        }),
+      );
+      const first = ndjsonBody(init, result);
+      const second = ndjsonBody(reprompt, init, result, endLine(0));
+
+      await appendLogs({...ctx, attempt: 1, offset: 0, body: first}, workflows);
+      await appendLogs({...ctx, attempt: 1, offset: first.length, body: second}, workflows);
+
+      const stream = await findStream({...ctx, attempt: 1});
+      const rows = recordsFromChunks(await listChunks(stream?.id as string)).flatMap((record) =>
+        record.type === 'agent_session' ? [record.row] : [],
+      );
+      const lifecycleRows = rows.filter(
+        (row): row is Extract<NonNullable<(typeof rows)[number]>, {kind: 'lifecycle'}> =>
+          row?.kind === 'lifecycle',
+      );
+
+      expect(lifecycleRows.map((row) => row.label)).toEqual([
+        'Session started',
+        'Turn 1 completed',
+        'Turn 2 started',
+        'Session completed',
+      ]);
+      expect(stream).toMatchObject({
+        claudeHasInit: true,
+        claudeSessionId: 'session-1',
+        claudeTurn: 2,
+        claudePendingResult: null,
+      });
+    });
+
     it('does not duplicate parsed rows on a retried append', async () => {
       const ctx = newCtx();
       await allowLargeLogBudget(ctx);

package/src/core/append-logs.ts

@@ -4,6 +4,8 @@ import {
   parseLogRecordLine,
   parseRawLogRecordLine,
   type RawLogRecord,
+  type SessionViewLifecycleRow,
+  type SessionViewRow,
 } from '@shipfox/api-logs-dto';
 import type {WorkflowsModuleClient} from '@shipfox/api-workflows-dto/inter-module';
 import {logger} from '@shipfox/node-opentelemetry';
@@ -16,6 +18,7 @@ import {
   casExtendCommittedLength,
   getAttemptStream,
   getOrCreateAttemptStreamWithStatus,
+  setClaudeParseContext,
   setDeclaredTotalBytes,
 } from '#db/streams.js';
 import {
@@ -27,6 +30,12 @@ import {
 import {allowedBudget} from './budget.js';
 import {closeStream, controlTombstone} from './close-stream.js';
 import {MalformedLogChunkError, OffsetGapError} from './errors.js';
+import {
+  type ClaudeParseContext,
+  claudeInitSessionId,
+  createClaudeParseContext,
+} from './session/claude-parser.js';
+import type {SessionParseContext} from './session/parse-session.js';
 import {parseSessionRecord} from './session/parse-session.js';
 import type {AgentSessionRecord} from './session/session-record.js';
 
@@ -166,6 +175,13 @@ interface StoreChunkResult extends AppendLogsResult {
   recordCounts: Partial<Record<LogRecord['type'], number>>;
 }
 
+interface StoredBody {
+  body: Buffer;
+  recordCounts: Partial<Record<LogRecord['type'], number>>;
+  claudeParseContext: ClaudeParseContext | undefined;
+  claudePendingResult: SessionViewLifecycleRow | null | undefined;
+}
+
 /**
  * Accrues the stored bytes, persists the chunk, and trips the per-job cap when
  * this append crosses the budget. Runs only after the offset-CAS extended
@@ -228,16 +244,62 @@ async function storeChunk(
 function buildStoredBody(
   records: readonly RawLogRecord[],
   harness: Harness,
-): {body: Buffer; recordCounts: Partial<Record<LogRecord['type'], number>>} {
+  initialClaudeParseContext?: ClaudeParseContext,
+  initialClaudePendingResult?: SessionViewLifecycleRow | null,
+  isStreamFinal = false,
+): StoredBody {
   const storedRecords: LogRecord[] = [];
-  for (const record of records) {
+  const parseContext: SessionParseContext | undefined =
+    harness === 'claude'
+      ? {
+          claude: initialClaudeParseContext ?? createClaudeParseContext(),
+          isFinalResult: true,
+        }
+      : undefined;
+  const latestClaudeInitIndicesBySessionId =
+    harness === 'claude' ? latestClaudeInitIndices(records) : undefined;
+  let pendingResult = initialClaudePendingResult ?? null;
+
+  if (parseContext?.claude !== undefined && pendingResult !== null) {
+    const firstInit = firstClaudeInit(records);
+    if (isStreamFinal || firstInit.hasInit) {
+      storedRecords.push(
+        storedAgentSessionRow(
+          finalizePendingResult(
+            pendingResult,
+            firstInit.sessionId !== undefined &&
+              firstInit.sessionId === parseContext.claude.sessionId,
+            parseContext.claude.turn,
+          ),
+        ),
+      );
+      pendingResult = null;
+    }
+  }
+
+  for (const [index, record] of records.entries()) {
     if (record.type !== 'agent_session') {
       storedRecords.push(record);
       continue;
     }
 
-    for (const row of parseSessionRecord(agentSessionRecord(record), harness)) {
-      storedRecords.push({v: 1, ts: row.timestamp, type: 'agent_session', row});
+    if (parseContext?.claude !== undefined && latestClaudeInitIndicesBySessionId !== undefined) {
+      parseContext.isFinalResult = !hasFutureClaudeInit(
+        latestClaudeInitIndicesBySessionId,
+        index,
+        parseContext.claude.sessionId,
+      );
+    }
+
+    for (const row of parseSessionRecord(agentSessionRecord(record), harness, parseContext)) {
+      if (parseContext?.claude !== undefined && !isStreamFinal && isClaudeFinalResultRow(row)) {
+        if (pendingResult !== null) {
+          storedRecords.push(storedAgentSessionRow(pendingResult));
+        }
+        pendingResult = row;
+        continue;
+      }
+      storedRecords.push(storedAgentSessionRow(row));
     }
   }
 
@@ -247,7 +309,71 @@ function buildStoredBody(
     recordCounts[record.type] = (recordCounts[record.type] ?? 0) + 1;
   }
 
-  return {body, recordCounts};
+  return {
+    body,
+    recordCounts,
+    claudeParseContext: parseContext?.claude,
+    claudePendingResult: parseContext?.claude === undefined ? undefined : pendingResult,
+  };
+}
+
+function storedAgentSessionRow(row: SessionViewRow): LogRecord {
+  return {v: 1, ts: row.timestamp, type: 'agent_session', row};
+}
+
+function isClaudeFinalResultRow(row: SessionViewRow): row is SessionViewLifecycleRow {
+  return row.kind === 'lifecycle' && row.label === 'Session completed';
+}
+
+function finalizePendingResult(
+  row: SessionViewLifecycleRow,
+  sameSession: boolean,
+  turn: number,
+): SessionViewLifecycleRow {
+  if (!sameSession) return row;
+
+  return {
+    ...row,
+    label: `Turn ${turn} completed`,
+    meta: [{label: 'turn', value: String(turn)}, ...row.meta],
+  };
+}
+
+function firstClaudeInit(records: readonly RawLogRecord[]): {
+  hasInit: boolean;
+  sessionId: string | undefined;
+} {
+  for (const record of records) {
+    if (record.type !== 'agent_session') continue;
+    const sessionRecord = agentSessionRecord(record);
+    const sessionId = claudeInitSessionId(sessionRecord);
+    if (sessionId !== undefined) return {hasInit: true, sessionId};
+  }
+
+  return {hasInit: false, sessionId: undefined};
+}
+
+function latestClaudeInitIndices(records: readonly RawLogRecord[]): Map<string, number> {
+  const latestIndices = new Map<string, number>();
+
+  for (const [index, record] of records.entries()) {
+    if (record.type !== 'agent_session') continue;
+
+    const sessionId = claudeInitSessionId(agentSessionRecord(record));
+    if (sessionId !== undefined) latestIndices.set(sessionId, index);
+  }
+
+  return latestIndices;
+}
+
+function hasFutureClaudeInit(
+  latestClaudeInitIndicesBySessionId: ReadonlyMap<string, number>,
+  currentIndex: number,
+  sessionId: string | null,
+): boolean {
+  if (sessionId === null) return false;
+
+  return (latestClaudeInitIndicesBySessionId.get(sessionId) ?? -1) > currentIndex;
 }
 
 function agentSessionRecord(
@@ -287,7 +413,6 @@ export async function appendLogs(
   const sessionHarness = parsed.hasAgentSessionRecord
     ? await getSessionHarness(workflows, params.stepId)
     : DEFAULT_HARNESS;
-  const stored = buildStoredBody(parsed.records, sessionHarness);
   const commitByteLen = params.body.length;
   const metrics = {
     recordCounts: {} as Partial<Record<LogRecordMetricKind, number>>,
@@ -325,6 +450,24 @@ export async function appendLogs(
       return {committedLength: cas.committedLength, capped: await isJobCapped(tx, params.jobId)};
     }
 
+    const parseHarness =
+      sessionHarness === 'claude' || stream.claudePendingResult !== null
+        ? 'claude'
+        : sessionHarness;
+    const stored = buildStoredBody(
+      parsed.records,
+      parseHarness,
+      parseHarness === 'claude'
+        ? {
+            hasInit: stream.claudeHasInit,
+            sessionId: stream.claudeSessionId,
+            turn: stream.claudeTurn,
+          }
+        : undefined,
+      parseHarness === 'claude' ? stream.claudePendingResult : undefined,
+      declaredTotalBytes !== undefined,
+    );
+
     const {
       recordCounts,
       stored: chunkStored,
@@ -338,6 +481,15 @@ export async function appendLogs(
     });
     if (chunkStored) {
       addRecordCounts(metrics.recordCounts, stored.recordCounts);
+      if (stored.claudeParseContext !== undefined) {
+        await setClaudeParseContext(tx, {
+          streamId: stream.id,
+          hasInit: stored.claudeParseContext.hasInit,
+          sessionId: stored.claudeParseContext.sessionId,
+          turn: stored.claudeParseContext.turn,
+          pendingResult: stored.claudePendingResult ?? null,
+        });
+      }
     }
     addRecordCounts(metrics.recordCounts, recordCounts);
 

package/src/core/close-stream.ts

@@ -26,12 +26,13 @@ export interface CloseStreamParams {
 }
 
 /**
- * The guarded UPDATE (`WHERE state='open'`) in `markStreamClosed` is the lock and
- * the idempotency gate: a stream already closed by the other path (append-time
+ * The row lock plus guarded UPDATE (`WHERE state='open'`) in `markStreamClosed` provide
+ * the lock and idempotency gate: a stream already closed by the other path (append-time
  * declared close vs the job-terminated timeout sweep) returns null, so no duplicate
- * `LOG_STREAM_CLOSED` is written and no second tombstone lands. A timeout close sets
- * `truncated` and injects a `runner_lost` tombstone in-band (a `capped` tombstone,
- * if any, was injected earlier at the append that tripped the cap).
+ * `LOG_STREAM_CLOSED` is written and no second tombstone lands. A pending Claude result
+ * is materialized before the close event, then a timeout close sets `truncated` and injects
+ * a `runner_lost` tombstone in-band (a `capped` tombstone, if any, was injected earlier at
+ * the append that tripped the cap).
  *
  * The event drives compaction; it is written in the same transaction as the flip.
  */
@@ -39,12 +40,30 @@ export async function closeStream(
   tx: Transaction,
   params: CloseStreamParams,
 ): Promise<AttemptStream | null> {
-  const closed = await markStreamClosed(tx, {
+  const closedResult = await markStreamClosed(tx, {
     streamId: params.streamId,
     reason: params.reason,
     markTruncated: params.reason === 'timeout',
   });
-  if (!closed) return null;
+  if (!closedResult) return null;
+
+  const {stream: closed, pendingClaudeResult} = closedResult;
+  if (pendingClaudeResult !== null) {
+    const record: LogRecord = {
+      v: 1,
+      ts: pendingClaudeResult.timestamp,
+      type: 'agent_session',
+      row: pendingClaudeResult,
+    };
+    const data = Buffer.from(`${JSON.stringify(record)}\n`, 'utf8');
+    await insertChunk(tx, {
+      streamId: closed.id,
+      streamOffset: closed.committedLength,
+      byteLen: data.length,
+      data,
+      origin: 'control',
+    });
+  }
 
   if (params.reason === 'timeout') {
     const tombstone = controlTombstone('runner_lost');

package/src/core/entities/attempt-stream.ts

@@ -1,3 +1,5 @@
+import type {SessionViewLifecycleRow} from '@shipfox/api-logs-dto';
+
 /** Lifecycle state of an attempt's log stream. */
 export type StreamState = 'open' | 'closed';
 
@@ -29,6 +31,10 @@ export interface AttemptStream {
   state: StreamState;
   closeReason: StreamCloseReason | null;
   declaredTotalBytes: number | null;
+  claudeHasInit: boolean;
+  claudeSessionId: string | null;
+  claudeTurn: number;
+  claudePendingResult: SessionViewLifecycleRow | null;
   truncated: boolean;
   objectKey: string | null;
   createdAt: Date;

package/src/core/finalize-attempt-stream.test.ts

@@ -1,6 +1,12 @@
 import {parseLogRecordLine} from '@shipfox/api-logs-dto';
+import {workflowsInterModuleContract} from '@shipfox/api-workflows-dto/inter-module';
+import {defineInterModulePresentation} from '@shipfox/inter-module';
+import {createFakeInterModuleClients} from '@shipfox/node-module/inter-module/testing';
+import {appendLogs} from '#core/append-logs.js';
 import {db} from '#db/db.js';
 import {getOrCreateAttemptStream} from '#db/streams.js';
+import {jobAccountingFactory} from '#test/factories/job-accounting.js';
+import {ndjsonBody, sessionLine} from '#test/fixtures/ndjson.js';
 import {listChunks, listStreamClosedEvents} from '#test/queries.js';
 import {
   createFinalizeAttemptLogStream,
@@ -74,6 +80,57 @@ describe('finalizeAttemptLogStream', () => {
     expect(metrics.recordAppendedAdd).toHaveBeenCalledWith(1, {kind: 'runner_lost'});
   });
 
+  it.each([
+    {logOutcome: 'drained' as const, expectedOrigins: ['runner', 'control']},
+    {logOutcome: 'abandoned' as const, expectedOrigins: ['runner', 'control', 'control']},
+  ])('flushes a pending Claude result before a $logOutcome close', async ({
+    logOutcome,
+    expectedOrigins,
+  }) => {
+    const identity = newIdentity({logOutcome});
+    await jobAccountingFactory.create({
+      jobId: identity.jobId,
+      workspaceId: identity.workspaceId,
+      startedAt: new Date(Date.now() - 60 * 60_000),
+    });
+    const workflows = createFakeInterModuleClients({
+      workflows: defineInterModulePresentation(workflowsInterModuleContract, {
+        startRunFromTrigger: vi.fn(),
+        deliverEventToJobListener: vi.fn(),
+        getStepLogContext: () => ({harness: 'claude' as const}),
+        getLeasedAgentToolContext: vi.fn(),
+      }),
+    }).workflows;
+    const body = ndjsonBody(
+      sessionLine(JSON.stringify({type: 'system', subtype: 'init', session_id: 'session-1'})),
+      sessionLine(JSON.stringify({type: 'result', subtype: 'success', result: 'response'})),
+    );
+
+    await appendLogs({...identity, offset: 0, body}, workflows);
+    const stream = await finalizeAttemptLogStream(identity);
+    const chunks = await listChunks(stream.id);
+    const records = chunks.flatMap((chunk) =>
+      chunk.data.toString('utf8').split('\n').filter(Boolean).map(parseLogRecordLine),
+    );
+
+    expect(chunks.map((chunk) => chunk.origin)).toEqual(expectedOrigins);
+    expect(
+      records.flatMap((record) =>
+        record.type === 'agent_session' && record.row.kind === 'lifecycle'
+          ? [record.row.label]
+          : [],
+      ),
+    ).toEqual(['Session started', 'Session completed']);
+    if (logOutcome === 'abandoned') {
+      expect(records.map((record) => record.type)).toEqual([
+        'agent_session',
+        'agent_session',
+        'runner_lost',
+      ]);
+    }
+    expect(stream.claudePendingResult).toBeNull();
+  });
+
   it('does not emit another tombstone or close event when finalized again', async () => {
     const identity = newIdentity({logOutcome: 'abandoned'});
 

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,
@@ -18,14 +19,30 @@ import {
 } 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:';
+
 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 +51,21 @@ export function systemRow(
     ),
   ].filter(isMeta);
 
-  return lifecycleRow(timestamp, label, detail, 'default', false, meta);
+  if (!isInit)
+    return lifecycleRow(timestamp, 'Session event', sessionId ?? null, 'default', false, baseMeta);
+
+  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('turn', isNewSession ? null : String(context.turn)), ...baseMeta].filter(
+    isMeta,
+  );
+
+  return lifecycleRow(timestamp, label, sessionId ?? null, 'default', false, meta);
 }
 
 export function assistantRows(
@@ -92,11 +123,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 +149,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 +167,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 +176,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 +188,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 [];