agent-afk 5.341.0 → 5.343.0

package/dist/agent/effect-ledger/store.d.ts

@@ -1,3 +1,4 @@
+import { type InputBudget } from '../outcomes/outcomes-input.js';
 import type { EffectRecord, EffectQuery, PendingEffectInput, ExecuteEffectInput } from './types.js';
 export declare class EffectStore {
     private readonly path;
@@ -12,3 +13,9 @@ export declare class EffectStore {
     query(filters?: EffectQuery): Promise<EffectRecord[]>;
     all(): Promise<EffectRecord[]>;
 }
+export interface ReadEffectsForSessionOptions {
+    path?: string;
+    maxRecords?: number;
+    budget?: InputBudget;
+}
+export declare function readEffectsForSession(sessionId: string, opts?: ReadEffectsForSessionOptions): Promise<EffectRecord[]>;

package/dist/agent/episodes/extract.d.ts

@@ -0,0 +1,2 @@
+import type { EpisodeInput } from './types.js';
+export declare function extractEpisodeInput(sessionId: string): EpisodeInput;

package/dist/agent/episodes/index.d.ts

@@ -0,0 +1,6 @@
+export type { EpisodeRecord, EpisodeInput } from './types.js';
+export { extractEpisodeInput } from './extract.js';
+export { synthesizeEpisode } from './synthesize.js';
+export { writeEpisode, formatEpisodeContent, sanitizeNarrative } from './writer.js';
+import type { EpisodeRecord } from './types.js';
+export declare function synthesizeAndWriteEpisode(sessionId: string): Promise<EpisodeRecord>;

package/dist/agent/episodes/session-end-hook.d.ts

@@ -0,0 +1,2 @@
+import type { HookHandler } from '../hooks.js';
+export declare function createEpisodeSessionEndHook(): HookHandler;

package/dist/agent/episodes/synthesize.d.ts

@@ -0,0 +1,2 @@
+import type { EpisodeInput, EpisodeRecord } from './types.js';
+export declare function synthesizeEpisode(input: EpisodeInput): Promise<EpisodeRecord>;

package/dist/agent/episodes/types.d.ts

@@ -0,0 +1,24 @@
+export interface EpisodeRecord {
+    sessionId: string;
+    goal: string;
+    approach: string;
+    pivots: string[];
+    decisions: string[];
+    outcome: string;
+    openQuestions: string[];
+    filesKey: string[];
+    tags: string[];
+    narrative: string;
+    synthesizedAt: string;
+}
+export interface EpisodeInput {
+    sessionId: string;
+    firstUserMessage: string;
+    markSequence: string[];
+    toolsUsed: string[];
+    toolErrors: string[];
+    lastAssistantMessage: string;
+    facetSummary?: string;
+    durationMs?: number;
+    costUsd?: number;
+}

package/dist/agent/episodes/writer.d.ts

@@ -0,0 +1,4 @@
+import type { EpisodeRecord } from './types.js';
+export declare function sanitizeNarrative(text: string): string;
+export declare function formatEpisodeContent(episode: EpisodeRecord): string;
+export declare function writeEpisode(episode: EpisodeRecord, memoryDir?: string): Promise<void>;

package/dist/agent/facets/derive.aggregate.d.ts

@@ -2,6 +2,7 @@ import { type SubagentInvocation, type ToolEventInput } from './schema.js';
 export declare const EVIDENCE_CAP = 50;
 export declare function parseInput(input: string | undefined): Record<string, unknown> | undefined;
 export declare function asString(v: unknown): string | undefined;
+export declare function patchApplyPaths(parsed: Record<string, unknown> | undefined): string[];
 export declare function dedupeToolEvents(events: ToolEventInput[]): ToolEventInput[];
 export interface AggregateToolEventsResult {
     toolCounts: Record<string, number>;

package/dist/agent/facets/journal-adapter.d.ts

@@ -2,6 +2,7 @@ import type { SubagentToolSummary, ToolEventInput } from './schema.js';
 import type { JournalRecord } from '../journal/types.js';
 export interface JournalAdapterOptions {
     resultTextCap?: number;
+    checkBudget?: () => void;
 }
 export declare function journalRecordsToToolEvents(records: readonly JournalRecord[], options?: JournalAdapterOptions): ToolEventInput[];
 export declare function summarizeSubagentJournal(subagentId: string, records: readonly JournalRecord[]): SubagentToolSummary;

package/dist/agent/outcomes/commit-survival-artifacts.d.ts

@@ -0,0 +1,6 @@
+import type { Artifacts, Vote } from './schema.js';
+import { type CheckAncestor, type CheckRevert } from './lf-delayed.js';
+export declare function commitSurvivalForArtifacts(artifacts: Artifacts, deps: {
+    checkAncestor: CheckAncestor;
+    checkRevert: CheckRevert;
+}, now: string): Promise<Vote[]>;

package/dist/agent/outcomes/compute-outcomes.d.ts

@@ -0,0 +1,21 @@
+import type { EffectRecord } from '../effect-ledger/types.js';
+import type { ToolEventInput } from '../facets/schema.js';
+import { type OutcomeCommit, type OutcomeSchedule, type OutcomesV1 } from './outcomes-v1.schema.js';
+export interface GitLogEntry {
+    sha: string;
+    subject: string;
+    repo: string;
+}
+export interface ComputeOutcomesInput {
+    cwd: string;
+    startHead: string | null;
+    endHead: string | null;
+    gitLog?: readonly GitLogEntry[];
+    ledgerEntries: readonly (EffectRecord | unknown)[];
+    toolEvents: readonly ToolEventInput[];
+    lastAssistantMessage: string | null;
+}
+export declare function mergeCommits(gitLog: readonly OutcomeCommit[], ledger: readonly OutcomeCommit[]): OutcomeCommit[];
+export declare function filesFromToolEvents(events: readonly ToolEventInput[], cwd: string): string[];
+export declare function schedulesFromToolEvents(events: readonly ToolEventInput[]): OutcomeSchedule[];
+export declare function computeOutcomes(input: ComputeOutcomesInput): OutcomesV1;

package/dist/agent/outcomes/git-range.d.ts

@@ -0,0 +1,6 @@
+import type { GitLogEntry } from './compute-outcomes.js';
+export interface GitLogRangeOptions {
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
+export declare function gitLogRange(cwd: string, startHead: string | null, endHead: string | null, opts?: GitLogRangeOptions): Promise<GitLogEntry[]>;

package/dist/agent/outcomes/index.d.ts

@@ -5,3 +5,8 @@ export { lfPrFate, lfCommitSurvival } from './lf-delayed.js';
 export { combine } from './combine.js';
 export { createOutcomeSessionEndHook } from './session-end-hook.js';
 export { createChildAttributionHook } from './child-attribution.js';
+export { computeOutcomes } from './compute-outcomes.js';
+export type { ComputeOutcomesInput, GitLogEntry } from './compute-outcomes.js';
+export { gitLogRange } from './git-range.js';
+export { OutcomesV1Schema } from './outcomes-v1.schema.js';
+export type { OutcomesV1 } from './outcomes-v1.schema.js';

package/dist/agent/outcomes/outcomes-input.d.ts

@@ -0,0 +1,22 @@
+import type { SessionMeta } from '../session/session-meta.js';
+export interface InputBudget {
+    signal: AbortSignal;
+    deadline: number;
+}
+export declare function checkBudget(budget: InputBudget): void;
+export declare function boundedLines(path: string, budget: InputBudget, maxBytes?: number): AsyncGenerator<string>;
+export declare function readOutcomesMeta(sessionId: string, budget: InputBudget): Promise<SessionMeta | null>;
+export declare function readOutcomesJournal(sessionId: string, budget: InputBudget): Promise<{
+    toolEvents: {
+        [x: string]: unknown;
+        toolName: string;
+        toolUseId?: string | undefined;
+        input?: string | undefined;
+        inputRaw?: string | undefined;
+        result?: string | undefined;
+        isError?: boolean | undefined;
+        incomplete?: boolean | undefined;
+        partialNodeCount?: number | undefined;
+    }[];
+    lastAssistantMessage: string | null;
+}>;

package/dist/agent/outcomes/outcomes-ledger.d.ts

@@ -0,0 +1,13 @@
+import type { OutcomeCommit, OutcomePr, OutcomeService, PrAction } from './outcomes-v1.schema.js';
+interface LedgerEffect {
+    command: string;
+    result: string;
+}
+export declare function settledEffects(entries: readonly unknown[]): LedgerEffect[];
+export declare function repoFromCommand(command: string, cwd: string): string;
+export declare function ledgerCommits(effects: readonly LedgerEffect[], cwd: string): OutcomeCommit[];
+export declare function prActionFromCommand(command: string): PrAction;
+export declare function addPr(list: OutcomePr[], pr: OutcomePr): void;
+export declare function ledgerPrs(effects: readonly LedgerEffect[]): OutcomePr[];
+export declare function ledgerServices(effects: readonly LedgerEffect[]): OutcomeService[];
+export {};

package/dist/agent/outcomes/outcomes-v1.schema.d.ts

@@ -0,0 +1,93 @@
+import { z } from 'zod';
+export declare const OUTCOMES_COMMITS_CAP = 200;
+export declare const OUTCOMES_PRS_CAP = 50;
+export declare const OUTCOMES_FILES_CAP = 500;
+export declare const ShaSchema: z.ZodString;
+export declare const OutcomeCommitSchema: z.ZodObject<{
+    sha: z.ZodString;
+    repo: z.ZodString;
+    subject: z.ZodString;
+    source: z.ZodEnum<{
+        tool_result: "tool_result";
+        git_log: "git_log";
+        effect_ledger: "effect_ledger";
+    }>;
+}, z.core.$strip>;
+export type OutcomeCommit = z.infer<typeof OutcomeCommitSchema>;
+export declare const PrActionSchema: z.ZodEnum<{
+    unknown: "unknown";
+    create: "create";
+    merge: "merge";
+    update: "update";
+}>;
+export type PrAction = z.infer<typeof PrActionSchema>;
+export declare const OutcomePrSchema: z.ZodObject<{
+    url: z.ZodString;
+    action: z.ZodEnum<{
+        unknown: "unknown";
+        create: "create";
+        merge: "merge";
+        update: "update";
+    }>;
+}, z.core.$strip>;
+export type OutcomePr = z.infer<typeof OutcomePrSchema>;
+export declare const OutcomeScheduleSchema: z.ZodObject<{
+    id: z.ZodString;
+    action: z.ZodEnum<{
+        cancel: "cancel";
+        create: "create";
+        update: "update";
+    }>;
+}, z.core.$strip>;
+export type OutcomeSchedule = z.infer<typeof OutcomeScheduleSchema>;
+export declare const OutcomeServiceSchema: z.ZodObject<{
+    name: z.ZodString;
+    action: z.ZodString;
+}, z.core.$strip>;
+export type OutcomeService = z.infer<typeof OutcomeServiceSchema>;
+export declare const OutcomesV1Schema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    cwd: z.ZodString;
+    startHead: z.ZodNullable<z.ZodString>;
+    endHead: z.ZodNullable<z.ZodString>;
+    commits: z.ZodArray<z.ZodObject<{
+        sha: z.ZodString;
+        repo: z.ZodString;
+        subject: z.ZodString;
+        source: z.ZodEnum<{
+            tool_result: "tool_result";
+            git_log: "git_log";
+            effect_ledger: "effect_ledger";
+        }>;
+    }, z.core.$strip>>;
+    prs: z.ZodArray<z.ZodObject<{
+        url: z.ZodString;
+        action: z.ZodEnum<{
+            unknown: "unknown";
+            create: "create";
+            merge: "merge";
+            update: "update";
+        }>;
+    }, z.core.$strip>>;
+    filesChanged: z.ZodArray<z.ZodString>;
+    filesChangedTruncated: z.ZodBoolean;
+    schedules: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        action: z.ZodEnum<{
+            cancel: "cancel";
+            create: "create";
+            update: "update";
+        }>;
+    }, z.core.$strip>>;
+    services: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        action: z.ZodString;
+    }, z.core.$strip>>;
+    terminalState: z.ZodNullable<z.ZodEnum<{
+        blocked: "blocked";
+        done: "done";
+        interrupted: "interrupted";
+        asking: "asking";
+    }>>;
+}, z.core.$strip>;
+export type OutcomesV1 = z.infer<typeof OutcomesV1Schema>;

