@gajae-code/coding-agent 0.11.7 → 0.11.9

package/dist/types/sdk/prompt-status.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Public DTO contract for Q26 `turn.prompt_status` and the `clientRef`
+ * correlation field on `turn.prompt`.
+ *
+ * Semantics:
+ * - `turn.prompt` remains ordered and non-idempotent. An envelope
+ *   `idempotencyKey` is ignored for replay/conflict purposes on ordered
+ *   operations (no replay cache, no `idempotency_conflict`).
+ * - `clientRef` is a caller-chosen correlation key (trimmed, non-empty,
+ *   1..PROMPT_CLIENT_REF_MAX_LENGTH chars; one fresh value per logical prompt)
+ *   mapped to the generated commandId/turnId at preflight acceptance so a
+ *   caller can reconcile after a lost acknowledgement frame.
+ * - The clientRef index is scoped to one live session runtime: identical refs
+ *   may coexist in different sessions, lookups never cross sessions, a ref
+ *   conflicts only while its record is retained (`client_ref_conflict`), and
+ *   after terminal TTL/capacity eviction a ref may be admitted again with the
+ *   prior outcome unknown — callers MUST NOT reuse a clientRef as a retry
+ *   mechanism and MUST treat `unknown` as uncertainty, not proof of
+ *   non-execution.
+ * - The durability floor is the live session process: after restart or
+ *   retained-record eviction, a lookup honestly reports `unknown`.
+ * - Q26 tracks prompts accepted through the SDK control surface (which always
+ *   carries a requesting connection); submissions without a delivery owner are
+ *   outside the reconciliation contract and hold no reservation.
+ */
+export declare const PROMPT_CLIENT_REF_MAX_LENGTH = 128;
+export interface TurnPromptImageInput {
+    data: string;
+    mimeType?: string;
+}
+/** Public input contract for ordered `turn.prompt`. */
+export interface TurnPromptInput {
+    text: string;
+    images?: TurnPromptImageInput[];
+    clientRef?: string;
+}
+/** Terminal outcome is preserved exactly; active records never age into terminal. */
+export type PromptReconciliationStatus = "accepted" | "in_flight" | "terminal_ok" | "failed";
+/** Exactly one selector per lookup. */
+export type TurnPromptStatusSelector = {
+    clientRef: string;
+} | {
+    commandId: string;
+    turnId: string;
+};
+interface TurnPromptReconciliationIdentity {
+    commandId: string;
+    turnId: string;
+    clientRef?: string;
+    /** Epoch milliseconds of preflight acceptance. */
+    acceptedAt: number;
+}
+export interface TurnPromptReconciliationAccepted extends TurnPromptReconciliationIdentity {
+    status: "accepted";
+}
+export interface TurnPromptReconciliationInFlight extends TurnPromptReconciliationIdentity {
+    status: "in_flight";
+    /** Epoch milliseconds of the agent_start transition. */
+    startedAt: number;
+}
+export interface TurnPromptReconciliationTerminalOk extends TurnPromptReconciliationIdentity {
+    status: "terminal_ok";
+    startedAt?: number;
+    /** Epoch milliseconds of the terminal transition. */
+    terminalAt: number;
+}
+export interface TurnPromptReconciliationFailed extends TurnPromptReconciliationIdentity {
+    status: "failed";
+    startedAt?: number;
+    terminalAt: number;
+    /** Bounded, sanitized failure detail (code safe-token ≤64, message ≤512). */
+    error: {
+        code: string;
+        message: string;
+    };
+}
+export interface TurnPromptReconciliationUnknown {
+    status: "unknown";
+}
+export type TurnPromptReconciliation = TurnPromptReconciliationAccepted | TurnPromptReconciliationInFlight | TurnPromptReconciliationTerminalOk | TurnPromptReconciliationFailed | TurnPromptReconciliationUnknown;
+/** Result of a successful `turn.prompt` preflight acknowledgement. */
+export interface TurnPromptAcceptedResult {
+    commandId: string;
+    turnId: string;
+    accepted: true;
+    clientRef?: string;
+}
+export {};

