@gajae-code/coding-agent 0.15.5 → 0.15.6

package/dist/types/gjc-runtime/empty-delete-gc.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Official GC of already-quarantined empty `.gjc-delete-*` receipts.
+ * Roots are operator operands — never hardcoded host paths.
+ */
+import type { BigIntStats } from "node:fs";
+import { exactUnlinkDirect } from "@gajae-code/natives";
+export declare const EMPTY_DELETE_PREFIX = ".gjc-delete-";
+export interface EmptyDeleteIdentity {
+    dev: bigint;
+    ino: bigint;
+    nlink: bigint;
+    size: bigint;
+    mtimeNs: bigint;
+    parentDev: bigint;
+    parentIno: bigint;
+    sha256: string;
+}
+export interface EmptyDeleteGcRecord {
+    root: string;
+    path: string;
+    action: "would_remove" | "removed" | "kept" | "skipped";
+    reason: string;
+    identity?: EmptyDeleteIdentity;
+    /** A dry-run candidate is an observation, never deletion authority. */
+    observationOnly?: boolean;
+    /** Retained-object paths a native direct unlink left behind; operator-recoverable only there. */
+    retainedPaths?: {
+        detached?: string;
+        successor?: string;
+        placeholder?: string;
+        unknown?: string;
+    };
+}
+export interface EmptyDeleteGcReport {
+    dry_run: boolean;
+    roots: string[];
+    records: EmptyDeleteGcRecord[];
+    would_remove: number;
+    removed: number;
+    kept: number;
+    skipped: number;
+    errors: string[];
+}
+export interface EmptyDeleteGcOptions {
+    roots: string[];
+    prune: boolean;
+}
+export interface EmptyDeleteGcDependencies {
+    /** Internal seam for deterministic collect-to-prune race tests. */
+    collect?: (root: string) => Promise<EmptyDeleteGcRecord[]>;
+    exactUnlinkDirect?: typeof exactUnlinkDirect;
+}
+export declare function collectEmptyDeleteReceipts(root: string, deps?: {
+    lstat?: (file: string, options: {
+        bigint: true;
+    }) => Promise<BigIntStats>;
+}): Promise<EmptyDeleteGcRecord[]>;
+export declare function runEmptyDeleteGc(options: EmptyDeleteGcOptions, deps?: EmptyDeleteGcDependencies): Promise<EmptyDeleteGcReport>;

package/dist/types/gjc-runtime/gc-runtime.d.ts

@@ -12,6 +12,7 @@
  *   error all mean KEEP — a live process is never signalled or killed.
  * - Dry-run by default: nothing is deleted unless `--prune`/`--force`.
  */
+import { type EmptyDeleteGcReport } from "./empty-delete-gc";
 import { type GcSessionScopeUsage } from "./gc-session-scope";
 export type GcStore = "harness_leases" | "file_locks" | "tmux_sessions" | "registry_entries" | "local_roots";
 export declare const GC_STORES: readonly GcStore[];