package/dist/agent/outcomes/schema.d.ts

@@ -31,6 +31,7 @@ export declare const ArtifactsSchema: z.ZodObject<{
     commits: z.ZodArray<z.ZodString>;
     prs: z.ZodArray<z.ZodString>;
     repo: z.ZodNullable<z.ZodString>;
+    commitRepos: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
 }, z.core.$strip>;
 export type Artifacts = z.infer<typeof ArtifactsSchema>;
 export declare const VerifiedOutcomeSchema: z.ZodObject<{
@@ -64,6 +65,7 @@ export declare const VerifiedOutcomeSchema: z.ZodObject<{
         commits: z.ZodArray<z.ZodString>;
         prs: z.ZodArray<z.ZodString>;
         repo: z.ZodNullable<z.ZodString>;
+        commitRepos: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     }, z.core.$strip>;
     votes: z.ZodArray<z.ZodObject<{
         lf: z.ZodString;
@@ -98,6 +100,51 @@ export declare const VerifiedOutcomeSchema: z.ZodObject<{
         normal: "normal";
     }>>;
     session_ended_at: z.ZodOptional<z.ZodString>;
+    outcomes: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        cwd: z.ZodString;
+        startHead: z.ZodNullable<z.ZodString>;
+        endHead: z.ZodNullable<z.ZodString>;
+        commits: z.ZodArray<z.ZodObject<{
+            sha: z.ZodString;
+            repo: z.ZodString;
+            subject: z.ZodString;
+            source: z.ZodEnum<{
+                tool_result: "tool_result";
+                git_log: "git_log";
+                effect_ledger: "effect_ledger";
+            }>;
+        }, z.core.$strip>>;
+        prs: z.ZodArray<z.ZodObject<{
+            url: z.ZodString;
+            action: z.ZodEnum<{
+                unknown: "unknown";
+                create: "create";
+                merge: "merge";
+                update: "update";
+            }>;
+        }, z.core.$strip>>;
+        filesChanged: z.ZodArray<z.ZodString>;
+        filesChangedTruncated: z.ZodBoolean;
+        schedules: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            action: z.ZodEnum<{
+                cancel: "cancel";
+                create: "create";
+                update: "update";
+            }>;
+        }, z.core.$strip>>;
+        services: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            action: z.ZodString;
+        }, z.core.$strip>>;
+        terminalState: z.ZodNullable<z.ZodEnum<{
+            blocked: "blocked";
+            done: "done";
+            interrupted: "interrupted";
+            asking: "asking";
+        }>>;
+    }, z.core.$strip>>>;
 }, z.core.$strip>;
 export type VerifiedOutcome = z.infer<typeof VerifiedOutcomeSchema>;
 export type OutcomeLabel = VerifiedOutcome['label'];