package/dist/types/sdk/session-directory.d.ts

@@ -20,7 +20,7 @@ export type ResolveManagedSessionScopeResult = {
     scope: ManagedSessionScope;
 } | {
     kind: "error";
-    code: "cwd_missing" | "cwd_not_directory" | "identity_unavailable" | "network_unsupported" | "sessions_root_unavailable" | "binding_conflict" | "binding_invalid";
+    code: "cwd_missing" | "cwd_not_directory" | "identity_unavailable" | "network_unsupported" | "sessions_root_unavailable" | "binding_conflict" | "binding_invalid" | "atomic_unavailable" | "durability_not_provable" | "durability_failed" | "invalid_request";
     message: string;
 };
 export interface LogicalSessionCandidate {

package/dist/types/sdk/startup-capability.d.ts

@@ -1,9 +1,12 @@
+import { type ModelProfileErrorCode, type ModelProfileErrorDetails } from "../config/model-profile-contract";
 export type SdkStartupPhase = "registration" | "startup";
 export type SdkStartupReason = "disabled" | "ineligible" | "factory_absent" | "runner_absent" | "pending" | "failed";
 export interface SdkStartupFailure {
     phase: SdkStartupPhase;
     reason: SdkStartupReason;
     message: string;
+    code?: ModelProfileErrorCode;
+    details?: ModelProfileErrorDetails;
 }
 export type SdkStartupResult = {
     status: "started";

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

@@ -542,6 +542,8 @@ export declare class AgentSession {
      *  recorded or the mode-state file is missing/unreadable; callers should
      *  treat undefined as a non-terminal phase (refuses to chain). */
     getActiveSkillPhase(): string | undefined;
+    /** Provider-facing ask metadata must expose only the active deep-interview phase. */
+    getDeepInterviewAskStage(): "topology" | "post-topology" | undefined;
     /** Peek the in-flight directive's invocation handler for use by the resolve tool. */
     peekQueueInvoker(): ((input: unknown) => Promise<unknown> | unknown) | undefined;
     peekStandingResolveHandler(): ((input: unknown) => Promise<unknown> | unknown) | undefined;

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

@@ -1,6 +1,7 @@
 import * as native from "@gajae-code/natives";
 import type { ResumeSessionIdentity } from "../session-manager";
-import { type ManagedDirectoryRoot, type ManagedSessionSecurityPolicy } from "./managed-session-storage";
+import { type NativeDirectoryTreeSnapshot } from "../session-storage";
+import { type ManagedDirectoryRoot, type ManagedSessionSecurityPolicy, type ManagedStorageLock } from "./managed-session-storage";
 export declare const MANAGED_SESSION_LAYOUT_VERSION: 2;
 export declare const MANAGED_SESSION_IDENTITY_VERSION: 1;
 export declare const MANAGED_SESSION_BINDING_FILE = ".gjc-managed-session-scope.v2.json";
@@ -33,7 +34,7 @@ export declare function managedDirectoryIdentityForScope(scope: ManagedScope): {
 };
 export declare function managedRootForScope(scope: ManagedScope): ManagedDirectoryRoot;
 export type ManagedMigrationPolicy = "copy-retain" | "disabled";
-export type ManagedScopeErrorCode = "cwd_missing" | "cwd_not_directory" | "identity_unavailable" | "network_unsupported" | "sessions_root_unavailable" | "binding_conflict" | "binding_invalid";
+export type ManagedScopeErrorCode = "cwd_missing" | "cwd_not_directory" | "identity_unavailable" | "network_unsupported" | "sessions_root_unavailable" | "binding_conflict" | "binding_invalid" | "atomic_unavailable" | "invalid_request" | "durability_failed" | "durability_not_provable";
 export type ManagedScopeResolution = {
     kind: "resolved";
     scope: ManagedScope;
@@ -41,6 +42,10 @@ export type ManagedScopeResolution = {
     kind: "error";
     code: ManagedScopeErrorCode;
     message: string;
+    cause?: {
+        readonly classification: string;
+        readonly diagnostic?: string;
+    };
 };
 export interface ManagedCandidate {
     sessionId: string;
@@ -63,7 +68,7 @@ export type ManagedCandidateListing = {
     code: "scan_failed" | "unsafe_root" | "invalid_candidate";
     message: string;
 };
-export type ManagedOpenFailure = "migration_busy" | "binding_conflict" | "binding_invalid" | "destination_conflict" | "source_changed" | "unsafe_artifacts" | "durability_failed" | "migration_retired" | "legacy_migration_disabled" | "managed_storage_unsupported";
+export type ManagedOpenFailure = "migration_busy" | "binding_conflict" | "binding_invalid" | "destination_conflict" | "source_changed" | "unsafe_artifacts" | "artifact_capacity_exceeded" | "durability_failed" | "atomic_unavailable" | "invalid_request" | "durability_not_provable" | "migration_retired" | "legacy_migration_disabled" | "managed_storage_unsupported";
 export type ManagedOpenCandidateResult = {
     kind: "opened";
     path: string;
@@ -80,6 +85,11 @@ export type ManagedDeleteCandidateResult = {
 } | {
     kind: "already_deleted";
     tombstonePath: string;
+} | {
+    kind: "cleanup_pending";
+    tombstonePath: string;
+    phase: "artifacts" | "transcript";
+    message: string;
 } | {
     kind: "error";
     code: ManagedOpenFailure;
@@ -105,10 +115,19 @@ interface ManagedScopeInput {
 export declare function resolveManagedScope(input: ManagedScopeInput): ManagedScopeResolution;
 /** Resolve a scope for a synchronous write without mutating an existing ACL mismatch. */
 export declare function resolveManagedScopeForWrite(input: ManagedScopeInput): ManagedScopeResolution;
+export declare function canonicalBindingOpenFlags(platform?: NodeJS.Platform): number;
+export declare function fsyncCanonicalBinding(bindingPath: string, expected: string): void;
 export declare function ensureManagedScope(scope: ManagedScope, policy?: ManagedSessionSecurityPolicy): Promise<ManagedScopeResolution>;
 /** Synchronously create and validate the v2 binding before a default session writer exists. */
 export declare function prepareManagedSessionScopeForWriteSync(scope: ManagedScope, policy?: ManagedSessionSecurityPolicy, authority?: ManagedCandidateWriteAuthority): ManagedScopeResolution;
 export declare function listManagedCandidates(scope: ManagedScope): ManagedCandidateListing;
+export declare function matchesMigrationArtifactRoot(pathname: string, identity: {
+    dev: bigint;
+    ino: bigint;
+    size: bigint;
+    mtimeNs: bigint;
+}, expectedTree: NativeDirectoryTreeSnapshot, platform?: NodeJS.Platform): boolean;
+export declare function restorePreparedArtifactRoot(scope: ManagedScope, source: ManagedCandidate, lock?: ManagedStorageLock): void;
 /** Resume tombstoned cleanup under its original operation lease without restoring retired candidates. */
 export declare function reconcileManagedTombstones(scope: ManagedScope): Promise<void>;
 /** Create the v2 binding and private write protocol directories before managed writes. */

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

@@ -1,10 +1,19 @@
 import { type NativeDirectoryTreeSnapshot, type NativeOwnerOnlySecurityResult, type RecoveryFsRoot } from "@gajae-code/natives";
+import { type NativePublishOutcome } from "./native-publish-outcome";
 export declare const MANAGED_ARTIFACT_MAX_DEPTH = 32;
-export declare const MANAGED_ARTIFACT_MAX_FILES = 10000;
+export declare const MANAGED_ARTIFACT_MAX_FILES = 50000;
 export declare const MANAGED_ARTIFACT_MAX_FILE_BYTES: number;
 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 diagnostic: string;
+    constructor(classification: ManagedPublishError["classification"], outcome: NativePublishOutcome);
+}
+/** Cleanup is safe only when the native move reports that it did not commit. */
+export declare function mayCleanManagedTreeStaging(error: unknown): boolean;
 export type ManagedSessionSecurityPolicy = "default" | "windows-existing-verify-first";
-export type ManagedStorageFailure = "migration_busy" | "binding_conflict" | "binding_invalid" | "destination_conflict" | "source_changed" | "unsafe_artifacts" | "durability_failed" | "migration_retired" | "managed_storage_unsupported";
+export type ManagedStorageFailure = "migration_busy" | "binding_conflict" | "binding_invalid" | "destination_conflict" | "source_changed" | "unsafe_artifacts" | "artifact_capacity_exceeded" | "durability_failed" | "atomic_unavailable" | "durability_not_provable" | "migration_retired" | "managed_storage_unsupported";
 export interface ManagedStorageLock {
     path: string;
     attemptId: string;
@@ -29,6 +38,13 @@ export interface ManagedDirectoryRoot {
     readonly dev: bigint;
     readonly ino: bigint;
 }
+/**
+ * Establish the first managed directory beneath a potentially shared ancestor.
+ * The ancestor is used only to create the managed chain; every component from
+ * `configuredRoot` downward is independently type, symlink, owner, mode, and
+ * ACL checked. This deliberately does not impose owner-only policy on `/tmp`.
+ */
+export declare function prepareManagedDirectoryRoot(configuredRoot: string, policy?: ManagedSessionSecurityPolicy): ManagedDirectoryRoot;
 export declare function managedDirectoryRoot(configuredRoot: string): ManagedDirectoryRoot;
 export declare function retainManagedDirectoryAuthority(root: ManagedDirectoryRoot, directory: string, expected?: {
     dev: bigint;
@@ -68,7 +84,7 @@ export declare class ManagedSessionDescendantStore {
     captureTree(relativePath: string): NativeDirectoryTreeSnapshot;
     /** Copy an exact captured tree into an absent managed destination. */
     importTree(sourceRelativePath: string, destinationRelativePath: string, snapshot: NativeDirectoryTreeSnapshot): Promise<void>;
-    moveTreeNoReplace(sourceRelativePath: string, destinationRelativePath: string, expected: NativeDirectoryTreeSnapshot): void;
+    moveTreeNoReplace(sourceRelativePath: string, destinationRelativePath: string, expected: NativeDirectoryTreeSnapshot): NativeDirectoryTreeSnapshot;
     removeTreeExpected(relativePath: string, expected: NativeDirectoryTreeSnapshot): void;
     fsyncTree(): NativeDirectoryTreeSnapshot;
 }
@@ -89,8 +105,12 @@ export declare function replaceManagedFile(destination: string, bytes: Uint8Arra
 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>;
+export interface ManagedArtifactTreeLimits {
+    maxFiles?: number;
+    maxTotalBytes?: number;
+}
 /** Bounds a no-follow artifact tree before it can be copied or deleted. */
-export declare function validateManagedArtifactTree(root: string): void;
+export declare function validateManagedArtifactTree(root: string, limits?: ManagedArtifactTreeLimits): void;
 /** Flush a copied managed artifact tree, including empty directories, before publishing its receipt. */
 export declare function fsyncManagedArtifactTree(root: string): NativeDirectoryTreeSnapshot;
 export declare function publishManagedTombstone(destination: string, record: Record<string, unknown>, assertOwned?: () => void): Promise<void>;

package/dist/types/session/internal/native-publish-outcome.d.ts

@@ -0,0 +1,48 @@
+export type NativePublishMutationState = "not_committed" | "committed" | "unknown";
+export type NativePublishDurabilityState = "not_attempted" | "proven" | "not_provable";
+export type NativePublishReason = "none" | "destination_exists" | "atomic_unavailable" | "cross_device" | "permission_denied" | "io_failure" | "interrupted" | "invalid_request" | "identity_violation" | "durability_not_provable" | "unknown";
+export type NativePublishOperation = "direct_rename" | "retained_file" | "retained_tree";
+export type NativePublishPrimitive = "renameat2_noreplace" | "renameatx_np_excl" | "windows_rename_noreplace" | "unsupported" | "unknown";
+export type NativePublishPhase = "preflight" | "file_sync" | "rename" | "source_parent_sync" | "destination_parent_sync" | "terminal_identity" | "complete" | "unknown";
+type SyncFailure = {
+    phase: Exclude<NativePublishPhase, "preflight" | "file_sync" | "rename" | "complete" | "unknown">;
+    parentRole: "source" | "destination" | "shared" | "staged_file";
+    osCode?: number;
+    kind: "unsupported" | "io" | "permission" | "other";
+};
+type PublishDiagnostic = {
+    schemaVersion: 1;
+    collectionState: "complete" | "partial" | "unavailable";
+    osCode?: number;
+    syncFailures?: readonly SyncFailure[];
+};
+export type NativePublishIdentity = {
+    readonly dev: string;
+    readonly ino: string;
+    readonly size: string;
+    readonly mtimeNs: string;
+    readonly ctimeNs: string;
+    readonly sha256?: string;
+};
+export type NativePublishOutcome = {
+    readonly ok: boolean;
+    readonly code?: string;
+    readonly identity?: NativePublishIdentity;
+    readonly mutationState: NativePublishMutationState;
+    readonly durabilityState: NativePublishDurabilityState;
+    readonly reason: NativePublishReason;
+    readonly primitive: NativePublishPrimitive;
+    readonly phase: NativePublishPhase;
+    readonly diagnostic: PublishDiagnostic;
+};
+/**
+ * Treat incompatible native results as an unknown mutation; never infer safety from legacy fields.
+ * Retained descriptor operations have a stricter contract than direct rename: a reported success
+ * includes the terminal identity and all required durability evidence.
+ */
+export declare function classifyNativePublishOutcome(value: unknown, operation?: NativePublishOperation): NativePublishOutcome;
+/** Only a fully validated pre-mutation result permits exact cleanup of current staging. */
+export declare function mayCleanCurrentStaging(outcome: NativePublishOutcome): boolean;
+/** Stable, bounded text for startup errors. Native paths and messages are intentionally excluded. */
+export declare function formatNativePublishDiagnostic(outcome: NativePublishOutcome): string;
+export {};

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

@@ -327,6 +327,9 @@ export declare class SessionMigrationPolicyError extends Error {
     readonly code = "legacy_migration_disabled";
     constructor();
 }
+export declare class SessionArtifactCapacityError extends Error {
+    constructor(message: string);
+}
 export type ResumeTailInspection = ResumeTailResumable | ResumeTailTerminal | ResumeTailError;
 export interface StrictSessionOpenSuccess {
     kind: "opened";
@@ -334,7 +337,8 @@ export interface StrictSessionOpenSuccess {
 }
 export interface StrictSessionOpenFailure {
     kind: "error";
-    reason: ResumeTailError["reason"] | "identity-mismatch" | "migration-required";
+    reason: ResumeTailError["reason"] | "identity-mismatch" | "migration-required" | "artifact_capacity_exceeded";
+    message?: string;
 }
 /** Exact transcript bytes and authority captured from one descriptor-bound read. */
 export interface CapturedSessionTranscriptSnapshot {

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

@@ -112,6 +112,11 @@ export interface SessionStorage {
     readSnapshotSync?(path: string): SessionStorageSnapshot;
     statSync(path: string): SessionStorageStat;
     listFilesSync(dir: string, pattern: string): string[];
+    /** List matching files with mtimes without issuing one JavaScript stat call per path. */
+    listFilesByMtime?(dir: string, pattern: string): Promise<Array<{
+        path: string;
+        mtimeMs: number;
+    }>>;
     /**
      * Strict directory scan that never suppresses scan/root errors. Used by strict
      * authorization inventory; the forgiving {@link listFilesSync} stays display-only.
@@ -184,6 +189,18 @@ export interface VerifiedSessionDeleteTarget {
     detachedArtifactsPath?: string;
     /** Identity-bound quarantine path retained when transcript unlink deferred cleanup. */
     detachedTranscriptPath?: string;
+    /** Native-retained publisher successor observed during transcript cleanup. */
+    retainedTranscriptSuccessorPath?: string;
+    /** Native-retained exchange placeholder observed during transcript cleanup. */
+    retainedTranscriptPlaceholderPath?: string;
+    /** Native-retained transcript entry whose identity could not be verified. */
+    retainedTranscriptUnknownPath?: string;
+    /** Native-retained publisher successor observed during cleanup. */
+    retainedArtifactsSuccessorPath?: string;
+    /** Native-retained exchange placeholder observed during cleanup. */
+    retainedArtifactsPlaceholderPath?: string;
+    /** Native-retained entry whose identity could not be verified. */
+    retainedArtifactsUnknownPath?: string;
     /** Caller-published, no-replace quarantine pathname for the next artifact detach. */
     plannedArtifactsPath?: string;
     /** Caller-published, no-replace quarantine pathname for the next transcript detach. */
@@ -215,6 +232,9 @@ export type VerifiedSessionDeleteResult = {
     artifactsTree: NativeDirectoryTreeSnapshot;
     /** Transcript identity (unchanged) for retry binding. */
     transcriptIdentity: SessionStorageFileIdentity;
+    retainedSuccessorPath?: string;
+    retainedPlaceholderPath?: string;
+    retainedUnknownPath?: string;
 } | {
     kind: "cleanup_pending";
     phase: "transcript";
@@ -223,6 +243,9 @@ export type VerifiedSessionDeleteResult = {
     transcriptIdentity: SessionStorageFileIdentity;
     /** Optional identity-bound transcript quarantine path for restart cleanup. */
     detachedTranscriptPath?: string;
+    retainedSuccessorPath?: string;
+    retainedPlaceholderPath?: string;
+    retainedUnknownPath?: string;
 };
 type NativeDirectoryTreeEntry = {
     relativePath: string;
@@ -249,6 +272,10 @@ export declare class FileSessionStorage implements SessionStorage {
     readSnapshotSync(fpath: string): SessionStorageSnapshot;
     statSync(path: string): SessionStorageStat;
     listFilesSync(dir: string, pattern: string): string[];
+    listFilesByMtime(dir: string, pattern: string): Promise<Array<{
+        path: string;
+        mtimeMs: number;
+    }>>;
     listFilesStrictSync(dir: string, pattern: string): string[];
     exists(path: string): Promise<boolean>;
     readText(path: string): Promise<string>;
@@ -281,6 +308,10 @@ export declare class MemorySessionStorage implements SessionStorage {
     readSnapshotSync(path: string): SessionStorageSnapshot;
     statSync(path: string): SessionStorageStat;
     listFilesSync(dir: string, pattern: string): string[];
+    listFilesByMtime(dir: string, pattern: string): Promise<Array<{
+        path: string;
+        mtimeMs: number;
+    }>>;
     listFilesStrictSync(dir: string, pattern: string): string[];
     exists(path: string): Promise<boolean>;
     readText(path: string): Promise<string>;

package/dist/types/skill-state/active-state.d.ts

@@ -45,6 +45,8 @@ export interface SkillActiveEntry {
     handoff_at?: string;
     active_subskills?: ActiveSubskillEntry[];
     source_state_revision?: number;
+    /** Durable ordering token from the source workflow mode-state, not this cache file's revision. */
+    committed_mode_state_revision?: number;
 }
 export interface SkillActiveState {
     version?: number;
@@ -85,6 +87,8 @@ export interface SyncSkillActiveStateOptions {
     handoff_at?: string;
     active_subskills?: ActiveSubskillEntry[];
     sourceRevision?: number;
+    /** Durable ordering token from the source workflow mode-state, not this cache file's revision. */
+    committedModeRevision?: number;
 }
 export declare function normalizeWorkflowHudSummary(raw: unknown): WorkflowHudSummary | undefined;
 export declare function isCanonicalGjcWorkflowSkill(skill: string): skill is CanonicalGjcWorkflowSkill;

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

@@ -36,7 +36,9 @@ export declare class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskT
     get description(): string;
     private constructor();
     /**
-     * Create a TaskTool instance with async agent discovery.
+     * Create a TaskTool instance.
+     * Repository authority is captured from session cwd *before* agent discovery so
+     * multi-repo workspaces fail closed prior to context/discovery (#2901).
      */
     static create(session: ToolSession): Promise<TaskTool>;
     execute(_toolCallId: string, rawParams: unknown, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<TaskToolDetails>): Promise<AgentToolResult<TaskToolDetails>>;

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

@@ -59,6 +59,8 @@ export interface TaskResultReceipt {
     extractedToolCounts?: Record<string, number>;
     forkContext?: SingleResult["forkContext"];
     forkContextAdvisory?: SingleResult["forkContextAdvisory"];
+    /** Resolved repository identity for this delegated lane (#2901). */
+    repositoryBinding?: SingleResult["repositoryBinding"];
     roi?: TaskRoi;
 }
 /**

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

@@ -52,6 +52,15 @@ export declare const taskItemSchema: z.ZodObject<{
         none: "none";
         receipt: "receipt";
     }>>;
+    repositoryBinding: z.ZodOptional<z.ZodObject<{
+        schema: z.ZodLiteral<"gjc.repository_binding.v1">;
+        worktreeRoot: z.ZodString;
+        commonDir: z.ZodNullable<z.ZodString>;
+        relativeSubdir: z.ZodOptional<z.ZodString>;
+        displayPath: z.ZodOptional<z.ZodString>;
+        head: z.ZodOptional<z.ZodString>;
+        branch: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
 }, z.core.$strip>;
 export type TaskItem = z.infer<typeof taskItemSchema>;
 export declare const taskSchema: z.ZodObject<{
@@ -67,6 +76,15 @@ export declare const taskSchema: z.ZodObject<{
             none: "none";
             receipt: "receipt";
         }>>;
+        repositoryBinding: z.ZodOptional<z.ZodObject<{
+            schema: z.ZodLiteral<"gjc.repository_binding.v1">;
+            worktreeRoot: z.ZodString;
+            commonDir: z.ZodNullable<z.ZodString>;
+            relativeSubdir: z.ZodOptional<z.ZodString>;
+            displayPath: z.ZodOptional<z.ZodString>;
+            head: z.ZodOptional<z.ZodString>;
+            branch: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
     }, z.core.$strip>>;
     spawnPlan: z.ZodOptional<z.ZodObject<{
         whyParallel: z.ZodString;
@@ -89,6 +107,15 @@ export declare const taskSchemaNoIsolation: z.ZodObject<{
             none: "none";
             receipt: "receipt";
         }>>;
+        repositoryBinding: z.ZodOptional<z.ZodObject<{
+            schema: z.ZodLiteral<"gjc.repository_binding.v1">;
+            worktreeRoot: z.ZodString;
+            commonDir: z.ZodNullable<z.ZodString>;
+            relativeSubdir: z.ZodOptional<z.ZodString>;
+            displayPath: z.ZodOptional<z.ZodString>;
+            head: z.ZodOptional<z.ZodString>;
+            branch: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
     }, z.core.$strip>>;
     spawnPlan: z.ZodOptional<z.ZodObject<{
         whyParallel: z.ZodString;
@@ -111,6 +138,15 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
             none: "none";
             receipt: "receipt";
         }>>;
+        repositoryBinding: z.ZodOptional<z.ZodObject<{
+            schema: z.ZodLiteral<"gjc.repository_binding.v1">;
+            worktreeRoot: z.ZodString;
+            commonDir: z.ZodNullable<z.ZodString>;
+            relativeSubdir: z.ZodOptional<z.ZodString>;
+            displayPath: z.ZodOptional<z.ZodString>;
+            head: z.ZodOptional<z.ZodString>;
+            branch: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
     }, z.core.$strip>>;
     spawnPlan: z.ZodOptional<z.ZodObject<{
         whyParallel: z.ZodString;
@@ -132,6 +168,15 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
             none: "none";
             receipt: "receipt";
         }>>;
+        repositoryBinding: z.ZodOptional<z.ZodObject<{
+            schema: z.ZodLiteral<"gjc.repository_binding.v1">;
+            worktreeRoot: z.ZodString;
+            commonDir: z.ZodNullable<z.ZodString>;
+            relativeSubdir: z.ZodOptional<z.ZodString>;
+            displayPath: z.ZodOptional<z.ZodString>;
+            head: z.ZodOptional<z.ZodString>;
+            branch: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
     }, z.core.$strip>>;
     spawnPlan: z.ZodOptional<z.ZodObject<{
         whyParallel: z.ZodString;
@@ -153,6 +198,15 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
             none: "none";
             receipt: "receipt";
         }>>;
+        repositoryBinding: z.ZodOptional<z.ZodObject<{
+            schema: z.ZodLiteral<"gjc.repository_binding.v1">;
+            worktreeRoot: z.ZodString;
+            commonDir: z.ZodNullable<z.ZodString>;
+            relativeSubdir: z.ZodOptional<z.ZodString>;
+            displayPath: z.ZodOptional<z.ZodString>;
+            head: z.ZodOptional<z.ZodString>;
+            branch: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
     }, z.core.$strip>>;
     spawnPlan: z.ZodOptional<z.ZodObject<{
         whyParallel: z.ZodString;
@@ -174,6 +228,15 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
             none: "none";
             receipt: "receipt";
         }>>;
+        repositoryBinding: z.ZodOptional<z.ZodObject<{
+            schema: z.ZodLiteral<"gjc.repository_binding.v1">;
+            worktreeRoot: z.ZodString;
+            commonDir: z.ZodNullable<z.ZodString>;
+            relativeSubdir: z.ZodOptional<z.ZodString>;
+            displayPath: z.ZodOptional<z.ZodString>;
+            head: z.ZodOptional<z.ZodString>;
+            branch: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
     }, z.core.$strip>>;
     spawnPlan: z.ZodOptional<z.ZodObject<{
         whyParallel: z.ZodString;
@@ -195,6 +258,15 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
             none: "none";
             receipt: "receipt";
         }>>;
+        repositoryBinding: z.ZodOptional<z.ZodObject<{
+            schema: z.ZodLiteral<"gjc.repository_binding.v1">;
+            worktreeRoot: z.ZodString;
+            commonDir: z.ZodNullable<z.ZodString>;
+            relativeSubdir: z.ZodOptional<z.ZodString>;
+            displayPath: z.ZodOptional<z.ZodString>;
+            head: z.ZodOptional<z.ZodString>;
+            branch: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
     }, z.core.$strip>>;
     spawnPlan: z.ZodOptional<z.ZodObject<{
         whyParallel: z.ZodString;
@@ -216,6 +288,15 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
             none: "none";
             receipt: "receipt";
         }>>;
+        repositoryBinding: z.ZodOptional<z.ZodObject<{
+            schema: z.ZodLiteral<"gjc.repository_binding.v1">;
+            worktreeRoot: z.ZodString;
+            commonDir: z.ZodNullable<z.ZodString>;
+            relativeSubdir: z.ZodOptional<z.ZodString>;
+            displayPath: z.ZodOptional<z.ZodString>;
+            head: z.ZodOptional<z.ZodString>;
+            branch: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
     }, z.core.$strip>>;
     spawnPlan: z.ZodOptional<z.ZodObject<{
         whyParallel: z.ZodString;
@@ -431,6 +512,19 @@ export interface SingleResult {
         recommendedMode: ForkContextMode;
         reasons: string[];
     };
+    /**
+     * Resolved repository identity used for this task after pre-discovery stamping
+     * and fail-closed validation (#2901).
+     */
+    repositoryBinding?: {
+        schema: "gjc.repository_binding.v1";
+        worktreeRoot: string;
+        commonDir: string | null;
+        relativeSubdir?: string;
+        displayPath?: string;
+        head?: string;
+        branch?: string;
+    };
 }
 /** True only for complete, factual five-bucket cost accounting. */
 export declare function hasCompleteUsageCostBreakdown(usage: unknown): boolean;