@@ -127,6 +128,7 @@ export interface GcReport {
      * PID-liveness axis above is unchanged by its absence or presence.
      */
     disk?: GcDiskReport;
+    empty_delete_receipts?: EmptyDeleteGcReport;
 }
 export interface GcRunResult {
     stdout: string;

package/dist/types/gjc-runtime/session-state-lock.d.ts

@@ -62,6 +62,12 @@ export declare const SessionStateLockTestHooks: {
     unqualifiedOwnerIsLocal?: boolean;
     /** @internal Runs after final live-owner validation and before descriptor rewrite. */
     afterCurrentOwnerValidation?: (file: string) => void | Promise<void>;
+    /** @internal Fault seam immediately before a held owner record rewrite mutates bytes. */
+    beforeOwnerRecordRewrite?: (file: string) => void | Promise<void>;
+    /** @internal Fault seam immediately before final transition-generation validation. */
+    beforeTransitionReleaseLstat?: (transitionDir: string) => void | Promise<void>;
+    /** @internal Fault seam immediately before setup generation capture. */
+    beforeTransitionSetupLstat?: (transitionDir: string) => void | Promise<void>;
     /**
      * @internal Runs after a live owner has been proven and immediately before its
      * final pathname capture for release. Tests use it to replace the pathname and
@@ -69,10 +75,30 @@ export declare const SessionStateLockTestHooks: {
      */
     beforeCurrentOwnerRelease?: (file: string) => void | Promise<void>;
     beforeLegacyDirectoryRemoval?: (lockDir: string) => void | Promise<void>;
+    /** @internal Last quarantine name minted in the current lock cycle (tests). */
+    lastQuarantineName?: string;
+    /** @internal Count of quarantine names minted in the current lock cycle (tests). */
+    quarantineMints?: number;
+    /** @internal Force the next mint to this name so leftover-collision tests can plant it. */
+    forcedQuarantineName?: string;
+    /** @internal Observes bounded acquisition retries without changing their timing. */
+    afterAcquireContention?: (lockFile: string, attempt: number, elapsedMs: number) => void;
 };
 /** Raised when the lock could not be acquired; callers map it to their own refusal. */
+export type SessionStateLockUnavailableReason = "acquire_timeout" | "legacy_directory_owner_unprovenanced" | "lock_initialization_failed" | "lock_inspection_failed" | "lock_owner_live_or_unverifiable" | "lock_owner_record_fresh" | "lock_owner_record_unprovenanced" | "lock_release_failed" | "transition_claim_timeout" | "unsafe_lock_path_type";
+interface SessionStateLockUnavailableDetails {
+    lockPath: string;
+    reason: SessionStateLockUnavailableReason;
+    attempts?: number;
+    elapsedMs?: number;
+    cause?: unknown;
+}
 export declare class SessionStateLockUnavailableError extends Error {
-    constructor(cause?: unknown);
+    readonly lockPath?: string;
+    readonly reason?: SessionStateLockUnavailableReason;
+    readonly attempts?: number;
+    readonly elapsedMs?: number;
+    constructor(causeOrDetails?: unknown | SessionStateLockUnavailableDetails);
 }
 /**
  * The identity-bound deletion primitives this lock is built on.
@@ -85,7 +111,7 @@ export declare class SessionStateLockUnavailableError extends Error {
  * caller proved. A replacement is therefore never deleted, by construction rather than by
  * a narrower window.
  */
-export type SessionStateLockNativeBindings = Pick<typeof import("@gajae-code/natives"), "exactRemoveDirectoryTree" | "exactUnlink" | "snapshotDirectoryTree">;
+export type SessionStateLockNativeBindings = Pick<typeof import("@gajae-code/natives"), "exactRemoveDirectoryTree" | "exactUnlink" | "exactUnlinkDirect" | "snapshotDirectoryTree">;
 /** How the deletion primitives are obtained. Throwing means they are unavailable. */
 type SessionStateLockNativeLoader = () => SessionStateLockNativeBindings;
 /**
@@ -102,12 +128,15 @@ type SessionStateLockNativeLoader = () => SessionStateLockNativeBindings;
  */
 export declare function setSessionStateLockNativeBindings(load: SessionStateLockNativeLoader | undefined): void;
 /**
- * Decide what actually occupies the lock path, without following it.
+ * Verified empty leftover at a reserved quarantine name is incomplete debris, not
+ * in-progress cleanup.
  *
- * @internal exported as the seam these decisions are tested through: a live legacy
- * directory owner must be provably left alone without waiting out a real stale window.
+ * Deletion authority is the native identity-bound direct unlink — never a plain
+ * pathname unlink. A replacement planted at the reserved name between observation
+ * and deletion has a different inode identity and is refused by construction.
  */
-export declare function reclaimStaleSessionStateLock(lockFile: string): Promise<void>;
+export declare function removeVerifiedEmptyQuarantine(directory: string, name: string): Promise<void>;
+export declare function reclaimStaleSessionStateLock(lockFile: string, quarantineName?: string): Promise<void>;
 /**
  * Serialize one read-modify-write of `stateFile` against every other holder of
  * `<stateFile>.lock`.

package/dist/types/gjc-runtime/session-state-sidecar.d.ts

@@ -195,6 +195,12 @@ export declare function persistCoordinatorRuntimeStateFromEvent(event: RuntimeSt
  * sidecar never trusts a model-supplied name.
  */
 observation?: CoordinatorToolObservation): Promise<void>;