package/dist/agent/outcomes/session-end-hook.d.ts

@@ -1,2 +1,5 @@
 import type { HookHandler } from '../hooks.js';
+import type { OutcomesV1 } from './outcomes-v1.schema.js';
+import type { Artifacts } from './schema.js';
 export declare function createOutcomeSessionEndHook(): HookHandler;
+export declare function artifactsFromOutcomes(o: OutcomesV1): Artifacts;

package/dist/agent/outcomes/session-outcomes.d.ts

@@ -0,0 +1,9 @@
+import { type OutcomesV1 } from './outcomes-v1.schema.js';
+export interface SessionOutcomesContext {
+    cwd?: string;
+}
+export declare function _resetSessionOutcomesCache(): void;
+export declare function readEndHead(cwd: string, signal?: AbortSignal): Promise<string | null>;
+export declare function getSessionOutcomes(sessionId: string, ctx?: SessionOutcomesContext, opts?: {
+    timeoutMs?: number;
+}): Promise<OutcomesV1 | null>;

package/dist/agent/provider.d.ts

@@ -194,11 +194,6 @@ export interface ProviderQuery extends AsyncIterable<ProviderEvent> {
     setBeforeTurnEnd?(cb: ((continuation: number, assistantText?: string) => Promise<{
         continueWith?: string;
     } | undefined>) | undefined): void;
-    reauth?(): Promise<{
-        accountId: string;
-        oldAccountId: string;
-        swapped: boolean;
-    } | null>;
     close(): void | Promise<void>;
 }
 export interface ProviderCommandInfo {

package/dist/agent/providers/anthropic-direct/query/cwd-dependents.d.ts

@@ -12,6 +12,7 @@ export type CwdDependentsFactory = (newCwd: string) => {
 export interface CwdDependentsFactoryArgs {
     stableSystemPrefix: StableSystemParts;
     config: AgentConfig;
+    resolvedSessionId: string | undefined;
     surface: string;
     runtimeStateSource: RuntimeStateSource;
     getCurrentCwd: () => string | undefined;

package/dist/agent/providers/anthropic-direct/query-runtime.d.ts

@@ -57,11 +57,6 @@ export declare class AnthropicDirectQuery implements ProviderQuery {
     getContextUsage(): Promise<ProviderContextUsage>;
     mcpServerStatus(): Promise<ProviderMcpServerStatus[]>;
     accountInfo(): Promise<ProviderAccountInfo>;
-    reauth(): Promise<{
-        accountId: string;
-        oldAccountId: string;
-        swapped: boolean;
-    } | null>;
     rewindFiles(userMessageId: string, options?: {
         dryRun?: boolean;
     }): Promise<ProviderRewindResult>;

package/dist/agent/providers/openai-compatible/index.d.ts

@@ -9,7 +9,7 @@ export declare class OpenAICompatibleProvider implements ModelProvider {
     private _stateStore;
     private readonly _injectedMemoryStore;
     private readonly _injectedStateStore;
-    private readonly schemas;
+    private schemas;
     private _defaultHeaders;
     private _sharedReadRoots;
     private _sharedWriteRoots;
@@ -23,6 +23,7 @@ export declare class OpenAICompatibleProvider implements ModelProvider {
         baseURL?: string;
         defaultHeaders?: Record<string, string>;
     }): void;
+    setSubscribeHandler(handler: import('../../tools/types.js').ToolHandler): void;
     query(args: ProviderQueryArgs): ProviderQuery;
     private buildDispatcher;
     private ensureSharedRoots;

package/dist/agent/providers/openai-compatible/index.options.d.ts

@@ -20,6 +20,7 @@ export interface OpenAICompatibleProviderOptions extends ChildSessionOptions {
     composeExecutor?: ComposeExecutor;
     memoryStore?: MemoryStore;
     workspaceStore?: WorkspaceStore;
+    subscribeHandler?: import('../../tools/types.js').ToolHandler;
     stateStore?: StateStore;
     surface?: string;
     readOnlyMemory?: boolean;

package/dist/agent/providers/openai-compatible/provider-schemas.d.ts

@@ -0,0 +1,3 @@
+import type { OpenAICompatibleProviderOptions } from './index.options.js';
+import type { AnthropicToolDef } from '../anthropic-direct/types.js';
+export declare function buildProviderSchemas(opts: OpenAICompatibleProviderOptions): AnthropicToolDef[];

package/dist/agent/providers/router/provider-router.d.ts

@@ -46,11 +46,6 @@ export declare class ProviderRouter implements ProviderQuery {
     setPermissionMode(mode: string): Promise<void>;
     setCwd(cwd: string): void;
     setSystemPrompt(basePrompt: string | undefined): boolean;
-    reauth(): Promise<{
-        accountId: string;
-        oldAccountId: string;
-        swapped: boolean;
-    } | null>;
     supportedCommands(): Promise<ProviderCommandInfo[]>;
     supportedModels(): Promise<ProviderModelInfo[]>;
     supportedAgents(): Promise<ProviderAgentInfo[]>;

package/dist/agent/session/agent-session.d.ts

@@ -57,11 +57,6 @@ export declare class AgentSession implements IAgentSession {
     setPermissionMode(mode: PermissionMode): Promise<void>;
     setSystemPrompt(basePrompt: string | undefined): boolean;
     setCwd(cwd: string): void;
-    reauth(): Promise<{
-        accountId: string;
-        oldAccountId: string;
-        swapped: boolean;
-    } | null>;
     getPrePlanMode(): PermissionMode | undefined;
     setPlanExitQueueCheck(fn: () => boolean): void;
     takePendingPlanExitSeed(): Promise<{

package/dist/agent/session/ledger-lifecycle.d.ts

@@ -14,6 +14,12 @@ export interface LedgerEnsureContext {
 export declare class LedgerLifecycle {
     private writer;
     private initAttempted;
+    private start;
+    initialize(ctx: {
+        depth?: number;
+        parentSessionId?: string;
+        cwd?: string;
+    }): void;
     ensure(ctx: LedgerEnsureContext): void;
     recordUser(text: string, input?: string): void;
     recordEvent(event: OutputEvent): void;

package/dist/agent/session/session-config.d.ts

@@ -17,11 +17,6 @@ export declare function setModel(model: AgentModelInput | undefined, deps: Confi
 export declare function setPermissionMode(mode: PermissionMode, deps: ConfigDeps): Promise<void>;
 export declare function setSystemPrompt(basePrompt: string | undefined, deps: ConfigDeps): boolean;
 export declare function setCwd(cwd: string, deps: ConfigDeps): void;
-export declare function reauth(deps: ConfigDeps): Promise<{
-    accountId: string;
-    oldAccountId: string;
-    swapped: boolean;
-} | null>;
 export declare function takePendingPlanExitSeed(deps: ConfigDeps): Promise<{
     message: string;
     mode: PermissionMode;

package/dist/agent/session/session-meta.d.ts

@@ -9,6 +9,14 @@ export interface SessionMeta {
     startedAt?: number;
     afkVersion?: string;
     forkedFrom?: string;
+    gitHead?: SessionStart | null;
 }
+export interface SessionStart {
+    branch: string | null;
+    headSha: string | null;
+    capturedAt: number;
+}
+export declare function captureGitHead(cwd: string): SessionStart;
 export declare function writeSessionMeta(meta: SessionMeta): Promise<void>;
 export declare function readSessionMeta(sessionId: string): SessionMeta | null;
+export declare function readSessionStart(sessionId: string): SessionStart | null;

package/dist/agent/trace/receipt.d.ts

@@ -1,83 +1,10 @@
 import { renderReceiptMarkdown } from './receipt.render.js';
 import type { HookHandler } from '../hooks.js';
-import { type CostTokens, type SessionCostSource } from './cost.js';
-import { type JournalSummary } from './receipt.journal.js';
-import { type ClosureReason, type ToolFailureClass, type TraceEvent, type TraceEventKind } from './types.js';
+import { type TraceEvent } from './types.js';
 export { renderReceiptMarkdown };
+export { RECEIPT_SCHEMA_VERSION, type ReceiptMeta, type ReceiptToolFailure, type RunReceipt } from './receipt.types.js';
+import { type ReceiptMeta, type RunReceipt } from './receipt.types.js';
 export { extractJournalSummary, type JournalSummary } from './receipt.journal.js';
-export declare const RECEIPT_SCHEMA_VERSION: 2;
-export interface ReceiptToolFailure {
-    toolUseId: string;
-    name: string;
-    failureClass?: ToolFailureClass;
-    durationMs: number;
-    ts: string;
-    truncated: boolean;
-    exempt: boolean;
-    subagentId?: string;
-}
-export interface RunReceipt {
-    schemaVersion: typeof RECEIPT_SCHEMA_VERSION;
-    generatedAt: string;
-    witnessLabel: string;
-    tracePath: string;
-    sessionId?: string;
-    endReason?: string;
-    status: 'succeeded' | 'failed' | 'cancelled' | 'unknown';
-    closureReason?: ClosureReason;
-    lastStopReason?: string;
-    guidance?: string;
-    incomplete: boolean;
-    startedAt?: string;
-    endedAt?: string;
-    durationMs?: number;
-    toolCalls: {
-        total: number;
-        succeeded: number;
-        errored: number;
-        erroredNotable: number;
-        refused: number;
-        circuitBreakerHits: number;
-        byTool: Record<string, {
-            total: number;
-            errored: number;
-        }>;
-        byFailureClass: Record<string, number>;
-    };
-    events: {
-        total: number;
-        byKind: Partial<Record<TraceEventKind, number>>;
-    };
-    subagents: {
-        started: number;
-        succeeded: number;
-        failed: number;
-        cancelled: number;
-    };
-    cost: {
-        finalCostUsd?: number;
-        turnCount?: number;
-        tokens?: CostTokens;
-        rootCostUsd?: number;
-        subagentCostUsd?: number;
-        totalCostUsd?: number;
-        totalTokens?: CostTokens;
-        costSource?: SessionCostSource;
-    };
-    failures: ReceiptToolFailure[];
-    humanReviewRequired: boolean;
-    humanReviewReasons: string[];
-    limitations: string[];
-    journalSummary?: JournalSummary;
-}
-export interface ReceiptMeta {
-    tracePath: string;
-    witnessLabel: string;
-    sessionId?: string;
-    endReason?: string;
-    now?: Date;
-    journalSummary?: JournalSummary;
-}
 export declare function parseTraceJsonl(raw: string): TraceEvent[];
 export declare function receiptPathsFor(tracePath: string): {
     label: string;
@@ -90,6 +17,7 @@ export interface WriteRunReceiptOptions {
     sessionId?: string;
     reason?: string;
     now?: Date;
+    cwd?: string;
 }
 export declare function writeRunReceipt(opts: WriteRunReceiptOptions): Promise<{
     label: string;

package/dist/agent/trace/receipt.types.d.ts

@@ -0,0 +1,79 @@
+import type { CostTokens, SessionCostSource } from './cost.js';
+import type { JournalSummary } from './receipt.journal.js';
+import type { OutcomesV1 } from '../outcomes/outcomes-v1.schema.js';
+import type { ClosureReason, ToolFailureClass, TraceEventKind } from './types.js';
+export declare const RECEIPT_SCHEMA_VERSION: 3;
+export interface ReceiptToolFailure {
+    toolUseId: string;
+    name: string;
+    failureClass?: ToolFailureClass;
+    durationMs: number;
+    ts: string;
+    truncated: boolean;
+    exempt: boolean;
+    subagentId?: string;
+}
+export interface RunReceipt {
+    schemaVersion: typeof RECEIPT_SCHEMA_VERSION;
+    generatedAt: string;
+    witnessLabel: string;
+    tracePath: string;
+    sessionId?: string;
+    endReason?: string;
+    status: 'succeeded' | 'failed' | 'cancelled' | 'unknown';
+    closureReason?: ClosureReason;
+    lastStopReason?: string;
+    guidance?: string;
+    incomplete: boolean;
+    startedAt?: string;
+    endedAt?: string;
+    durationMs?: number;
+    toolCalls: {
+        total: number;
+        succeeded: number;
+        errored: number;
+        erroredNotable: number;
+        refused: number;
+        circuitBreakerHits: number;
+        byTool: Record<string, {
+            total: number;
+            errored: number;
+        }>;
+        byFailureClass: Record<string, number>;
+    };
+    events: {
+        total: number;
+        byKind: Partial<Record<TraceEventKind, number>>;
+    };
+    subagents: {
+        started: number;
+        succeeded: number;
+        failed: number;
+        cancelled: number;
+    };
+    cost: {
+        finalCostUsd?: number;
+        turnCount?: number;
+        tokens?: CostTokens;
+        rootCostUsd?: number;
+        subagentCostUsd?: number;
+        totalCostUsd?: number;
+        totalTokens?: CostTokens;
+        costSource?: SessionCostSource;
+    };
+    failures: ReceiptToolFailure[];
+    humanReviewRequired: boolean;
+    humanReviewReasons: string[];
+    limitations: string[];
+    journalSummary?: JournalSummary;
+    outcomes?: OutcomesV1 | null;
+}
+export interface ReceiptMeta {
+    tracePath: string;
+    witnessLabel: string;
+    sessionId?: string;
+    endReason?: string;
+    now?: Date;
+    journalSummary?: JournalSummary;
+    outcomes?: OutcomesV1 | null;
+}