@gajae-code/coding-agent 0.12.4 → 0.12.6

package/dist/types/session/client-bridge.d.ts

@@ -55,12 +55,23 @@ export interface ClientBridgeTerminalOutput {
 }
 export interface ClientBridgeTerminalHandle {
     terminalId: string;
+    /** Exact provider lease/session identity that owns this terminal. */
+    providerLeaseId: string;
     waitForExit(): Promise<ClientBridgeTerminalExitStatus>;
     currentOutput(): Promise<ClientBridgeTerminalOutput>;
     kill(): Promise<void>;
     release(): Promise<void>;
+    /** Full authenticated provider identity, when supplied by the transport. */
+    providerLeaseIdentity?: ClientBridgeProviderLeaseIdentity;
+}
+export interface ClientBridgeProviderLeaseIdentity {
+    leaseId: string;
+    connectionId: string;
+    connectionGeneration: number;
+    fence: string;
 }
 export interface ClientBridgeCreateTerminalParams {
+    toolCallId: string;
     command: string;
     args?: string[];
     env?: Array<{
@@ -69,6 +80,7 @@ export interface ClientBridgeCreateTerminalParams {
     }>;
     cwd?: string;
     outputByteLimit?: number;
+    signal?: AbortSignal;
 }
 export interface ClientBridge {
     readonly capabilities: ClientBridgeCapabilities;
@@ -84,5 +96,7 @@ export interface ClientBridge {
         content: string;
     }): Promise<void>;
     createTerminal?(params: ClientBridgeCreateTerminalParams): Promise<ClientBridgeTerminalHandle>;
+    /** Fence the exact provider identity after cleanup ownership becomes uncertain. */
+    quarantineProviderLease?(providerLease: string | ClientBridgeProviderLeaseIdentity, reason: string): Promise<void>;
     requestPermission?(toolCall: ClientBridgePermissionToolCall, options: ClientBridgePermissionOption[], signal?: AbortSignal): Promise<ClientBridgePermissionOutcome>;
 }

package/dist/types/session/internal/managed-session-storage.d.ts

@@ -7,7 +7,6 @@ export declare const MANAGED_ARTIFACT_MAX_TOTAL_BYTES: number;
 export declare const MANAGED_ARTIFACT_COPY_BATCH_SIZE = 256;
 export declare class ManagedPublishError extends Error {
     readonly classification: "destination_conflict" | "atomic_unavailable" | "invalid_request" | "durability_not_provable" | "identity_mismatch" | "io_error" | "durability_failed";
-    readonly code: ManagedPublishError["classification"];
     readonly diagnostic: string;
     constructor(classification: ManagedPublishError["classification"], outcome: NativePublishOutcome);
 }
@@ -21,12 +20,6 @@ export interface ManagedStorageLock {
     assertOwned(): void;
     release(): Promise<void>;
 }