+export declare function persistCoordinatorWorkerIntegrationOutcome(context: RuntimeStateContext, outcome: {
+    kind: "worker_integration" | "terminal_persistence";
+    status: "completed" | "failed" | "timed_out";
+    correlationId?: string;
+    error?: string;
+}): Promise<void>;
 export declare function ownerTerminalContextFromEnvironment(): OwnerTerminalContext | "invalid" | null;
 export declare function persistCoordinatorRuntimeStateFromPostmortem(reason: postmortem.Reason, context: RuntimeStateContext): Promise<void>;
 export declare function registerCoordinatorRuntimeStateFinalizer(context: RuntimeStateContext): () => void;

package/dist/types/index.d.ts

@@ -28,6 +28,7 @@ export * from "./session/session-dump-format";
 export * from "./session/session-manager";
 export * from "./task/executor";
 export type * from "./task/types";
+export * from "./telemetry";
 export * from "./tools";
 export * from "./utils/git";
 export { HookEditorComponent as ExtensionEditorComponent, HookInputComponent as ExtensionInputComponent, HookSelectorComponent as ExtensionSelectorComponent, };

package/dist/types/main.d.ts

@@ -47,7 +47,9 @@ export interface InteractiveModeNotify {
     kind: "warn" | "error" | "info";
     message: string;
 }
