@excitedjs/agent-runtime-codex 0.5.0-beta.179 → 0.5.0-beta.183

package/dist/activity/budget.d.ts

@@ -0,0 +1,8 @@
+import { type ScanBudget } from '@excitedjs/dreamux-utils';
+export type CodexScanBudget = ScanBudget;
+export declare function createCodexScanBudget(input?: {
+    maxEntries?: number;
+    maxElapsedMs?: number;
+    now?: () => number;
+}): CodexScanBudget;
+//# sourceMappingURL=budget.d.ts.map

package/dist/activity/budget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"budget.d.ts","sourceRoot":"","sources":["../../src/activity/budget.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,UAAU,EAChB,MAAM,0BAA0B,CAAC;AAIlC,MAAM,MAAM,eAAe,GAAG,UAAU,CAAC;AAEzC,wBAAgB,qBAAqB,CAAC,KAAK,GAAE;IAC3C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACf,GAAG,eAAe,CASvB"}

package/dist/activity/budget.js

@@ -0,0 +1,9 @@
+import { createScanBudget, } from '@excitedjs/dreamux-utils';
+import { CodexActivityError } from './error.js';
+export function createCodexScanBudget(input = {}) {
+    return createScanBudget({
+        ...input,
+        limitError: () => new CodexActivityError('scan_unsupported', 'Codex activity read exceeded its bounded limit'),
+    });
+}
+//# sourceMappingURL=budget.js.map

package/dist/activity/budget.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"budget.js","sourceRoot":"","sources":["../../src/activity/budget.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,GAEjB,MAAM,0BAA0B,CAAC;AAElC,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAIhD,MAAM,UAAU,qBAAqB,CAAC,QAIlC,EAAE;IACJ,OAAO,gBAAgB,CAAC;QACtB,GAAG,KAAK;QACR,UAAU,EAAE,GAAG,EAAE,CACf,IAAI,kBAAkB,CACpB,kBAAkB,EAClB,gDAAgD,CACjD;KACJ,CAAC,CAAC;AACL,CAAC"}

package/dist/{transcript → activity}/cursor.d.ts