-export interface ManagedStorageLockSync {
-    path: string;
-    attemptId: string;
-    assertOwned(): void;
-    release(): void;
-}
 export interface ManagedFileSnapshot {
     bytes: Buffer;
     identity: {
@@ -38,13 +31,6 @@ export interface ManagedFileSnapshot {
         sha256: string;
     };
 }
-export declare const MANAGED_SESSION_SECURITY_CODES: readonly ["acl_denied", "acl_io_error", "acl_present", "acl_malformed", "acl_unknown", "acl_unavailable", "acl_apply_failed", "acl_verify_failed", "not_found", "not_directory", "network_unsupported", "reparse_point", "identity_unavailable", "identity_mismatch", "owner_mismatch", "mode_mismatch", "io_error"];
-export type ManagedSessionSecurityCode = (typeof MANAGED_SESSION_SECURITY_CODES)[number];
-export declare class ManagedSessionSecurityError extends Error {
-    readonly code: ManagedSessionSecurityCode;
-    constructor(code: ManagedSessionSecurityCode);
-}
-export declare function managedSessionSecurityCode(error: unknown): ManagedSessionSecurityCode | undefined;
 export declare function validateNativeSecurityResult(value: unknown, operation: "apply" | "verify", kind: "directory" | "file"): NativeOwnerOnlySecurityResult;
 /** Captured configured-root authority for managed paths only. */
 export interface ManagedDirectoryRoot {
@@ -77,6 +63,8 @@ export declare class ManagedSessionDescendantStore {
     get rootAuthority(): ManagedDirectoryRoot;
     get subtreeRootAuthority(): ManagedDirectoryRoot;
     get securityPolicy(): ManagedSessionSecurityPolicy;
+    get hasRetainedAuthority(): boolean;
+    acquireMutationFence(name: string): Promise<ManagedStorageLock | undefined>;
     get profileAgentDir(): string;
     deriveSubtree(relativePath: string): ManagedSessionDescendantStore;
     retainAuthority(): RecoveryFsRoot | undefined;
@@ -91,6 +79,7 @@ export declare class ManagedSessionDescendantStore {
     publishNoReplace(relativePath: string, bytes: Uint8Array): Promise<void>;
     publishNoReplaceSync(relativePath: string, bytes: Uint8Array): void;
     replace(relativePath: string, bytes: Uint8Array): Promise<void>;
+    replaceExpected(relativePath: string, bytes: Uint8Array, expected: ManagedFileSnapshot): void;
     replaceSync(relativePath: string, bytes: Uint8Array): void;
     appendSync(relativePath: string, bytes: Uint8Array): void;
     /** Read an exact managed file without exposing its pathname as authority. */
@@ -118,19 +107,14 @@ export declare function captureManagedFilePrefixNoFollow(pathname: string, maxBy
 export declare function captureManagedFileNoFollow(pathname: string): ManagedFileSnapshot;
 /** Atomically publishes bytes without replacing an existing destination. */
 export declare function publishManagedFileNoReplace(destination: string, bytes: Uint8Array, assertOwned?: () => void, root?: ManagedDirectoryRoot, policy?: ManagedSessionSecurityPolicy): Promise<void>;
-export declare function publishManagedFileNoReplaceSync(destination: string, bytes: Uint8Array, root?: ManagedDirectoryRoot, policy?: ManagedSessionSecurityPolicy): void;
-/**
- * Atomically replace a managed file only when the destination is still the
- * exact captured object. Unlike `replaceManagedFileSync`, this never performs
- * an unconditional pathname rename.
- */
-export declare function replaceManagedFileExactSync(destination: string, bytes: Uint8Array, expected: Pick<ManagedFileSnapshot, "identity">, root: ManagedDirectoryRoot): void;
+export declare function publishManagedFileNoReplaceSync(destination: string, bytes: Uint8Array, root?: ManagedDirectoryRoot, policy?: ManagedSessionSecurityPolicy, assertOwned?: () => void): void;
+/** Replace one managed regular file while retaining the secured staging fd through publication. */
+export declare function replaceManagedFileSync(destination: string, bytes: Uint8Array, root: ManagedDirectoryRoot, policy?: ManagedSessionSecurityPolicy, assertFence?: () => void): void;
+export declare function replaceManagedFile(destination: string, bytes: Uint8Array, root: ManagedDirectoryRoot, policy?: ManagedSessionSecurityPolicy): Promise<void>;
 /** Copy the exact bytes captured from one no-follow source descriptor. */
 export declare function copyManagedFileNoReplace(source: string, destination: string, snapshot?: ManagedFileSnapshot, root?: ManagedDirectoryRoot, policy?: ManagedSessionSecurityPolicy): Promise<void>;
 /** Acquire a lease lock with bounded wait, heartbeats, conservative stale reclaim, and fencing. */
 export declare function acquireManagedLock(locksDirectory: string, name: string, root?: ManagedDirectoryRoot, policy?: ManagedSessionSecurityPolicy): Promise<ManagedStorageLock>;
-/** Acquire a synchronous lease lock for a short cross-process critical section. */
-export declare function acquireManagedLockSync(locksDirectory: string, name: string, root?: ManagedDirectoryRoot, policy?: ManagedSessionSecurityPolicy): ManagedStorageLockSync;
 export interface ManagedArtifactTreeLimits {
     maxFiles?: number;
     maxTotalBytes?: number;

package/dist/types/session/messages.d.ts

@@ -73,7 +73,10 @@ export declare const PRE_ADMISSION_ARTIFACT_SPILL_TAIL_BYTES = 4096;
  * next provider context is constructed. Byte boundaries never split UTF-8
  * code points, so head/tail recovery remains readable for emoji and CJK text.
  */
-export declare function createPreAdmissionArtifactSpillPreview(fullText: string, artifactId: string, digest: string): string;
+export declare function createPreAdmissionArtifactSpillPreview(fullText: string, artifactId: string, digest: string, options?: {
+    maxInlineBytes?: number;
+    fullOutput?: boolean;
+}): string;
 /**
  * Message type for bash executions via the ! command.
  */

package/dist/types/session/session-manager.d.ts

@@ -4,7 +4,7 @@ import type { ImageContent, Message, MessageAttribution, ServiceTier, TextConten
 import * as native from "@gajae-code/natives";
 import type { TtsrInjectionRecord } from "../export/ttsr";
 import type { ManagedLegacyLocalMigrationSource } from "../internal-urls/local-protocol";
-import { ArtifactManager } from "./artifacts";
+import { ArtifactManager, type ArtifactSaveReceipt } from "./artifacts";
 import { type BlobPutResult, BlobStore } from "./blob-store";
 import { type ManagedMigrationPolicy } from "./internal/managed-session-scope";
 import { type ManagedDirectoryRoot, ManagedSessionDescendantStore } from "./internal/managed-session-storage";
@@ -329,6 +329,7 @@ export interface ResumeSessionIdentity {
     sessionId: string;
     dev: bigint;
     ino: bigint;
+    nlink?: bigint;
     size: number;
     mtimeMs: number;
     mtimeNs: bigint;
@@ -484,7 +485,7 @@ export interface ReadonlySessionManager {
 /** Creates an immutable facade that never exposes SessionManager mutation authority. */
 export declare function createReadonlySessionManager(manager: SessionManager): ReadonlySessionManager;
 /** Internal artifact-writing capability. Read-only facades expose it only through a private weak-map lookup. */
-export type SessionArtifactCapability = Readonly<Pick<SessionManager, "allocateArtifactPath" | "saveArtifact" | "putBlob">>;
+export type SessionArtifactCapability = Readonly<Pick<SessionManager, "allocateArtifactPath" | "saveArtifact" | "getArtifactPath" | "putBlob">>;
 /**
  * Returns the artifact capability for a concrete persistence owner or one of its
  * immutable read-only facades. Structural lookalikes remain unauthorized.
@@ -756,10 +757,11 @@ export declare class SessionManager {
         path?: string;
     }>;
     /**
-     * Save artifact content under the current session and return artifact ID.
-     * Returns an artifact ID for all sessions (file-backed for persistent, in-memory fallback otherwise).
+     * Save artifact content under the current persisted session and return its artifact ID.
+     * In-memory sessions cannot produce protocol-resolvable artifact references.
      */
     saveArtifact(content: string, toolType: string): Promise<string | undefined>;
+    saveArtifactReceipt(content: string, toolType: string): Promise<ArtifactSaveReceipt | undefined>;
     /**
      * Resolve an artifact ID to an on-disk path for the current session.
      * Returns null when missing or when the session is not persisted.
@@ -986,7 +988,7 @@ export declare class SessionManager {
      * @param sessionDir Optional session directory for /new or /branch. If omitted, derives from file's parent.
      */
     static open(filePath: string, destinationInput?: SessionDestinationInput, storage?: SessionStorage, migrationPolicy?: SessionDirectoryMigrationPolicy): Promise<SessionManager>;
-    static openNestedManaged(filePath: string, destination: SessionDestination, store: ManagedSessionDescendantStore, storage?: SessionStorage): Promise<SessionManager>;
+    static openNestedManaged(filePath: string, destination: SessionDestination, store: ManagedSessionDescendantStore, storage?: SessionStorage, cwdOverride?: string): Promise<SessionManager>;
     /**
      * List default-managed sessions for the resume picker without recovery or other
      * maintenance writes. This is the only picker inventory that includes legacy

package/dist/types/session/session-storage.d.ts

@@ -3,6 +3,7 @@ import { type ManagedDirectoryRoot } from "./internal/managed-session-storage";
 export interface SessionStorageStat {
     dev: bigint;
     ino: bigint;
+    nlink?: bigint;
     size: number;
     mtimeMs: number;
     mtimeNs: bigint;
@@ -148,6 +149,7 @@ export interface SessionStorage {
 export interface SessionStorageFileIdentity {
     dev: bigint;
     ino: bigint;
+    nlink?: bigint;
     size: number;
     mtimeNs: bigint;
     sha256: string;
@@ -181,12 +183,17 @@ export interface VerifiedSessionDeleteTarget {
     cwd: string;
     /** Expected transcript file `(dev, ino)` captured at authorization. */
     transcriptIdentity: SessionStorageFileIdentity;
+    transcriptParentIdentity?: {
+        dev: bigint;
+        ino: bigint;
+    };
     /**
      * For retry after an `artifacts` `cleanup_pending`: the recorded artifact
      * directory identity to re-accept. A replacement/different artifact directory
      * fails closed. Omit on first attempt or to accept recorded absence.
      */
     expectedArtifactsIdentity?: SessionStorageFileIdentity;
+    artifactsAbsentAtAuthorization?: true;
     /** Stable native recursive-tree evidence captured before artifact detachment. */
     expectedArtifactsTree?: NativeDirectoryTreeSnapshot;
     /** Identity-bound quarantine path retained when recursive artifact cleanup failed. */
@@ -256,6 +263,7 @@ type NativeDirectoryTreeEntry = {
     kind: string;
     dev: string;
     ino: string;
+    nlink: string;
     size: string;
     mtimeNs: string;
     ctimeNs: string;

package/dist/types/session/streaming-output.d.ts

@@ -37,17 +37,40 @@ export interface OutputSummary {
     elidedBytes?: number;
     /** Lines elided from the middle when head-retain mode is active. */
     elidedLines?: number;
+    /** Exact source ranges retained by head/tail middle-elision windows. */
+    headRange?: {
+        start: number;
+        end: number;
+    };
+    tailRange?: {
+        start: number;
+        end: number;
+    };
+    /** The retained tail ends with only a byte fragment of its source line. */
+    lastLinePartial?: boolean;
+    /** The retained head ends with only a byte fragment of its source line. */
+    firstLinePartial?: boolean;
     /** Bytes dropped by the per-line column cap (sum across all lines). */
     columnDroppedBytes?: number;
     /** Number of distinct lines that hit the per-line column cap. */
     columnTruncatedLines?: number;
+    /** Configured per-line byte/column cap that caused visible omission. */
+    columnMax?: number;
     /** Artifact ID for internal URL access (artifact://<id>) when output was persisted. */
     artifactId?: string;
+    /** Artifact existence was proven by successful publication or file finalization. */
+    artifactVerified?: boolean;
     /** Bytes omitted from artifact storage after the artifact hard cap was reached. */
     artifactTruncatedBytes?: number;
+    /** Bytes dropped before the Bash executor received the native output stream. */
+    sourceTruncatedBytes?: number;
+    /** Exact source capture completeness could not be proven. */
+    sourceCaptureIncomplete?: boolean;
     /** Bounded diagnostic when artifact writer or terminal publisher creation, write, finalization, or publication failed. */
     artifactFailureDiagnostic?: string;
 }
+/** Verify that this exact OutputSink summary came from a successful current-execution publication. */
+export declare function hasCurrentExecutionArtifactProof(summary: OutputSummary, artifactId: string, payload?: string): boolean;
 export interface OutputSinkOptions {
     /**
      * Deprecated managed artifact pathname. Bare paths are deliberately ignored:
@@ -112,7 +135,16 @@ export interface TruncationResult {
     elidedBytes?: number;
     /** Lines elided from the middle (truncateMiddle only). */
     elidedLines?: number;
+    headRange?: {
+        start: number;
+        end: number;
+    };
+    tailRange?: {
+        start: number;
+        end: number;
+    };
     lastLinePartial?: boolean;
+    firstLinePartial?: boolean;
     firstLineExceedsLimit?: boolean;
     lastLineExceedsLimit?: boolean;
 }

package/dist/types/task/executor.d.ts

@@ -107,7 +107,7 @@ export interface ExecutorOptions {
 export declare class ManagedTaskPersistence {
     #private;
     constructor(artifacts: ArtifactManager, taskId: string);
-    openSession(): Promise<SessionManager>;
+    openSession(cwd: string): Promise<SessionManager>;
     publishOutput(rawOutput: string, metadata: Uint8Array): Promise<void>;
 }
 export declare function createManagedTaskPersistence(artifacts: ArtifactManager, taskId: string): ManagedTaskPersistence;

package/dist/types/task/index.d.ts

@@ -5,8 +5,9 @@ import { type SubagentRunOutcome } from "../async";
 import type { Theme } from "../modes/theme/theme";
 import { type SingleResult, type TaskToolDetails, type TaskToolSchemaInstance } from "./types";
 import "../tools/review";
+import { type TaskResultReceipt } from "./receipt";
 import { renderResult, renderCall as renderTaskCall } from "./render";
-export declare function subagentRunOutcomeFromSingleResult(finalText: string, singleResult: Pick<SingleResult, "aborted" | "exitCode" | "paused" | "setupFailure"> | undefined): string | SubagentRunOutcome;
+export declare function subagentRunOutcomeFromSingleResult(finalText: string, singleResult: (Pick<SingleResult, "aborted" | "exitCode" | "paused" | "setupFailure"> & Partial<Pick<TaskResultReceipt, "status">>) | undefined): string | SubagentRunOutcome;
 export { loadBundledAgents as BUNDLED_AGENTS } from "./agents";
 export { discoverCommands, expandCommand, getCommand } from "./commands";
 export { discoverAgents, getAgent } from "./discovery";

package/dist/types/task/receipt.d.ts

@@ -34,6 +34,7 @@ export interface TaskResultReceipt {
     cost?: number;
     usageCostBreakdownComplete?: true;
     branchName?: string;
+    persistence?: SingleResult["persistence"];
     retryFailure?: {
         attempt: number;
         errorSummary: string;
@@ -69,6 +70,8 @@ export interface TaskResultReceipt {
     forkContextAdvisory?: SingleResult["forkContextAdvisory"];
     /** Resolved repository identity for this delegated lane (#2901). */
     repositoryBinding?: SingleResult["repositoryBinding"];
+    /** Runtime-derived review source disposition and rerun guidance (#3469). */
+    reviewSource?: SingleResult["reviewSource"];
     roi?: TaskRoi;
 }
 /**

package/dist/types/task/types.d.ts

@@ -1,6 +1,7 @@
 import type { ThinkingLevel } from "@gajae-code/agent-core";
 import type { Usage } from "@gajae-code/ai";
 import * as z from "zod/v4";
+import type { ReviewDeliveryDisposition, ReviewSourceLane } from "../gjc-runtime/ultragoal-review-source";
 import type { TaskResultReceipt } from "./receipt";
 import type { SpawnRoiReconciliation } from "./roi-reconciliation";
 import { type TaskSimpleMode } from "./simple-mode";
@@ -65,6 +66,24 @@ export declare const taskItemSchema: z.ZodObject<{
         head: z.ZodOptional<z.ZodString>;
         branch: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
+    reviewSource: z.ZodOptional<z.ZodObject<{
+        schema: z.ZodLiteral<"gjc.review_source_dispatch.v1">;
+        cohortId: z.ZodString;
+        generation: z.ZodNumber;
+        lane: z.ZodEnum<{
+            architect: "architect";
+            cleaner: "cleaner";
+            critic: "critic";
+            qa: "qa";
+        }>;
+        snapshotId: z.ZodString;
+        repositoryBindingDigest: z.ZodString;
+        stateRevision: z.ZodNumber;
+        dispatchId: z.ZodString;
+        rerunCommand: z.ZodString;
+        taskId: z.ZodString;
+        createdAt: z.ZodString;
+    }, z.core.$strict>>;
 }, z.core.$strip>;
 export type TaskItem = z.infer<typeof taskItemSchema>;
 export declare const taskSchema: z.ZodObject<{
@@ -93,6 +112,24 @@ export declare const taskSchema: z.ZodObject<{
             head: z.ZodOptional<z.ZodString>;
             branch: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>;
+        reviewSource: z.ZodOptional<z.ZodObject<{
+            schema: z.ZodLiteral<"gjc.review_source_dispatch.v1">;
+            cohortId: z.ZodString;
+            generation: z.ZodNumber;
+            lane: z.ZodEnum<{
+                architect: "architect";
+                cleaner: "cleaner";
+                critic: "critic";
+                qa: "qa";
+            }>;
+            snapshotId: z.ZodString;
+            repositoryBindingDigest: z.ZodString;
+            stateRevision: z.ZodNumber;
+            dispatchId: z.ZodString;
+            rerunCommand: z.ZodString;
+            taskId: z.ZodString;
+            createdAt: z.ZodString;
+        }, z.core.$strict>>;
     }, z.core.$strip>>;
     spawnPlan: z.ZodOptional<z.ZodObject<{
         whyParallel: z.ZodString;
@@ -128,6 +165,24 @@ export declare const taskSchemaNoIsolation: z.ZodObject<{
             head: z.ZodOptional<z.ZodString>;
             branch: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>;
+        reviewSource: z.ZodOptional<z.ZodObject<{
+            schema: z.ZodLiteral<"gjc.review_source_dispatch.v1">;
+            cohortId: z.ZodString;
+            generation: z.ZodNumber;
+            lane: z.ZodEnum<{
+                architect: "architect";
+                cleaner: "cleaner";
+                critic: "critic";
+                qa: "qa";
+            }>;
+            snapshotId: z.ZodString;
+            repositoryBindingDigest: z.ZodString;
+            stateRevision: z.ZodNumber;
+            dispatchId: z.ZodString;
+            rerunCommand: z.ZodString;
+            taskId: z.ZodString;
+            createdAt: z.ZodString;
+        }, z.core.$strict>>;
     }, z.core.$strip>>;
     spawnPlan: z.ZodOptional<z.ZodObject<{
         whyParallel: z.ZodString;
@@ -163,6 +218,24 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
             head: z.ZodOptional<z.ZodString>;
             branch: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>;
+        reviewSource: z.ZodOptional<z.ZodObject<{
+            schema: z.ZodLiteral<"gjc.review_source_dispatch.v1">;
+            cohortId: z.ZodString;
+            generation: z.ZodNumber;
+            lane: z.ZodEnum<{
+                architect: "architect";
+                cleaner: "cleaner";
+                critic: "critic";
+                qa: "qa";
+            }>;
+            snapshotId: z.ZodString;
+            repositoryBindingDigest: z.ZodString;
+            stateRevision: z.ZodNumber;
+            dispatchId: z.ZodString;
+            rerunCommand: z.ZodString;
+            taskId: z.ZodString;
+            createdAt: z.ZodString;
+        }, z.core.$strict>>;
     }, z.core.$strip>>;
     spawnPlan: z.ZodOptional<z.ZodObject<{
         whyParallel: z.ZodString;
@@ -197,6 +270,24 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
             head: z.ZodOptional<z.ZodString>;
             branch: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>;
+        reviewSource: z.ZodOptional<z.ZodObject<{
+            schema: z.ZodLiteral<"gjc.review_source_dispatch.v1">;
+            cohortId: z.ZodString;
+            generation: z.ZodNumber;
+            lane: z.ZodEnum<{
+                architect: "architect";
+                cleaner: "cleaner";
+                critic: "critic";
+                qa: "qa";
+            }>;
+            snapshotId: z.ZodString;
+            repositoryBindingDigest: z.ZodString;
+            stateRevision: z.ZodNumber;
+            dispatchId: z.ZodString;
+            rerunCommand: z.ZodString;
+            taskId: z.ZodString;
+            createdAt: z.ZodString;
+        }, z.core.$strict>>;
     }, z.core.$strip>>;
     spawnPlan: z.ZodOptional<z.ZodObject<{
         whyParallel: z.ZodString;
@@ -231,6 +322,24 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
             head: z.ZodOptional<z.ZodString>;
             branch: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>;
+        reviewSource: z.ZodOptional<z.ZodObject<{
+            schema: z.ZodLiteral<"gjc.review_source_dispatch.v1">;
+            cohortId: z.ZodString;
+            generation: z.ZodNumber;
+            lane: z.ZodEnum<{
+                architect: "architect";
+                cleaner: "cleaner";
+                critic: "critic";
+                qa: "qa";
+            }>;
+            snapshotId: z.ZodString;
+            repositoryBindingDigest: z.ZodString;
+            stateRevision: z.ZodNumber;
+            dispatchId: z.ZodString;
+            rerunCommand: z.ZodString;
+            taskId: z.ZodString;
+            createdAt: z.ZodString;
+        }, z.core.$strict>>;
     }, z.core.$strip>>;
     spawnPlan: z.ZodOptional<z.ZodObject<{
         whyParallel: z.ZodString;
@@ -265,6 +374,24 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
             head: z.ZodOptional<z.ZodString>;
             branch: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>;
+        reviewSource: z.ZodOptional<z.ZodObject<{
+            schema: z.ZodLiteral<"gjc.review_source_dispatch.v1">;
+            cohortId: z.ZodString;
+            generation: z.ZodNumber;
+            lane: z.ZodEnum<{
+                architect: "architect";
+                cleaner: "cleaner";
+                critic: "critic";
+                qa: "qa";
+            }>;
+            snapshotId: z.ZodString;
+            repositoryBindingDigest: z.ZodString;
+            stateRevision: z.ZodNumber;
+            dispatchId: z.ZodString;
+            rerunCommand: z.ZodString;
+            taskId: z.ZodString;
+            createdAt: z.ZodString;
+        }, z.core.$strict>>;
     }, z.core.$strip>>;
     spawnPlan: z.ZodOptional<z.ZodObject<{
         whyParallel: z.ZodString;
@@ -299,6 +426,24 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
             head: z.ZodOptional<z.ZodString>;
             branch: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>;
+        reviewSource: z.ZodOptional<z.ZodObject<{
+            schema: z.ZodLiteral<"gjc.review_source_dispatch.v1">;
+            cohortId: z.ZodString;
+            generation: z.ZodNumber;
+            lane: z.ZodEnum<{
+                architect: "architect";
+                cleaner: "cleaner";
+                critic: "critic";
+                qa: "qa";
+            }>;
+            snapshotId: z.ZodString;
+            repositoryBindingDigest: z.ZodString;
+            stateRevision: z.ZodNumber;
+            dispatchId: z.ZodString;
+            rerunCommand: z.ZodString;
+            taskId: z.ZodString;
+            createdAt: z.ZodString;
+        }, z.core.$strict>>;
     }, z.core.$strip>>;
     spawnPlan: z.ZodOptional<z.ZodObject<{
         whyParallel: z.ZodString;
@@ -333,6 +478,24 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
             head: z.ZodOptional<z.ZodString>;
             branch: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>;
+        reviewSource: z.ZodOptional<z.ZodObject<{
+            schema: z.ZodLiteral<"gjc.review_source_dispatch.v1">;
+            cohortId: z.ZodString;
+            generation: z.ZodNumber;
+            lane: z.ZodEnum<{
+                architect: "architect";
+                cleaner: "cleaner";
+                critic: "critic";
+                qa: "qa";
+            }>;
+            snapshotId: z.ZodString;
+            repositoryBindingDigest: z.ZodString;
+            stateRevision: z.ZodNumber;
+            dispatchId: z.ZodString;
+            rerunCommand: z.ZodString;
+            taskId: z.ZodString;
+            createdAt: z.ZodString;
+        }, z.core.$strict>>;
     }, z.core.$strip>>;
     spawnPlan: z.ZodOptional<z.ZodObject<{
         whyParallel: z.ZodString;
@@ -495,6 +658,18 @@ export interface SetupFailureSummary {
 }
 /** Create a bounded diagnostic that preserves a setup failure's cause without exposing credentials or local paths. */
 export declare function createSetupFailureSummary(error: unknown): SetupFailureSummary;
+export interface TaskRecoveryArtifactRef {
+    uri: string;
+    sizeBytes: number;
+    sha256: string;
+    /** Recovery artifacts remain readable for the parent session lifetime. */
+    durability: "session";
+}
+export interface TaskPersistenceResult {
+    outcome: "applied" | "no_changes" | "recovery_available";
+    ownerWorktreeApplied: boolean;
+    recoveryRef?: TaskRecoveryArtifactRef;
+}
 /** Result from a single agent execution */
 export interface SingleResult {
     index: number;
@@ -540,6 +715,10 @@ export interface SingleResult {
     nestedPatches?: NestedRepoPatch[];
     /** Whether isolated execution produced a non-empty root or nested patch. */
     producedChanges?: boolean;
+    /** Receipt-safe owner-worktree persistence result for isolated execution. */
+    persistence?: TaskPersistenceResult;
+    /** Identity-bound patch artifact captured before isolation cleanup. */
+    recoveryRef?: TaskRecoveryArtifactRef;
     /** Data extracted by registered subprocess tool handlers (keyed by tool name) */
     extractedToolData?: Record<string, unknown[]>;
     /** Full wrapper-owned review evidence, kept separate from caller completion data. */
@@ -587,6 +766,21 @@ export interface SingleResult {
         head?: string;
         branch?: string;
     };
+    /** Leader-issued immutable source identity for source-aware review lanes (#3469). */
+    reviewSource?: {
+        schema: "gjc.review_source_dispatch.v1";
+        cohortId: string;
+        generation: number;
+        lane: ReviewSourceLane;
+        snapshotId: string;
+        repositoryBindingDigest: string;
+        stateRevision: number;
+        dispatchId: string;
+        rerunCommand: string;
+        disposition: ReviewDeliveryDisposition;
+        currentSnapshotId?: string;
+        deliveryId?: string;
+    };
 }
 /** True only for complete, factual five-bucket cost accounting. */
 export declare function hasCompleteUsageCostBreakdown(usage: unknown): boolean;

package/dist/types/task/worktree.d.ts

@@ -22,6 +22,8 @@ export interface WorktreeBaseline {
 export declare function getRepoRoot(cwd: string): Promise<string>;
 export declare function getGitNoIndexNullPath(): string;
 export declare function captureBaseline(repoRoot: string): Promise<WorktreeBaseline>;
+/** Confirm that applying patches to the captured owner baseline exactly matches the current owner worktree. */
+export declare function verifyRootPatchesApplied(repoRoot: string, baseline: WorktreeBaseline, patches: readonly string[]): Promise<boolean>;
 export interface NestedRepoPatch {
     relativePath: string;
     patch: string;
@@ -29,14 +31,19 @@ export interface NestedRepoPatch {
 export interface DeltaPatchResult {
     rootPatch: string;
     nestedPatches: NestedRepoPatch[];
+    captureErrors?: string[];
 }
+export interface RecoveryPatchBundle {
+    version: 1;
+    rootPatch: string;
+    nestedPatches: NestedRepoPatch[];
+    captureErrors?: string[];
+}
+export declare function serializeRecoveryPatchBundle(delta: DeltaPatchResult): string;
+export declare function verifyNestedPatchesApplied(repoRoot: string, baseline: WorktreeBaseline, patches: readonly NestedRepoPatch[]): Promise<boolean>;
 export declare function captureDeltaPatch(isolationDir: string, baseline: WorktreeBaseline): Promise<DeltaPatchResult>;
-/**
- * Apply nested repo patches directly to their working directories after parent merge.
- * @param commitMessage Optional async function to generate a commit message from the combined diff.
- *                      If omitted or returns null, falls back to a generic message.
- */
-export declare function applyNestedPatches(repoRoot: string, patches: NestedRepoPatch[], commitMessage?: (diff: string) => Promise<string | null>): Promise<void>;
+/** Preflight every nested delta, then roll back earlier repositories if a later apply fails. */
+export declare function applyNestedPatches(repoRoot: string, patches: NestedRepoPatch[]): Promise<void>;
 /**
  * User-facing isolation mode names exposed by the `task.isolation.mode`
  * setting. Mapped to a backend-kind hint via {@link parseIsolationMode};

package/dist/types/tools/bash.d.ts

@@ -91,7 +91,7 @@ export declare class BashTool implements AgentTool<BashToolSchema, BashToolDetai
         label: string;
         commandCwd: string;
     }>;
-    execute(_toolCallId: string, { command: rawCommand, env: rawEnv, timeout: rawTimeout, cwd, async: asyncRequested, pty, }: BashToolInput, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<BashToolDetails>, ctx?: AgentToolContext): Promise<AgentToolResult<BashToolDetails>>;
+    execute(toolCallId: string, { command: rawCommand, env: rawEnv, timeout: rawTimeout, cwd, async: asyncRequested, pty, }: BashToolInput, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<BashToolDetails>, ctx?: AgentToolContext): Promise<AgentToolResult<BashToolDetails>>;
 }
 export interface BashRenderArgs {
     command?: string;

package/dist/types/tools/fetch.d.ts

@@ -49,6 +49,9 @@ export interface ReadUrlToolDetails {
 }
 interface ReadUrlCacheEntry {
     artifactId?: string;
+    artifactVerified?: boolean;
+    artifactFailureDiagnostic?: string;
+    artifactStorageIncomplete?: boolean;
     details: ReadUrlToolDetails;
     image?: FetchImagePayload;
     /** Complete URL output, including its preamble and body. */