-export declare function submitInteractiveInput(mode: Pick<InteractiveMode, "markPendingSubmissionStarted" | "finishPendingSubmission" | "showError" | "checkShutdownRequested" | "waitForAgentEnd">, session: Pick<AgentSession, "prompt" | "promptCustomMessage">, input: SubmittedUserInput): Promise<void>;
+export declare function submitInteractiveInput(mode: Pick<InteractiveMode, "markPendingSubmissionStarted" | "finishPendingSubmission" | "showError" | "checkShutdownRequested" | "waitForAgentEnd">, session: Pick<AgentSession, "prompt" | "promptCustomMessage"> & {
+    continuePersistedHistory?: AgentSession["continuePersistedHistory"];
+}, input: SubmittedUserInput): Promise<void>;
 type StartupModelProfileArgs = {
     session: AgentSession;
     settings: Settings;

package/dist/types/modes/components/jobs-overlay-model.d.ts

@@ -7,10 +7,11 @@
  */
 import type { SelectItem } from "@gajae-code/tui";
 import type { JobsSnapshot } from "../jobs-observer";
-export type JobRefKind = "monitor" | "cron";
+export type JobRefKind = "monitor" | "cron" | "folded";
 export interface JobRef {
     kind: JobRefKind;
     id: string;
+    generation?: string;
 }
 /** Compact relative time, e.g. "in 5m", "2m ago", "now". */
 export declare function formatRelative(targetMs: number | undefined, nowMs?: number): string;
@@ -18,7 +19,8 @@ export declare function formatRelative(targetMs: number | undefined, nowMs?: num
 export declare function parseJobRef(value: string): JobRef | null;
 /**
  * Build the grouped jobs list: monitors first (newest-first), then crons
- * (newest-first). The snapshot arrays are already sorted newest-first.
+ * (newest-first), then read-only folded jobs. The snapshot arrays are already
+ * sorted newest-first where a source has a timestamp.
  */
 export declare function buildJobsListItems(snapshot: JobsSnapshot): SelectItem[];
 /**

package/dist/types/modes/jobs-observer.d.ts

@@ -14,11 +14,43 @@
  */
 import type { AsyncJob, AsyncJobManager } from "../async";
 export type JobsWorstState = "none" | "running" | "failed";
+export type JobDeliveryState = "pending" | "delivered" | "failed-visible";
+/** The manager-owned, one-pass job projection consumed by this observer. */
+export interface AsyncJobSnapshotEntry {
+    id: string;
+    kind: string;
+    label: string;
+    status: AsyncJob["status"];
+    generation: string;
+    backgrounded: boolean;
+    deliveryState: JobDeliveryState;
+}
+/** Scalar delivery failure evidence that may outlive the AsyncJob record. */
+export interface DeadLetteredJobSnapshotEntry {
+    jobId: string;
+    generation: string;
+    ownerId?: string;
+    backgrounded?: boolean;
+    attempt: number;
+    lastError?: string;
+    recordedAt: number;
+}
+export interface AsyncJobsSnapshot {
+    jobs: AsyncJobSnapshotEntry[];
+    deadLettered: DeadLetteredJobSnapshotEntry[];
+}
 export interface MonitorJobView {
     id: string;
     label: string;
     status: AsyncJob["status"];
     startTime: number;
+    generation?: string;
+    backgrounded?: boolean;
+    deliveryState?: JobDeliveryState;
+}
+export interface FoldedJobView extends AsyncJobSnapshotEntry {
+    /** Safe diagnostic retained for a dead-lettered delivery, when available. */
+    errorText?: string;
 }
 export interface CronJobView {
     id: string;
@@ -34,6 +66,10 @@ export interface CronJobView {
 export interface JobsSnapshot {
     monitors: MonitorJobView[];
     crons: CronJobView[];
+    /** Backgrounded work and undeliverable terminal work that must stay visible. */
+    foldedJobs?: FoldedJobView[];
+    /** Scalar dead-letter evidence retained for diagnostics and red-drill-in. */
+    deadLettered?: DeadLetteredJobSnapshotEntry[];
     activeMonitorCount: number;
     activeCronCount: number;
     worstState: JobsWorstState;

package/dist/types/sdk/broker/broker.d.ts

@@ -1,5 +1,6 @@
 import type { NativeDirectoryTreeSnapshot } from "@gajae-code/natives";
 import type { ModelProfileErrorDetails } from "../../config/model-profile-contract";
+import { type SdkHostModelResolver } from "../host/model-pin";
 import { type DirectoryMigrationPolicy } from "../session-directory";
 import { type BrokerDiscovery, type BrokerPublicationObservation, type RedactedBrokerDiscovery } from "./discovery";
 import { type LifecycleDurableEffectsReceipt, LifecycleLedger, type LifecycleStartupFailureReceipt } from "./lifecycle-ledger";
@@ -11,6 +12,8 @@ export interface BrokerSettings {
     heartbeatTtlMs?: number;
     /** Broker-owned migration policy. Client lifecycle frames cannot select it. */
     resolveDirectoryMigration?: (_cwd: string) => Promise<DirectoryMigrationPolicy>;
+    /** Host model resolver override for lifecycle tests and embedders. */
+    resolveModelPin?: SdkHostModelResolver;
 }
 type ResolvedBrokerSettings = {
     agentDir: string;

package/dist/types/sdk/bus/kind-aware-reconciliation.d.ts

@@ -29,10 +29,13 @@ export interface KindAwareReconciliation {
     noteTransition(kind: ReconciliationKind, correlation: PromptCorrelation | undefined, frame: {
         type: "agent_start" | "agent_end";
         content?: TurnResultContent;
+        hasActivity?: boolean;
+        outcome?: SdkPromptTerminalOutcome;
     } | {
         type: "agent_failed";
         error: unknown;
         content?: TurnResultContent;
+        hasActivity?: boolean;
     }): Promise<void>;
     claimPendingOutcome(kind: ReconciliationKind, correlation: PromptCorrelation, outcome: SdkPromptTerminalOutcome, receiptState?: Extract<ReceiptState, "present" | "missing">): Promise<SdkPromptTerminalOutcome>;
     finalizeOutcome(kind: ReconciliationKind, correlation: PromptCorrelation, outcome?: SdkPromptTerminalOutcome, recordError?: {

package/dist/types/sdk/bus/prompt-reconciliation.d.ts

@@ -22,6 +22,7 @@
  *   record that has none, but never changes status, terminalAt, or retention.
  */
 import { PROMPT_FAILURE_CODE_MAX, sanitizePromptFailure } from "../prompt-failure";
+import type { SdkPromptTerminalOutcome } from "../prompt-status";
 import type { ReceiptState } from "../receipt-state";
 export { PROMPT_FAILURE_CODE_MAX, sanitizePromptFailure };
 export declare const PROMPT_RECONCILIATION_ACTIVE_CAPACITY = 128;
@@ -102,10 +103,13 @@ export interface PromptReconciliation {
     } | {
         type: "agent_end";
         finalText?: string;
+        hasActivity?: boolean;
+        outcome?: SdkPromptTerminalOutcome;
     } | {
         type: "agent_failed";
         error: unknown;
         finalText?: string;
+        hasActivity?: boolean;
     }): void;
     lookup(selector: {
         commandId?: string;

package/dist/types/sdk/client/discovery.d.ts

@@ -22,6 +22,7 @@ export declare class SdkDiscoveryError extends Error {
     constructor(path: string, message: string);
 }
 export type SdkSessionEndpointScope = "default" | "chat";
+export declare function endpointDirectory(repo: string, scope?: SdkSessionEndpointScope): string;
 /** Lists endpoint files and returns individual malformed or unreadable records as warnings. */
 export declare function listSdkSessionEndpoints(repo: string): Promise<SdkSessionEndpointList>;
 /** Resolves one per-session SDK endpoint discovery file. */

package/dist/types/sdk/host/model-pin.d.ts

@@ -5,7 +5,10 @@ export interface SdkHostModelResolveContext {
     cwd?: string;
 }
 /** Registry loader owned by the SDK host, not by machine-facing adapters. */
-export type SdkHostModelRegistryLoader = (context?: SdkHostModelResolveContext) => ModelRegistry | Promise<ModelRegistry>;
+export type SdkHostModelRegistryLoader = ((context?: SdkHostModelResolveContext) => ModelRegistry | Promise<ModelRegistry>) & {
+    acquire?: (context?: SdkHostModelResolveContext) => () => void;
+    dispose?: () => Promise<void>;
+};
 /**
  * Builds an offline model resolver for a single SDK host process.
  *
@@ -22,7 +25,9 @@ export type SdkHostModelResolution = {
     model: string;
     error: string;
 };
-export type SdkHostModelResolver = (raw: unknown, context?: SdkHostModelResolveContext) => Promise<SdkHostModelResolution>;
+export type SdkHostModelResolver = ((raw: unknown, context?: SdkHostModelResolveContext) => Promise<SdkHostModelResolution>) & {
+    dispose?: () => Promise<void>;
+};
 /** Resolve the explicit model pin at the SDK host boundary. */
 export declare function resolveSdkHostModel(raw: unknown, loadRegistry: SdkHostModelRegistryLoader, context?: SdkHostModelResolveContext): Promise<SdkHostModelResolution>;
 /** Default resolver used by the SDK broker host. */

package/dist/types/sdk/host/sdk-run-capability.d.ts

@@ -0,0 +1 @@
+export { createSdkRunCapability } from "../../session/sdk-run-capability-internal";

package/dist/types/sdk/host/session-runtime.d.ts

@@ -1,5 +1,6 @@
 import { type Settings } from "../../config/settings";
 import type { ExtensionAPI, ExtensionContext } from "../../extensibility/extensions";
+import { type TurnResultContent } from "../turn-result";
 import { SessionSdkHost, type SessionSdkHostOptions } from "./host";
 import { type SessionSurface } from "./query";
 import { type SdkCapabilities, type SdkSurfacePolicy } from "./surface-policy";
@@ -194,9 +195,18 @@ export interface InvocationReconciliation {
     noteAccepted(kind: InvocationKind, correlation: InvocationCorrelation, clientRef?: string): Promise<void>;
     noteTransition(kind: InvocationKind, correlation: InvocationCorrelation | undefined, frame: {
         type: "agent_start" | "agent_end";
+        content?: TurnResultContent;
+        hasActivity?: boolean;
+        outcome?: {
+            kind: "stopped";
+            reason: "cancelled";
+            provenance: "client_cancel";
+        };
     } | {
         type: "agent_failed";
         error: unknown;
+        content?: TurnResultContent;
+        hasActivity?: boolean;
     }): Promise<void>;
     lookup(kind: InvocationKind, selector: {
         commandId?: string;
@@ -228,7 +238,11 @@ export interface InvocationReconciliation {
     }, arg4?: (() => boolean) | {
         code: string;
         message: string;
-    }, arg5?: unknown): Promise<void>;
+    }, arg5?: unknown, arg6?: {
+        content?: TurnResultContent;
+        hasActivity?: boolean;
+        outcomeKind?: string;
+    }): Promise<void>;
     markUncertain(kind: InvocationKind, correlation: InvocationCorrelation, isCurrent?: () => boolean, deadlineMaxAt?: number): Promise<void>;
 }
 export declare function createInvocationReconciliation(options?: {

package/dist/types/sdk/prompt-deadline-manager.d.ts

@@ -1,5 +1,6 @@
 import type { KindAwareReconciliation } from "./bus/kind-aware-reconciliation";
 import type { InvocationCorrelation, InvocationReconciliation } from "./host/session-runtime";
+import type { TurnResultContent } from "./turn-result";
 type DeadlineReconciliation = InvocationReconciliation | KindAwareReconciliation;
 export type PromptDeadlineOutcome = {
     kind: "failed";
@@ -7,6 +8,15 @@ export type PromptDeadlineOutcome = {
     message: string;
     provenance: "deadline";
 };
+export interface PromptTerminalTransitionEvidence {
+    content?: TurnResultContent;
+    hasActivity?: boolean;
+    outcome?: {
+        kind: "stopped";
+        reason: "cancelled";
+        provenance: "client_cancel";
+    };
+}
 export declare class PromptDeadlineManager {
     #private;
     constructor(options: {
@@ -28,7 +38,7 @@ export declare class PromptDeadlineManager {
     noteTerminalTransition(correlation: InvocationCorrelation, pendingFailure?: {
         code: string;
         message: string;
-    }): void;
+    }, evidence?: PromptTerminalTransitionEvidence): void;
     clear(correlation: InvocationCorrelation): void;
     clearAll(): void;
     /** For tests: current deadline or undefined if no lease. */

package/dist/types/sdk/protocol/adapter-validation.d.ts

@@ -9,6 +9,8 @@ export type AdapterValidationError = {
     code: "invalid_reload_component" | "invalid_input";
     message: string;
 };
+/** Rejects instruction-bearing controls before correlation or provider work. */
+export declare function validateRequiredPromptText(operation: string, input: Input): AdapterValidationError | undefined;
 /** Validates controls that adapters must reject before forwarding them to a host. */
 export declare function validateAdapterControl(operation: string, input: Input): AdapterValidationError | undefined;
 export {};

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

@@ -1,6 +1,13 @@
 import { type SessionIndex } from "../broker/session-index";
 import { type SdkDispatchContext, type SdkDispatchHandler } from "../client/client";
 import { type ActivatedPreparedSession } from "../session-activation";
+export interface SessionEndpointIdentity {
+    readonly mtimeMs: number;
+    readonly mtimeNs: bigint;
+    readonly ctimeNs: bigint;
+    readonly size: bigint;
+    readonly ino: bigint;
+}
 /**
  * Exact identity of one attached SDK session endpoint. Providers persist it next to
  * their conversation state and re-prove it before every resume, so it must be derived
@@ -14,6 +21,8 @@ export declare function sessionAttachmentAuthorityId(input: {
     endpointMtimeMs: number | undefined;
     url: string;
     token: string;
+    /** Proven no-follow endpoint identity, when the caller has one. */
+    endpointIdentity?: SessionEndpointIdentity;
 }): string;
 /** The only capability a provider may retain for an attached SDK session. */
 export interface SessionAttachment {

package/dist/types/session/account-inventory.d.ts

@@ -59,6 +59,7 @@ export interface AccountInventoryInput {
             provider: string;
         }>;
         getProviderBaseUrl?: (provider: string) => string | undefined;
+        getAuthStorageOwner?: () => object;
     };
     sessionId?: string;
     provider?: string;

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

@@ -109,6 +109,7 @@ import { type ConfiguredFallbackChain, type FallbackChainRuntimeState } from "./
 export { DefaultModelSelectionRecoveryError } from "./default-model-selection";
 import type { ClientBridge, ClientBridgePermissionOption, ClientBridgePermissionOutcome, ClientBridgePermissionToolCall } from "./client-bridge";
 import { type ContributionPrepOptions, type ContributionPrepResult } from "./contribution-prep";
+import { type FoldAdapter, FoldCoordinator } from "./fold-coordinator";
 import type { MemoryGuardRestoreResult } from "./memory-guard-checkpoint-participant";
 import { type CustomMessage } from "./messages";
 import type { BranchSummaryEntry, CompactionEntry, NewSessionOptions, PreparedNewSession, RecoveryHydrationContext, RecoveryHydrationPromotionFence, SessionContext, SessionManagerCloseOutcome, SessionMemoryStats } from "./session-manager";
@@ -426,8 +427,8 @@ export interface PromptOptions {
     }) => void;
     /** Optional invocation-scoped cancellation fence used before an accepted skill starts execution. */
     preflightSignal?: AbortSignal;
-    /** Internal SDK lifecycle owner token. */
-    sdkRunToken?: string;
+    /** Internal host capability; ordinary package callers cannot construct the branded value. */
+    sdkRunCapability?: unknown;
 }
 /** Result from a handoff operation. */
 export interface HandoffResult {
@@ -553,6 +554,14 @@ export type BeforeAgentStartContributor = (event: {
     images?: ImageContent[];
     sessionId: string | undefined;
 }) => Promise<BeforeAgentStartInternalMessage | undefined>;
+export type WorkerIntegrationOutcome = {
+    status: "completed";
+} | {
+    status: "failed";
+    error: string;
+} | {
+    status: "timed_out";
+};
 export declare class WorkerIntegrationRequestScheduler {
     #private;
     readonly request: (signal: AbortSignal) => Promise<void>;
@@ -560,6 +569,7 @@ export declare class WorkerIntegrationRequestScheduler {
     constructor(request: (signal: AbortSignal) => Promise<void>, timeoutMs?: number);
     enqueue(): void;
     flush(): Promise<void>;
+    flushWithOutcome(): Promise<WorkerIntegrationOutcome>;
 }
 export type StreamingEditParsedToolCall = {
     toolCall: ToolCall;
@@ -837,7 +847,9 @@ export declare class AgentSession {
      * handler, so Ctrl+B-style folding fails closed instead of aborting or
      * shell-suspending arbitrary work.
      */
-    registerForegroundBashBackgroundRequestHandler(handler: () => void): () => void;
+    registerForegroundFoldParticipant(adapter: FoldAdapter): () => void;
+    /** The session-owned fold coordinator, for delivery-side receipt lookup. */
+    get foldCoordinator(): FoldCoordinator;
     /**
      * Returns whether a managed foreground bash call is currently backgroundable.
      * UI key handlers use this to avoid consuming normal editor shortcuts when
@@ -854,7 +866,7 @@ export declare class AgentSession {
      * Ask the active managed foreground bash call to return as a background job.
      * Returns false when no supported foreground tool is currently backgroundable.
      */
-    requestForegroundBashBackground(): boolean;
+    requestForegroundBashBackground(): Promise<boolean>;
     /**
      * Get all configured tool names (built-in via --tools or default, plus custom tools).
      */
@@ -947,7 +959,7 @@ export declare class AgentSession {
     /** Live SDK configuration values exposed through the session query surface. */
     getSdkConfigItems(): Record<string, string>;
     setPlanModeState(state: PlanModeState | undefined): void;
-    invokeSkill(name: string, args?: string, options?: Pick<PromptOptions, "onPreflightAccepted" | "onPreflightAcceptCommit" | "onSkillPrepared" | "preflightSignal" | "sdkRunToken">): Promise<{
+    invokeSkill(name: string, args?: string, options?: Pick<PromptOptions, "onPreflightAccepted" | "onPreflightAcceptCommit" | "onSkillPrepared" | "preflightSignal" | "sdkRunCapability">): Promise<{
         name: string;
         path: string;
         args?: string;
@@ -1002,7 +1014,7 @@ export declare class AgentSession {
      * @throws Error if no model selected or no API key available (when not streaming)
      */
     prompt(text: string, options?: PromptOptions): Promise<void>;
-    promptCustomMessage<T = unknown>(message: Pick<CustomMessage<T>, "customType" | "content" | "display" | "details" | "attribution">, options?: Pick<PromptOptions, "streamingBehavior" | "toolChoice" | "followUpQueuePolicy" | "onPreflightAccepted" | "onPreflightAcceptCommit" | "preflightSignal" | "sdkRunToken">): Promise<void>;
+    promptCustomMessage<T = unknown>(message: Pick<CustomMessage<T>, "customType" | "content" | "display" | "details" | "attribution">, options?: Pick<PromptOptions, "streamingBehavior" | "toolChoice" | "followUpQueuePolicy" | "onPreflightAccepted" | "onPreflightAcceptCommit" | "preflightSignal" | "sdkRunCapability">): Promise<void>;
     /**
      * Queue a steering message to interrupt the agent mid-run.
      */
@@ -1062,7 +1074,7 @@ export declare class AgentSession {
             startsOwnRun: boolean;
         }) => void;
         preflightSignal?: AbortSignal;
-        sdkRunToken?: string;
+        sdkRunCapability?: unknown;
     }): Promise<void>;
     /**
      * Clear queued messages and return them.