@@ -1,4 +1,4 @@
-import { transcriptDigest } from '@excitedjs/dreamux-utils';
+import { scanDigest } from '@excitedjs/dreamux-utils';
 export interface CodexCursorPosition {
     segment: number;
     offset: number;
@@ -19,5 +19,5 @@ export declare function encodeCodexCursor(input: {
     boundaryDigest: string;
 }): string;
 export declare function decodeCodexCursor(cursor: string, expectedFingerprint: string): CodexCursorEnvelope;
-export { transcriptDigest as digest };
+export { scanDigest as digest };
 //# sourceMappingURL=cursor.d.ts.map

package/dist/activity/cursor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cursor.d.ts","sourceRoot":"","sources":["../../src/activity/cursor.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,UAAU,EACX,MAAM,0BAA0B,CAAC;AAIlC,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,UAAU,mBAAmB;IAC3B,CAAC,EAAE,CAAC,CAAC;IACL,CAAC,EAAE,OAAO,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,mBAAmB,CAAC;IACzB,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,wBAAgB,qBAAqB,CAAC,YAAY,EAAE,OAAO,GAAG,MAAM,CAEnE;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE;IACvC,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,mBAAmB,CAAC;IAC9B,cAAc,EAAE,MAAM,CAAC;CACxB,GAAG,MAAM,CAUT;AAED,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,MAAM,EACd,mBAAmB,EAAE,MAAM,GAC1B,mBAAmB,CA0BrB;AAyBD,OAAO,EAAE,UAAU,IAAI,MAAM,EAAE,CAAC"}

package/dist/{transcript → activity}/cursor.js

@@ -1,7 +1,7 @@
-import { isTranscriptDigest, transcriptDigest, } from '@excitedjs/dreamux-utils';
-import { CodexTranscriptError } from './error.js';
+import { isScanDigest, scanDigest, } from '@excitedjs/dreamux-utils';
+import { CodexActivityError } from './error.js';
 export function codexQueryFingerprint(includeTools) {
-    return transcriptDigest(JSON.stringify({ include_tools: includeTools }));
+    return scanDigest(JSON.stringify({ include_tools: includeTools }));
 }
 export function encodeCodexCursor(input) {
     const envelope = {
@@ -23,13 +23,13 @@ export function decodeCodexCursor(cursor, expectedFingerprint) {
         value = JSON.parse(decoded.toString('utf8'));
     }
     catch (error) {
-        throw new CodexTranscriptError('cursor_invalid', 'Codex transcript cursor is invalid', { cause: error });
+        throw new CodexActivityError('cursor_invalid', 'Codex activity cursor is invalid', { cause: error });
     }
     if (!isCursorEnvelope(value)) {
-        throw new CodexTranscriptError('cursor_invalid', 'Codex transcript cursor is invalid');
+        throw new CodexActivityError('cursor_invalid', 'Codex activity cursor is invalid');
     }
     if (value.fp !== expectedFingerprint) {
-        throw new CodexTranscriptError('cursor_query_mismatch', 'Codex transcript cursor belongs to a different query');
+        throw new CodexActivityError('cursor_query_mismatch', 'Codex activity cursor belongs to a different query');
     }
     return value;
 }
@@ -42,9 +42,9 @@ function isCursorEnvelope(value) {
     return (Object.keys(record).length === 6 &&
         record['v'] === 1 &&
         record['p'] === 'codex' &&
-        isTranscriptDigest(record['fp']) &&
-        isTranscriptDigest(record['gen']) &&
-        isTranscriptDigest(record['bd']) &&
+        isScanDigest(record['fp']) &&
+        isScanDigest(record['gen']) &&
+        isScanDigest(record['bd']) &&
         position !== null &&
         typeof position === 'object' &&
         !Array.isArray(position) &&
@@ -53,5 +53,5 @@ function isCursorEnvelope(value) {
         Number.isSafeInteger(position['offset']) &&
         position['offset'] >= 0);
 }
-export { transcriptDigest as digest };
+export { scanDigest as digest };
 //# sourceMappingURL=cursor.js.map

package/dist/activity/cursor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cursor.js","sourceRoot":"","sources":["../../src/activity/cursor.ts"],"names":[],"mappings":"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"}

package/dist/activity/error.d.ts

@@ -0,0 +1,16 @@
+import type { AgentActivityError } from '@excitedjs/dreamux-types';
+/**
+ * Why a Codex activity read failed, at native granularity. This is internal
+ * control-flow vocabulary: only the public {@link AgentActivityError.reason} it
+ * projects crosses the provider seam.
+ */
+export type CodexActivityDetail = 'not_found' | 'session_mismatch' | 'locator_outside_root' | 'unreadable' | 'invalid' | 'scan_unsupported' | 'cursor_invalid' | 'cursor_query_mismatch' | 'cursor_stale';
+export declare class CodexActivityError extends Error implements AgentActivityError {
+    readonly detail: CodexActivityDetail;
+    readonly name = "AgentActivityError";
+    readonly reason: AgentActivityError['reason'];
+    constructor(detail: CodexActivityDetail, message: string, options?: {
+        cause?: unknown;
+    });
+}
+//# sourceMappingURL=error.d.ts.map

package/dist/activity/error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../../src/activity/error.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAEnE;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,GAC3B,WAAW,GACX,kBAAkB,GAClB,sBAAsB,GACtB,YAAY,GACZ,SAAS,GACT,kBAAkB,GAClB,gBAAgB,GAChB,uBAAuB,GACvB,cAAc,CAAC;AAiBnB,qBAAa,kBAAmB,SAAQ,KAAM,YAAW,kBAAkB;IAMvE,QAAQ,CAAC,MAAM,EAAE,mBAAmB;IALtC,QAAQ,CAAC,IAAI,wBAAwB;IAErC,QAAQ,CAAC,MAAM,EAAE,kBAAkB,CAAC,QAAQ,CAAC,CAAC;gBAGnC,MAAM,EAAE,mBAAmB,EACpC,OAAO,EAAE,MAAM,EACf,OAAO,GAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAO;CAKpC"}

package/dist/activity/error.js

@@ -0,0 +1,22 @@
+const PUBLIC_REASON = {
+    not_found: 'session_unavailable',
+    session_mismatch: 'session_unavailable',
+    locator_outside_root: 'session_unavailable',
+    unreadable: 'session_unavailable',
+    invalid: 'activity_corrupt',
+    scan_unsupported: 'provider_failure',
+    cursor_invalid: 'cursor_invalid',
+    cursor_query_mismatch: 'cursor_invalid',
+    cursor_stale: 'cursor_invalid',
+};
+export class CodexActivityError extends Error {
+    detail;
+    name = 'AgentActivityError';
+    reason;
+    constructor(detail, message, options = {}) {
+        super(message, options);
+        this.detail = detail;
+        this.reason = PUBLIC_REASON[detail];
+    }
+}
+//# sourceMappingURL=error.js.map

package/dist/activity/error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.js","sourceRoot":"","sources":["../../src/activity/error.ts"],"names":[],"mappings":"AAkBA,MAAM,aAAa,GAGf;IACF,SAAS,EAAE,qBAAqB;IAChC,gBAAgB,EAAE,qBAAqB;IACvC,oBAAoB,EAAE,qBAAqB;IAC3C,UAAU,EAAE,qBAAqB;IACjC,OAAO,EAAE,kBAAkB;IAC3B,gBAAgB,EAAE,kBAAkB;IACpC,cAAc,EAAE,gBAAgB;IAChC,qBAAqB,EAAE,gBAAgB;IACvC,YAAY,EAAE,gBAAgB;CAC/B,CAAC;AAEF,MAAM,OAAO,kBAAmB,SAAQ,KAAK;IAMhC;IALF,IAAI,GAAG,oBAAoB,CAAC;IAE5B,MAAM,CAA+B;IAE9C,YACW,MAA2B,EACpC,OAAe,EACf,UAA+B,EAAE;QAEjC,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QAJf,WAAM,GAAN,MAAM,CAAqB;QAKpC,IAAI,CAAC,MAAM,GAAG,aAAa,CAAC,MAAM,CAAC,CAAC;IACtC,CAAC;CACF"}

package/dist/activity/opened-file.d.ts

@@ -0,0 +1,10 @@
+import { type FileHandle } from 'node:fs/promises';
+export interface CodexOpenedRollout {
+    handle: FileHandle;
+    path: string;
+    size: number;
+    dev: number | bigint;
+    ino: number | bigint;
+}
+export declare function openCodexRollout(candidate: string, canonicalRoots: readonly string[]): Promise<CodexOpenedRollout>;
+//# sourceMappingURL=opened-file.d.ts.map

package/dist/activity/opened-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opened-file.d.ts","sourceRoot":"","sources":["../../src/activity/opened-file.ts"],"names":[],"mappings":"AACA,OAAO,EAAkB,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAMnE,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,UAAU,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;IACrB,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;CACtB;AAED,wBAAsB,gBAAgB,CACpC,SAAS,EAAE,MAAM,EACjB,cAAc,EAAE,SAAS,MAAM,EAAE,GAChC,OAAO,CAAC,kBAAkB,CAAC,CA4D7B"}

package/dist/{transcript → activity}/opened-file.js

@@ -1,8 +1,8 @@
 import { constants } from 'node:fs';
 import { open, realpath } from 'node:fs/promises';
 import { isPathWithin } from '@excitedjs/dreamux-utils';
-import { CodexTranscriptError } from './error.js';
-export async function openCodexTranscript(candidate, canonicalRoots) {
+import { CodexActivityError } from './error.js';
+export async function openCodexRollout(candidate, canonicalRoots) {
     let handle;
     try {
         handle = await open(candidate, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
@@ -16,10 +16,10 @@ export async function openCodexTranscript(candidate, canonicalRoots) {
             realpath(candidate),
         ]);
         if (!opened.isFile()) {
-            throw new CodexTranscriptError('invalid', 'Codex transcript is not a regular file');
+            throw new CodexActivityError('invalid', 'Codex activity source is not a regular file');
         }
         if (!canonicalRoots.some((root) => isPathWithin(root, canonicalPath))) {
-            throw new CodexTranscriptError('locator_outside_root', 'Codex transcript locator is outside the native transcript roots');
+            throw new CodexActivityError('locator_outside_root', 'Codex activity is unavailable for this session');
         }
         const current = await open(canonicalPath, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0)).catch((error) => {
             throw classifyOpenError(error);
@@ -27,7 +27,7 @@ export async function openCodexTranscript(candidate, canonicalRoots) {
         try {
             const currentStat = await current.stat();
             if (opened.dev !== currentStat.dev || opened.ino !== currentStat.ino) {
-                throw new CodexTranscriptError('unreadable', 'Codex transcript changed while opening');
+                throw new CodexActivityError('unreadable', 'Codex activity source changed while opening');
             }
         }
         finally {
@@ -43,19 +43,19 @@ export async function openCodexTranscript(candidate, canonicalRoots) {
     }
     catch (error) {
         await handle.close().catch(() => undefined);
-        if (error instanceof CodexTranscriptError)
+        if (error instanceof CodexActivityError)
             throw error;
-        throw new CodexTranscriptError('unreadable', 'Codex transcript is unreadable', { cause: error });
+        throw new CodexActivityError('unreadable', 'Codex activity is unreadable', { cause: error });
     }
 }
 function classifyOpenError(error) {
     const code = error.code;
     if (code === 'ENOENT') {
-        return new CodexTranscriptError('not_found', 'Codex transcript is unavailable', { cause: error });
+        return new CodexActivityError('not_found', 'Codex activity is unavailable for this session', { cause: error });
     }
     if (code === 'ELOOP') {
-        return new CodexTranscriptError('locator_outside_root', 'Codex transcript locator is outside the native transcript roots', { cause: error });
+        return new CodexActivityError('locator_outside_root', 'Codex activity is unavailable for this session', { cause: error });
     }
-    return new CodexTranscriptError('unreadable', 'Codex transcript is unreadable', { cause: error });
+    return new CodexActivityError('unreadable', 'Codex activity is unreadable', { cause: error });
 }
 //# sourceMappingURL=opened-file.js.map

package/dist/activity/opened-file.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"opened-file.js","sourceRoot":"","sources":["../../src/activity/opened-file.ts"],"names":[],"mappings":"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"}

package/dist/activity/path.d.ts

@@ -0,0 +1,27 @@
+import type { DreamuxEnvironment } from '@excitedjs/dreamux-types';
+import { type CodexScanBudget } from './budget.js';
+import { type CodexOpenedRollout } from './opened-file.js';
+export interface CodexRolloutRoots {
+    home: string;
+    sessions: string;
+    archived: string;
+}
+export interface CodexValidatedRollout {
+    path: string;
+    root: string;
+    sessionId: string;
+    rolloutId: string;
+    historyBase: CodexHistoryBase | null;
+    dev: number | bigint;
+    ino: number | bigint;
+}
+export interface CodexHistoryBase {
+    rolloutId: string;
+    endByteOffset: number;
+}
+export declare function resolveCodexRolloutRoots(env?: DreamuxEnvironment): Promise<CodexRolloutRoots>;
+export declare function validateCodexRolloutPath(candidate: string, expectedSessionId: string, roots: CodexRolloutRoots): Promise<CodexValidatedRollout>;
+export declare function locateCodexRollout(locator: string | null | undefined, expectedSessionId: string, roots: CodexRolloutRoots, budget?: CodexScanBudget): Promise<CodexValidatedRollout>;
+export declare function findCodexRolloutById(roots: CodexRolloutRoots, rolloutId: string, budget?: CodexScanBudget): Promise<CodexValidatedRollout>;
+export declare function readCodexRolloutText(opened: CodexOpenedRollout, maxDecodedBytes: number): Promise<string>;
+//# sourceMappingURL=path.d.ts.map

package/dist/activity/path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path.d.ts","sourceRoot":"","sources":["../../src/activity/path.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAGnE,OAAO,EAEL,KAAK,eAAe,EACrB,MAAM,aAAa,CAAC;AAErB,OAAO,EAEL,KAAK,kBAAkB,EACxB,MAAM,kBAAkB,CAAC;AAM1B,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,gBAAgB,GAAG,IAAI,CAAC;IACrC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;IACrB,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,wBAAsB,wBAAwB,CAC5C,GAAG,GAAE,kBAAgC,GACpC,OAAO,CAAC,iBAAiB,CAAC,CAuC5B;AAED,wBAAsB,wBAAwB,CAC5C,SAAS,EAAE,MAAM,EACjB,iBAAiB,EAAE,MAAM,EACzB,KAAK,EAAE,iBAAiB,GACvB,OAAO,CAAC,qBAAqB,CAAC,CAMhC;AAED,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAClC,iBAAiB,EAAE,MAAM,EACzB,KAAK,EAAE,iBAAiB,EACxB,MAAM,GAAE,eAAyC,GAChD,OAAO,CAAC,qBAAqB,CAAC,CA4ChC;AAED,wBAAsB,oBAAoB,CACxC,KAAK,EAAE,iBAAiB,EACxB,SAAS,EAAE,MAAM,EACjB,MAAM,GAAE,eAAyC,GAChD,OAAO,CAAC,qBAAqB,CAAC,CA2BhC;AAED,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,kBAAkB,EAC1B,eAAe,EAAE,MAAM,GACtB,OAAO,CAAC,MAAM,CAAC,CAwCjB"}

package/dist/{transcript → activity}/path.js

@@ -1,19 +1,18 @@
-import { isAbsolute as isAbsolutePath } from 'node:path';
 import { opendir, realpath, stat } from 'node:fs/promises';
-import { basename, dirname, isAbsolute, join, relative, resolve, } from 'node:path';
+import { basename, isAbsolute, join, resolve } from 'node:path';
 import { createZstdDecompress } from 'node:zlib';
 import { isPathWithin } from '@excitedjs/dreamux-utils';
-import { createCodexTranscriptBudget, } from './budget.js';
-import { CodexTranscriptError } from './error.js';
-import { openCodexTranscript, } from './opened-file.js';
+import { createCodexScanBudget, } from './budget.js';
+import { CodexActivityError } from './error.js';
+import { openCodexRollout, } from './opened-file.js';
 const ROLLOUT_FILENAME = /^rollout-[^/]+-[0-9a-f-]{36}(?:_[0-9a-f-]{36})?\.jsonl(?:\.zst)?$/i;
 const MAX_METADATA_BYTES = 1_048_576;
-export async function resolveCodexTranscriptRoots(env = process.env) {
+export async function resolveCodexRolloutRoots(env = process.env) {
     const configured = env['CODEX_HOME'];
     let home;
     if (configured !== undefined) {
-        if (!isAbsolutePath(configured)) {
-            throw new CodexTranscriptError('invalid', 'Explicit Codex home must be an absolute directory');
+        if (!isAbsolute(configured)) {
+            throw new CodexActivityError('invalid', 'Explicit Codex home must be an absolute directory');
         }
         let info;
         try {
@@ -23,7 +22,7 @@ export async function resolveCodexTranscriptRoots(env = process.env) {
             throw classifyRootError(error);
         }
         if (!info.isDirectory()) {
-            throw new CodexTranscriptError('invalid', 'Explicit Codex home must be a directory');
+            throw new CodexActivityError('invalid', 'Explicit Codex home must be a directory');
         }
         home = await realpath(configured).catch((error) => {
             throw classifyRootError(error);
@@ -44,48 +43,21 @@ export async function resolveCodexTranscriptRoots(env = process.env) {
         archived: join(home, 'archived_sessions'),
     };
 }
-export async function validateCodexThreadPath(candidate, expectedSessionId, roots) {
-    try {
-        return await validateCodexTranscriptLocator(candidate, expectedSessionId, roots);
-    }
-    catch (error) {
-        if (!(error instanceof CodexTranscriptError) ||
-            error.reason !== 'not_found') {
-            throw error;
-        }
-    }
-    assertNativeRolloutPath(candidate);
-    const rolloutId = rolloutIdFromPath(candidate);
-    if (threadIdFromPath(candidate).toLowerCase() !==
-        expectedSessionId.toLowerCase()) {
-        throw new CodexTranscriptError('session_mismatch', 'Codex transcript does not belong to the selected session');
-    }
-    const canonicalPath = await canonicalProspectivePath(candidate, roots);
-    return {
-        path: canonicalPath,
-        root: canonicalRootsForProspectivePath(canonicalPath, roots),
-        sessionId: expectedSessionId,
-        rolloutId,
-        historyBase: null,
-        dev: -1,
-        ino: -1,
-    };
-}
-export async function validateCodexTranscriptLocator(candidate, expectedSessionId, roots) {
-    return validateCodexTranscript({
+export async function validateCodexRolloutPath(candidate, expectedSessionId, roots) {
+    return validateCodexRollout({
         candidate,
         roots,
         expectedSessionId,
     });
 }
-export async function locateCodexTranscript(locator, expectedSessionId, roots, budget = createCodexTranscriptBudget()) {
+export async function locateCodexRollout(locator, expectedSessionId, roots, budget = createCodexScanBudget()) {
     if (locator !== null && locator !== undefined) {
         try {
-            return await validateCodexTranscriptLocator(locator, expectedSessionId, roots);
+            return await validateCodexRolloutPath(locator, expectedSessionId, roots);
         }
         catch (error) {
-            if (!(error instanceof CodexTranscriptError) ||
-                error.reason !== 'not_found') {
+            if (!(error instanceof CodexActivityError) ||
+                error.detail !== 'not_found') {
                 throw error;
             }
         }
@@ -93,46 +65,46 @@ export async function locateCodexTranscript(locator, expectedSessionId, roots, b
     const candidates = await discoverRollouts(roots, expectedSessionId, budget);
     for (const candidate of candidates) {
         try {
-            return await validateCodexTranscriptLocator(candidate, expectedSessionId, roots);
+            return await validateCodexRolloutPath(candidate, expectedSessionId, roots);
         }
         catch (error) {
-            if (error instanceof CodexTranscriptError &&
-                (error.reason === 'session_mismatch' ||
-                    error.reason === 'not_found')) {
+            if (error instanceof CodexActivityError &&
+                (error.detail === 'session_mismatch' ||
+                    error.detail === 'not_found')) {
                 continue;
             }
             throw error;
         }
     }
-    throw new CodexTranscriptError('not_found', 'Codex transcript is unavailable');
+    throw new CodexActivityError('not_found', 'Codex activity is unavailable for this session');
 }
-export async function findCodexRolloutById(roots, rolloutId, budget = createCodexTranscriptBudget()) {
+export async function findCodexRolloutById(roots, rolloutId, budget = createCodexScanBudget()) {
     const candidates = await discoverRollouts(roots, rolloutId, budget);
     for (const candidate of candidates) {
         if (!basename(candidate).toLowerCase().includes(rolloutId.toLowerCase())) {
             continue;
         }
         try {
-            return await validateCodexTranscript({
+            return await validateCodexRollout({
                 candidate,
                 roots,
                 expectedRolloutId: rolloutId,
             });
         }
         catch (error) {
-            if (error instanceof CodexTranscriptError &&
-                (error.reason === 'session_mismatch' ||
-                    error.reason === 'not_found')) {
+            if (error instanceof CodexActivityError &&
+                (error.detail === 'session_mismatch' ||
+                    error.detail === 'not_found')) {
                 continue;
             }
             throw error;
         }
     }
-    throw new CodexTranscriptError('not_found', 'Codex transcript lineage is unavailable');
+    throw new CodexActivityError('not_found', 'Codex activity history is unavailable');
 }
-export async function readCodexTranscriptText(opened, maxDecodedBytes) {
+export async function readCodexRolloutText(opened, maxDecodedBytes) {
     if (opened.path.endsWith('.zst') && opened.size > maxDecodedBytes) {
-        throw new CodexTranscriptError('scan_unsupported', 'Codex compressed transcript requires a native read index');
+        throw new CodexActivityError('scan_unsupported', 'Codex activity requires a native read index');
     }
     const source = opened.handle.createReadStream({
         autoClose: false,
@@ -148,15 +120,15 @@ export async function readCodexTranscriptText(opened, maxDecodedBytes) {
             const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
             decodedBytes += buffer.length;
             if (decodedBytes > maxDecodedBytes) {
-                throw new CodexTranscriptError('scan_unsupported', 'Codex transcript exceeds the bounded scan limit');
+                throw new CodexActivityError('scan_unsupported', 'Codex activity exceeds the bounded limit');
             }
             chunks.push(buffer);
         }
     }
     catch (error) {
-        if (error instanceof CodexTranscriptError)
+        if (error instanceof CodexActivityError)
             throw error;
-        throw new CodexTranscriptError('unreadable', 'Codex transcript is unreadable', { cause: error });
+        throw new CodexActivityError('unreadable', 'Codex activity is unreadable', { cause: error });
     }
     finally {
         stream.destroy();
@@ -196,15 +168,15 @@ async function readCodexSessionMetadata(opened) {
         }
     }
     catch (error) {
-        if (error instanceof CodexTranscriptError)
+        if (error instanceof CodexActivityError)
             throw error;
-        throw new CodexTranscriptError('unreadable', 'Codex transcript metadata is unreadable', { cause: error });
+        throw new CodexActivityError('unreadable', 'Codex activity metadata is unreadable', { cause: error });
     }
     finally {
         stream.destroy();
         source.destroy();
     }
-    throw new CodexTranscriptError('invalid', 'Codex transcript metadata is invalid');
+    throw new CodexActivityError('invalid', 'Codex activity metadata is invalid');
 }
 async function discoverRollouts(roots, id, budget) {
     const matches = [];
@@ -219,7 +191,7 @@ async function discoverRollouts(roots, id, budget) {
             catch (error) {
                 if (error.code === 'ENOENT')
                     continue;
-                throw new CodexTranscriptError('unreadable', 'Codex transcript directory is unreadable', { cause: error });
+                throw new CodexActivityError('unreadable', 'Codex activity source is unreadable', { cause: error });
             }
             try {
                 for await (const entry of opened) {
@@ -235,11 +207,11 @@ async function discoverRollouts(roots, id, budget) {
                 }
             }
             catch (error) {
-                if (error instanceof CodexTranscriptError)
+                if (error instanceof CodexActivityError)
                     throw error;
                 if (error.code === 'ENOENT')
                     continue;
-                throw new CodexTranscriptError('unreadable', 'Codex transcript directory is unreadable', { cause: error });
+                throw new CodexActivityError('unreadable', 'Codex activity source is unreadable', { cause: error });
             }
         }
     }
@@ -256,11 +228,11 @@ async function existingRepresentation(path) {
         }
         catch (error) {
             if (error.code !== 'ENOENT') {
-                throw new CodexTranscriptError('unreadable', 'Codex transcript path is unreadable', { cause: error });
+                throw new CodexActivityError('unreadable', 'Codex activity source is unreadable', { cause: error });
             }
         }
     }
-    throw new CodexTranscriptError('not_found', 'Codex transcript is unavailable');
+    throw new CodexActivityError('not_found', 'Codex activity is unavailable for this session');
 }
 async function canonicalExistingRoots(roots) {
     const result = [];
@@ -268,31 +240,31 @@ async function canonicalExistingRoots(roots) {
         const canonical = await realpath(root).catch((error) => {
             if (error.code === 'ENOENT')
                 return null;
-            throw new CodexTranscriptError('unreadable', 'Codex transcript root is unreadable', { cause: error });
+            throw new CodexActivityError('unreadable', 'Codex activity source is unreadable', { cause: error });
         });
         if (canonical !== null)
             result.push(canonical);
     }
     if (result.length === 0) {
-        throw new CodexTranscriptError('not_found', 'Codex transcript roots are unavailable');
+        throw new CodexActivityError('not_found', 'Codex activity is unavailable');
     }
     return result;
 }
-async function validateCodexTranscript(input) {
+async function validateCodexRollout(input) {
     assertNativeRolloutPath(input.candidate);
     const existing = await existingRepresentation(input.candidate);
     const canonicalRoots = await canonicalExistingRoots(input.roots);
-    const opened = await openCodexTranscript(existing, canonicalRoots);
+    const opened = await openCodexRollout(existing, canonicalRoots);
     try {
         const rolloutId = rolloutIdFromPath(opened.path);
         if (input.expectedRolloutId !== undefined &&
             rolloutId.toLowerCase() !== input.expectedRolloutId.toLowerCase()) {
-            throw new CodexTranscriptError('session_mismatch', 'Codex transcript rollout identity does not match');
+            throw new CodexActivityError('session_mismatch', 'Codex activity identity does not match');
         }
         const metadata = await readCodexSessionMetadata(opened);
         if (input.expectedSessionId !== undefined &&
             metadata.sessionId !== input.expectedSessionId) {
-            throw new CodexTranscriptError('session_mismatch', 'Codex transcript does not belong to the selected session');
+            throw new CodexActivityError('session_mismatch', 'Codex activity does not belong to the selected session');
         }
         return {
             path: opened.path,
@@ -308,11 +280,6 @@ async function validateCodexTranscript(input) {
         await opened.handle.close();
     }
 }
-function canonicalRootsForProspectivePath(candidate, roots) {
-    return isPathWithin(roots.sessions, candidate)
-        ? roots.sessions
-        : roots.archived;
-}
 function metadataFromLine(line) {
     const value = parseObject(line);
     if (value?.['type'] !== 'session_meta')
@@ -321,7 +288,7 @@ function metadataFromLine(line) {
     const meta = asRecord(payload?.['meta']) ?? payload;
     const id = stringValue(meta?.['id']) ?? stringValue(meta?.['session_id']);
     if (id === null) {
-        throw new CodexTranscriptError('invalid', 'Codex transcript metadata is invalid');
+        throw new CodexActivityError('invalid', 'Codex activity metadata is invalid');
     }
     const historyBaseRecord = asRecord(meta?.['history_base']);
     const rolloutId = stringValue(historyBaseRecord?.['thread_id']);
@@ -334,67 +301,30 @@ function metadataFromLine(line) {
     };
 }
 function metadataTooLarge() {
-    return new CodexTranscriptError('invalid', 'Codex transcript metadata exceeds its bounded record size');
+    return new CodexActivityError('invalid', 'Codex activity metadata exceeds its bounded record size');
 }
 function classifyRootError(error) {
-    return new CodexTranscriptError(error.code === 'ENOENT'
+    return new CodexActivityError(error.code === 'ENOENT'
         ? 'not_found'
         : 'unreadable', 'Codex home directory is unavailable', { cause: error });
 }
-async function canonicalProspectivePath(candidate, roots) {
-    const canonicalCandidate = await canonicalizeProspectivePath(candidate);
-    const canonicalRoots = await Promise.all([roots.sessions, roots.archived].map(canonicalizeProspectivePath));
-    if (!canonicalRoots.some((root) => isPathWithin(root, canonicalCandidate))) {
-        throw new CodexTranscriptError('locator_outside_root', 'Codex transcript locator is outside the native transcript roots');
-    }
-    return canonicalCandidate;
-}
-async function canonicalizeProspectivePath(path) {
-    const absolutePath = resolve(path);
-    let ancestor = absolutePath;
-    while (true) {
-        const canonicalAncestor = await realpathIfExists(ancestor);
-        if (canonicalAncestor !== null) {
-            return resolve(canonicalAncestor, relative(ancestor, absolutePath));
-        }
-        const parent = dirname(ancestor);
-        if (parent === ancestor) {
-            throw new CodexTranscriptError('not_found', 'Codex transcript root is unavailable');
-        }
-        ancestor = parent;
-    }
-}
-async function realpathIfExists(path) {
-    try {
-        return await realpath(path);
-    }
-    catch (error) {
-        if (error.code === 'ENOENT')
-            return null;
-        throw new CodexTranscriptError('unreadable', 'Codex transcript path is unreadable', { cause: error });
-    }
-}
 function rolloutIdFromPath(path) {
     const ids = rolloutIdsFromPath(path);
     return ids.at(-1) ?? basename(path);
 }
-function threadIdFromPath(path) {
-    const ids = rolloutIdsFromPath(path);
-    return ids[0] ?? basename(path);
-}
 function rolloutIdsFromPath(path) {
     const name = basename(path).replace(/\.jsonl(?:\.zst)?$/, '');
     return name.match(/[0-9a-f]{8}-[0-9a-f-]{27}/gi) ?? [];
 }
 function assertNativeRolloutPath(candidate) {
     if (!isAbsolute(candidate) || !ROLLOUT_FILENAME.test(basename(candidate))) {
-        throw new CodexTranscriptError('invalid', 'Codex transcript locator is not a native rollout path');
+        throw new CodexActivityError('invalid', 'Codex activity source is not a native rollout path');
     }
 }
 function homeDirectory(env) {
     const value = env['HOME'];
     if (value === undefined || value === '') {
-        throw new CodexTranscriptError('not_found', 'Codex home directory is unavailable');
+        throw new CodexActivityError('not_found', 'Codex home directory is unavailable');
     }
     return value;
 }