vouchington-tooling 0.1.0 → 0.1.2

package/README.md

@@ -90,7 +90,11 @@ import {
 import { createArtifactClassifier, runCleanup } from 'vouchington-tooling/gha-artifacts-cleanup'
 import { validateOptionalHttpOrigin } from 'vouchington-tooling/http-origin'
 import { boundPendingLine, splitCompleteLines } from 'vouchington-tooling/process-line-buffer'
-import { runBrowserSession } from 'vouchington-tooling/browser-session-runner'
+import {
+  isProcessGroupAlive,
+  runBrowserSession,
+  waitForProcessGroupExit,
+} from 'vouchington-tooling/browser-session-runner'
 import {
   generateSchemaSnapshot,
   renderSchemaMarkdown,
@@ -144,3 +148,5 @@ are terminal. Output is decoded independently per stream; unfinished lines are c
 `diagnosticTailBytes` retains a UTF-8-safe tail no larger than its byte budget.
 The runner uses monotonic elapsed time, rejects timer budgets above Node's maximum delay, and waits for
 the dedicated process group to exit after the direct child closes so descendants cannot overlap a retry.
+`isProcessGroupAlive` and `waitForProcessGroupExit` are also available when callers need the same
+process-group probe and bounded-drain semantics outside a browser session.

package/dist/browser-session-runner/attempt.mjs

@@ -1,7 +1,7 @@
-import { StringDecoder } from 'node:string_decoder';
-import { boundPendingLine, splitCompleteLines } from '../process-line-buffer/index.mjs';
+import { createOutputConsumer } from './output.mjs';
 import { tailText } from './tail.mjs';
 import { TailQueue } from './tail-queue.mjs';
+import { createWatchdogLifecycle, registerWatchdogSetup } from './watchdog.mjs';
 export function runAttempt(options, deps, deadline, attempt) {
     return new Promise((resolve, reject) => {
         const startedAt = deps.now(), process = options.start(attempt);
@@ -20,7 +20,9 @@ export function runAttempt(options, deps, deadline, attempt) {
         let startupProgress = false, semanticProgress = false;
         let failure, hasFailure = false, childExited = false, closeExit, draining = false, drainDone = false, reason = 'exit', complete = false, terminating = false;
         let killTimer, stallTimer;
+        const watchdog = createWatchdogLifecycle();
         const listeners = [];
+        const captureFailure = (error) => !hasFailure && ((failure = error), (hasFailure = true));
         const finish = (exit) => {
             if (complete)
                 return;
@@ -29,6 +31,7 @@ export function runAttempt(options, deps, deadline, attempt) {
             if (killTimer)
                 deps.clearTimeout(killTimer);
             deps.clearTimeout(stallTimer);
+            watchdog.complete(captureFailure);
             for (const remove of listeners)
                 remove();
             const result = {
@@ -78,10 +81,9 @@ export function runAttempt(options, deps, deadline, attempt) {
             signal('SIGTERM');
         };
         const fail = (error) => {
-            if (hasFailure)
+            if (hasFailure || complete)
                 return;
-            failure = error;
-            hasFailure = true;
+            captureFailure(error);
             terminate('exit');
         };
         const drain = () => {
@@ -102,39 +104,22 @@ export function runAttempt(options, deps, deadline, attempt) {
                 deps.clearTimeout(stallTimer);
             stallTimer = deps.setTimeout(() => terminate(nextReason), ms);
         };
-        const consume = () => {
-            const decoder = new StringDecoder('utf8');
-            let pending = '';
-            const line = (value) => {
-                const event = options.onLine(value);
-                if (event === 'startup' && !startupProgress) {
-                    startupProgress = true;
-                    if (!childExited)
-                        armStall(options.semanticStallMs, 'semantic-stall');
-                }
-                if (event === 'semantic') {
-                    semanticProgress = true;
-                    if (startupProgress && !childExited)
-                        armStall(options.semanticStallMs, 'semantic-stall');
-                }
-            };
-            const appendLines = (text) => {
-                tail.append(text);
-                const split = splitCompleteLines(pending + text);
-                pending = boundPendingLine(split.pending);
-                for (const value of split.complete)
-                    line(value);
-            };
-            return {
-                flush: () => {
-                    appendLines(decoder.end());
-                    if (pending)
-                        line(pending);
-                },
-                write: (chunk) => appendLines(decoder.write(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk))),
-            };
+        const line = (value) => {
+            const event = options.onLine(value);
+            if (event === 'startup' && !startupProgress) {
+                startupProgress = true;
+                if (!childExited)
+                    armStall(options.semanticStallMs, 'semantic-stall');
+            }
+            if (event === 'semantic') {
+                semanticProgress = true;
+                if (startupProgress && !childExited)
+                    armStall(options.semanticStallMs, 'semantic-stall');
+            }
         };
-        const streams = [process.stdout, process.stderr].map((stream) => stream ? consume() : undefined);
+        const streams = [process.stdout, process.stderr].map((stream, index) => stream
+            ? createOutputConsumer(options, tail, index === 0 ? 'stdout' : 'stderr', line)
+            : undefined);
         for (const [index, stream] of [process.stdout, process.stderr].entries())
             stream?.on('data', (chunk) => {
                 try {
@@ -191,5 +176,21 @@ export function runAttempt(options, deps, deadline, attempt) {
             if (drainDone || hasFailure)
                 finish(closeExit);
         });
+        try {
+            const setup = options.watchdog?.({
+                attempt,
+                deadline,
+                now: () => deps.now(),
+                process,
+                terminate: () => {
+                    if (!childExited)
+                        terminate('provider-watchdog');
+                },
+            });
+            registerWatchdogSetup(setup, watchdog, fail);
+        }
+        catch (error) {
+            fail(error);
+        }
     });
 }

package/dist/browser-session-runner/index.d.mts

@@ -1,4 +1,4 @@
 import type { BrowserSessionDeps, BrowserSessionOptions, BrowserSessionResult } from './types.mts';
-export type { BrowserSessionDeps, BrowserSessionEvent, BrowserSessionExit, BrowserSessionOptions, BrowserSessionProcess, BrowserSessionResult, } from './types.mts';
-export { ProcessGroupDrainTimeoutError } from './process-group.mts';
+export type { BrowserSessionDeps, BrowserSessionEvent, BrowserSessionExit, BrowserSessionOptions, BrowserSessionOutput, BrowserSessionProcess, BrowserSessionResult, BrowserSessionTerminationReason, BrowserSessionWatchdog, BrowserSessionWatchdogCleanup, BrowserSessionWatchdogController, } from './types.mts';
+export { isProcessGroupAlive, ProcessGroupDrainTimeoutError, waitForProcessGroupExit, } from './process-group.mts';
 export declare function runBrowserSession(options: BrowserSessionOptions, deps?: BrowserSessionDeps): Promise<BrowserSessionResult>;

package/dist/browser-session-runner/index.mjs

@@ -1,7 +1,7 @@
 import { runAttempt } from './attempt.mjs';
 import { expiredResult } from './result.mjs';
 import { isProcessGroupAlive, waitForProcessGroupExit } from './process-group.mjs';
-export { ProcessGroupDrainTimeoutError } from './process-group.mjs';
+export { isProcessGroupAlive, ProcessGroupDrainTimeoutError, waitForProcessGroupExit, } from './process-group.mjs';
 const defaultDeps = {
     clearInterval,
     clearTimeout,
@@ -31,11 +31,12 @@ export async function runBrowserSession(options, deps = defaultDeps) {
     let attempts = 0;
     for (let attempt = 1; attempt <= options.attempts && deps.now() < deadline; attempt += 1) {
         attempts = attempt;
-        last = await runAttempt(options, deps, deadline, attempt);
+        last = { ...(await runAttempt(options, deps, deadline, attempt)), attempts };
+        options.onAttemptComplete?.(snapshotResult(last));
         if (last.reason === 'parent-signal' ||
             last.reason === 'deadline' ||
             options.classifyExit(last.exit, omitAttempts(last)) !== 'retry')
-            return { ...last, attempts };
+            return last;
     }
     if (attempts === options.attempts)
         return { ...last, attempts };
@@ -43,6 +44,7 @@ export async function runBrowserSession(options, deps = defaultDeps) {
 }
 function validateOptions(options) {
     const maxTimerDelay = 2_147_483_647;
+    const drainTimeoutMs = options.graceMs + (options.processGroupDrainMs ?? options.graceMs);
     for (const [name, value] of [
         ['attempts', options.attempts],
         ['deadlineMs', options.deadlineMs],
@@ -58,7 +60,12 @@ function validateOptions(options) {
     const tailBytes = options.diagnosticTailBytes ?? 4096;
     if (!Number.isSafeInteger(tailBytes) || tailBytes <= 0)
         throw new RangeError('diagnosticTailBytes must be positive');
+    if (!Number.isSafeInteger(drainTimeoutMs) || drainTimeoutMs > maxTimerDelay)
+        throw new RangeError('graceMs + processGroupDrainMs must be a positive Node timer delay');
 }
 function omitAttempts({ attempts: _attempts, ...result }) {
     return result;
 }
+function snapshotResult(result) {
+    return { ...result, exit: { ...result.exit } };
+}

package/dist/browser-session-runner/output.d.mts

@@ -0,0 +1,8 @@
+import type { BrowserSessionOptions, BrowserSessionOutput } from './types.mts';
+import type { TailQueue } from './tail-queue.mts';
+type OutputConsumer = {
+    flush(): void;
+    write(chunk: string | Buffer): void;
+};
+export declare function createOutputConsumer(options: BrowserSessionOptions, tail: TailQueue, source: BrowserSessionOutput['source'], onLine: (line: string) => void): OutputConsumer;
+export {};

package/dist/browser-session-runner/output.mjs

@@ -0,0 +1,24 @@
+import { StringDecoder } from 'node:string_decoder';
+import { boundPendingLine, splitCompleteLines } from '../process-line-buffer/index.mjs';
+export function createOutputConsumer(options, tail, source, onLine) {
+    const decoder = new StringDecoder('utf8');
+    let pending = '';
+    const appendLines = (text) => {
+        tail.append(text);
+        const split = splitCompleteLines(pending + text);
+        pending = boundPendingLine(split.pending);
+        for (const value of split.complete)
+            onLine(value);
+    };
+    return {
+        flush: () => {
+            appendLines(decoder.end());
+            if (pending)
+                onLine(pending);
+        },
+        write: (chunk) => {
+            options.onOutput?.({ chunk, source });
+            appendLines(decoder.write(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)));
+        },
+    };
+}

package/dist/browser-session-runner/process-group.mjs

@@ -5,6 +5,8 @@ export class ProcessGroupDrainTimeoutError extends Error {
     }
 }
 export function isProcessGroupAlive(processGroupId) {
+    validateProcessGroupId(processGroupId);
+    assertSupportedPlatform();
     try {
         process.kill(-processGroupId, 0);
         return true;
@@ -14,6 +16,9 @@ export function isProcessGroupAlive(processGroupId) {
     }
 }
 export async function waitForProcessGroupExit(processGroupId, timeoutMs) {
+    validateProcessGroupId(processGroupId);
+    validateTimerDelay(timeoutMs);
+    assertSupportedPlatform();
     const deadline = performance.now() + timeoutMs;
     while (isProcessGroupAlive(processGroupId)) {
         if (performance.now() >= deadline)
@@ -21,3 +26,17 @@ export async function waitForProcessGroupExit(processGroupId, timeoutMs) {
         await new Promise((resolve) => setTimeout(resolve, Math.min(10, deadline - performance.now())));
     }
 }
+function assertSupportedPlatform() {
+    if (process.platform === 'win32')
+        throw new Error('process-group control is unsupported on Windows');
+}
+function validateProcessGroupId(processGroupId) {
+    if (!Number.isSafeInteger(processGroupId) ||
+        processGroupId <= 1 ||
+        processGroupId > 2_147_483_647)
+        throw new RangeError('processGroupId must be a positive supported PID');
+}
+function validateTimerDelay(timeoutMs) {
+    if (!Number.isSafeInteger(timeoutMs) || timeoutMs <= 0 || timeoutMs > 2_147_483_647)
+        throw new RangeError('timeoutMs must be a positive Node timer delay');
+}

package/dist/browser-session-runner/types.d.mts

@@ -4,6 +4,11 @@ export type BrowserSessionExit = {
     code: number | null;
     signal: NodeJS.Signals | null;
 };
+export type BrowserSessionOutput = {
+    chunk: string | Buffer;
+    source: 'stderr' | 'stdout';
+};
+export type BrowserSessionTerminationReason = 'deadline' | 'parent-signal' | 'provider-watchdog' | 'semantic-stall' | 'startup-stall';
 type BrowserSessionStream = {
     on(event: 'data', listener: (chunk: string | Buffer) => void): unknown;
     on(event: 'error', listener: (error: Error) => void): unknown;
@@ -13,7 +18,7 @@ export type BrowserSessionResult = {
     deadlineExceeded: boolean;
     diagnosticTail: string;
     exit: BrowserSessionExit;
-    reason: 'exit' | 'parent-signal' | 'semantic-stall' | 'startup-stall' | 'deadline';
+    reason: 'exit' | BrowserSessionTerminationReason;
     startupProgress: boolean;
     semanticProgress: boolean;
 };
@@ -37,6 +42,15 @@ export type BrowserSessionDeps = {
     setTimeout(callback: () => void, ms: number): unknown;
     waitForProcessGroupExit(processGroupId: number, timeoutMs: number): Promise<void>;
 };
+export type BrowserSessionWatchdogController = {
+    attempt: number;
+    deadline: number;
+    now(): number;
+    process: BrowserSessionProcess;
+    terminate(reason?: 'provider-watchdog'): void;
+};
+export type BrowserSessionWatchdogCleanup = () => void;
+export type BrowserSessionWatchdog = (controller: BrowserSessionWatchdogController) => void | BrowserSessionWatchdogCleanup | Promise<void | BrowserSessionWatchdogCleanup>;
 export type BrowserSessionOptions = {
     attempts: number;
     classifyExit(exit: BrowserSessionExit, result: Omit<BrowserSessionResult, 'attempts'>): 'retry' | 'return';
@@ -44,10 +58,13 @@ export type BrowserSessionOptions = {
     diagnosticTailBytes?: number;
     graceMs: number;
     onLine(line: string): BrowserSessionEvent | undefined;
+    onOutput?(output: BrowserSessionOutput): void;
+    onAttemptComplete?(result: BrowserSessionResult): void;
     processGroupDrainMs?: number;
     semanticStallMs: number;
     start(attempt: number): BrowserSessionProcess;
     startupStallMs: number;
     watchdogIntervalMs?: number;
+    watchdog?: BrowserSessionWatchdog;
 };
 export {};

package/dist/browser-session-runner/watchdog.d.mts

@@ -0,0 +1,10 @@
+export type WatchdogCleanup = () => void;
+type WatchdogSetup = void | WatchdogCleanup | Promise<void | WatchdogCleanup>;
+type WatchdogLifecycle = ReturnType<typeof createWatchdogLifecycle>;
+export declare function createWatchdogLifecycle(): {
+    complete: (onError: (error: unknown) => void) => void;
+    isComplete: () => boolean;
+    register: (next: void | WatchdogCleanup, onError: (error: unknown) => void) => void;
+};
+export declare function registerWatchdogSetup(setup: WatchdogSetup, lifecycle: WatchdogLifecycle, onError: (error: unknown) => void): void;
+export {};

package/dist/browser-session-runner/watchdog.mjs

@@ -0,0 +1,38 @@
+export function createWatchdogLifecycle() {
+    let complete = false;
+    let cleanup;
+    const run = (next, onError) => {
+        try {
+            next();
+        }
+        catch (error) {
+            onError(error);
+        }
+    };
+    return {
+        complete: (onError) => {
+            complete = true;
+            if (!cleanup)
+                return;
+            const next = cleanup;
+            cleanup = undefined;
+            run(next, onError);
+        },
+        isComplete: () => complete,
+        register: (next, onError) => {
+            if (!next)
+                return;
+            if (complete)
+                return run(next, onError);
+            cleanup = next;
+        },
+    };
+}
+export function registerWatchdogSetup(setup, lifecycle, onError) {
+    if (!(setup instanceof Promise))
+        return lifecycle.register(setup, onError);
+    void setup.then((cleanup) => lifecycle.register(cleanup, onError), (error) => {
+        if (!lifecycle.isComplete())
+            onError(error);
+    });
+}

package/dist/index.d.mts

@@ -22,8 +22,8 @@ export { createArtifactClassifier, parseArtifactPatternsJson, planRunDeletions,
 export type { ArtifactClassification, ArtifactClassifier, ArtifactPatterns, CleanupRequest, DeletionSummary, } from './gha-artifacts-cleanup/index.mts';
 export { validateOptionalHttpOrigin } from './http-origin/index.mts';
 export { boundPendingLine, DEFAULT_MAX_PENDING_LINE_LENGTH, DEFAULT_TRUNCATED_LINE_MARKER, splitCompleteLines, } from './process-line-buffer/index.mts';
-export { ProcessGroupDrainTimeoutError, runBrowserSession, } from './browser-session-runner/index.mts';
-export type { BrowserSessionDeps, BrowserSessionEvent, BrowserSessionExit, BrowserSessionOptions, BrowserSessionProcess, BrowserSessionResult, } from './browser-session-runner/index.mts';
+export { isProcessGroupAlive, ProcessGroupDrainTimeoutError, runBrowserSession, waitForProcessGroupExit, } from './browser-session-runner/index.mts';
+export type { BrowserSessionDeps, BrowserSessionEvent, BrowserSessionExit, BrowserSessionOptions, BrowserSessionOutput, BrowserSessionProcess, BrowserSessionResult, BrowserSessionTerminationReason, BrowserSessionWatchdog, BrowserSessionWatchdogCleanup, BrowserSessionWatchdogController, } from './browser-session-runner/index.mts';
 export { buildSchemaSnapshot, detectRenamedIndexes, generateSchemaSnapshot, indexShapeKey, readSchemaCatalog, renderSchemaMarkdown, stableStringify, writeSchemaSnapshot, } from './pg-schema-snapshot/index.mts';
 export type { CatalogQuery, PartitionPolicy, SchemaCatalog, SchemaGrowthMaps, SchemaSnapshot, SchemaTableSnapshot, } from './pg-schema-snapshot/index.mts';
 export { buildOpenApiDocument, hashContractSchema, nodeToOpenApi, writeOpenApi, } from './openapi-document/index.mts';

package/dist/index.mjs

@@ -13,7 +13,7 @@ export { decodeSelectedFiles, encodeSelectedFiles, formatMultilineOutput, SELECT
 export { createArtifactClassifier, parseArtifactPatternsJson, planRunDeletions, runCleanup, sweepCleanup, } from './gha-artifacts-cleanup/index.mjs';
 export { validateOptionalHttpOrigin } from './http-origin/index.mjs';
 export { boundPendingLine, DEFAULT_MAX_PENDING_LINE_LENGTH, DEFAULT_TRUNCATED_LINE_MARKER, splitCompleteLines, } from './process-line-buffer/index.mjs';
-export { ProcessGroupDrainTimeoutError, runBrowserSession, } from './browser-session-runner/index.mjs';
+export { isProcessGroupAlive, ProcessGroupDrainTimeoutError, runBrowserSession, waitForProcessGroupExit, } from './browser-session-runner/index.mjs';
 export { buildSchemaSnapshot, detectRenamedIndexes, generateSchemaSnapshot, indexShapeKey, readSchemaCatalog, renderSchemaMarkdown, stableStringify, writeSchemaSnapshot, } from './pg-schema-snapshot/index.mjs';
 export { buildOpenApiDocument, hashContractSchema, nodeToOpenApi, writeOpenApi, } from './openapi-document/index.mjs';
 export { decide, deriveRetryAttempt } from './transient-retry/index.mjs';

package/dist/retrospective-transcript/codex-segment.d.mts

@@ -0,0 +1,2 @@
+import { type CodexSegment } from './shared.mts';
+export declare function segmentCodex(lines: string[]): CodexSegment | undefined;

package/dist/retrospective-transcript/codex-segment.mjs

@@ -0,0 +1,73 @@
+import { asNumber, asRecord, emptyTokens, parseLines, } from './shared.mjs';
+function hasInheritedParent(sessionMeta) {
+    const payload = asRecord(sessionMeta.payload);
+    return (asRecord(asRecord(payload?.source)?.subagent) !== undefined ||
+        typeof payload?.forked_from_id === 'string' ||
+        typeof payload?.parent_thread_id === 'string' ||
+        (typeof payload?.id === 'string' &&
+            typeof payload.session_id === 'string' &&
+            payload.id.toLowerCase() !== payload.session_id.toLowerCase()));
+}
+function isOwnedTaskStart(record, timestampMs) {
+    if (record.type !== 'event_msg')
+        return false;
+    const payload = asRecord(record.payload);
+    if (payload?.type !== 'task_started' || typeof payload.started_at !== 'number')
+        return false;
+    return payload.started_at >= 1_000_000_000_000
+        ? payload.started_at >= timestampMs
+        : payload.started_at >= Math.floor(timestampMs / 1000);
+}
+function usage(record) {
+    if (record.type !== 'event_msg')
+        return undefined;
+    const payload = asRecord(record.payload);
+    if (payload?.type !== 'token_count')
+        return undefined;
+    const totals = asRecord(asRecord(payload?.info)?.total_token_usage);
+    if (!totals)
+        return undefined;
+    return {
+        input: asNumber(totals.input_tokens),
+        output: asNumber(totals.output_tokens),
+        cacheRead: asNumber(totals.cached_input_tokens),
+        cacheCreation: 0,
+    };
+}
+function retainHighWater(previous, current) {
+    return {
+        input: Math.max(previous.input, current.input),
+        output: Math.max(previous.output, current.output),
+        cacheRead: Math.max(previous.cacheRead, current.cacheRead),
+        cacheCreation: 0,
+    };
+}
+export function segmentCodex(lines) {
+    const content = lines.filter(Boolean);
+    const sessionMeta = parseLines(content.slice(0, 1))[0];
+    if (sessionMeta?.type !== 'session_meta')
+        return { lines: content, baseline: emptyTokens() };
+    if (!hasInheritedParent(sessionMeta))
+        return { lines: content.slice(1), baseline: emptyTokens() };
+    const timestamp = asRecord(sessionMeta.payload)?.timestamp;
+    const timestampMs = typeof timestamp === 'string' ? Date.parse(timestamp) : Number.NaN;
+    if (!Number.isFinite(timestampMs))
+        return undefined;
+    const ownedIndex = content.findIndex((line, index) => {
+        if (index === 0)
+            return false;
+        const record = parseLines([line])[0];
+        return record ? isOwnedTaskStart(record, timestampMs) : false;
+    });
+    if (ownedIndex === -1)
+        return undefined;
+    let baseline;
+    for (const record of parseLines(content.slice(1, ownedIndex))) {
+        const current = usage(record);
+        if (current)
+            baseline = retainHighWater(baseline ?? emptyTokens(), current);
+    }
+    if (!baseline)
+        return undefined;
+    return { lines: content.slice(ownedIndex), baseline };
+}

package/dist/retrospective-transcript/codex.d.mts

@@ -7,5 +7,4 @@ export declare function codexIdentity(lines: string[]): {
     threadId?: string;
     agentPath: string;
 };
-export declare function withoutLeadingSessionMetadata(lines: string[]): string[];
 export declare function computeCodex(lines: string[], subagents?: CodexSegment[], baseline?: TokenTotals): TranscriptFacts;

package/dist/retrospective-transcript/codex.mjs

@@ -161,10 +161,6 @@ export function codexIdentity(lines) {
         agentPath: typeof payload?.agent_path === 'string' ? payload.agent_path : '/root',
     };
 }
-export function withoutLeadingSessionMetadata(lines) {
-    const content = lines.filter(Boolean);
-    return parseLines(content.slice(0, 1))[0]?.type === 'session_meta' ? content.slice(1) : content;
-}
 export function computeCodex(lines, subagents = [], baseline) {
     const facts = emptyFacts();
     applyRecords(parseLines(lines), facts, false, baseline);

package/dist/retrospective-transcript/index.mjs

@@ -2,10 +2,11 @@ import { existsSync, globSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { basename, dirname, join } from 'node:path';
-import { codexChildren, codexIdentity, computeCodex, withoutLeadingSessionMetadata, } from './codex.mjs';
+import { codexChildren, codexIdentity, computeCodex } from './codex.mjs';
+import { segmentCodex } from './codex-segment.mjs';
 import { computeClaude } from './claude.mjs';
 import { formatTranscriptFacts, formatUnavailable, sessionLabel } from './format.mjs';
-import { emptyFacts, emptyTokens, hasMalformedInteriorRecord, parseLines, } from './shared.mjs';
+import { emptyFacts, hasMalformedInteriorRecord, parseLines, } from './shared.mjs';
 export { codexChildren, codexIdentity } from './codex.mjs';
 export { formatTranscriptFacts, formatUnavailable } from './format.mjs';
 const SESSION_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
@@ -114,9 +115,11 @@ async function codexSubagents(lines, sessionsDir, ownerPath, visited = new Set()
             hasMalformedInteriorRecord(child) ||
             !matchesChildIdentity(child, edge.threadId, edge.agentPath))
             return undefined;
-        const content = withoutLeadingSessionMetadata(child);
-        result.push({ lines: content, baseline: emptyTokens() });
-        const nested = await codexSubagents(content, sessionsDir, edge.agentPath, visited);
+        const segment = segmentCodex(child);
+        if (!segment)
+            return undefined;
+        result.push(segment);
+        const nested = await codexSubagents(segment.lines, sessionsDir, edge.agentPath, visited);
         if (!nested)
             return undefined;
         result.push(...nested);
@@ -141,11 +144,14 @@ export async function runRetrospectiveTranscript(options) {
         return formatTranscriptFacts(resolved.sessionId, computeTranscriptFacts(lines, subagents.filter((value) => value !== undefined && schema(value) === 'claude' && !hasMalformedInteriorRecord(value))));
     }
     const identity = codexIdentity(lines);
+    const root = segmentCodex(lines);
+    if (!root)
+        return formatUnavailable('could not segment Codex transcript');
     const codexHome = (options.env ?? process.env).CODEX_HOME;
-    const subagents = await codexSubagents(lines, options.codexSessionsDir ??
+    const subagents = await codexSubagents(root.lines, options.codexSessionsDir ??
         (options.jsonlPath ? dirname(resolved.path) : undefined) ??
         join(codexHome || join(homedir(), '.codex'), 'sessions'), identity.agentPath, new Set([identity.threadId ?? resolved.sessionId].filter((threadId) => SESSION_ID.test(threadId))));
     if (!subagents)
         return formatUnavailable('could not resolve a referenced Codex child transcript');
-    return formatTranscriptFacts(resolved.sessionId, computeTranscriptFacts(withoutLeadingSessionMetadata(lines), subagents));
+    return formatTranscriptFacts(resolved.sessionId, computeCodex(root.lines, subagents, root.baseline));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vouchington-tooling",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Vouchington CLI and extractable tooling libraries.",
   "homepage": "https://github.com/vouchington/vouchington-tooling/tree/main/packages/vouchington-tooling#readme",
   "bugs": {