@gajae-code/coding-agent 0.15.4 → 0.15.6

package/dist/types/extensibility/extensions/types.d.ts

@@ -344,6 +344,7 @@ export interface ExtensionContext {
             cleanedArgs?: string;
         }) => void;
         preflightSignal?: AbortSignal;
+        sdkRunCapability?: unknown;
     }): Promise<unknown>;
     setPlanMode?(on: boolean): unknown;
     operateGoal?(op: "create" | "get" | "resume" | "pause" | "complete" | "drop", objective?: string): Promise<unknown>;
@@ -492,6 +493,8 @@ export interface AgentStartEvent extends SharedAgentStartEvent {
 export interface AgentFailedEvent {
     type: "agent_failed";
     error: AgentFailureDiagnostic;
+    /** Internal SDK queue-owner binding for exact lifecycle attribution. */
+    sdkRunToken?: string;
     /** Attempt correlation for the failing run, when scoped (matches the
      * agent_start/agent_end scope contract). */
     scope?: AttemptScope;
@@ -841,8 +844,6 @@ export interface ExtensionAPI {
             startsOwnRun: boolean;
         }) => void;
         preflightSignal?: AbortSignal;
-        /** Internal SDK correlation owner for an exact queued follow-up. */
-        sdkRunToken?: string;
     }): Promise<void>;
     /** Append a custom entry to the session for state persistence (not sent to LLM). */
     appendEntry<T = unknown>(customType: string, data?: T): void;
@@ -1028,8 +1029,6 @@ export type SendUserMessageHandler = (content: string | (TextContent | ImageCont
         removed?: boolean;
     }) => void;
     preflightSignal?: AbortSignal;
-    /** Internal SDK correlation owner for an exact queued follow-up. */
-    sdkRunToken?: string;
 }) => void | Promise<void>;
 export type AppendEntryHandler = <T = unknown>(customType: string, data?: T) => void;
 export type GetActiveToolsHandler = () => string[];
@@ -1166,6 +1165,7 @@ export interface ExtensionContextActions {
             cleanedArgs?: string;
         }) => void;
         preflightSignal?: AbortSignal;
+        sdkRunCapability?: unknown;
     }) => Promise<unknown>;
     setPlanMode?: (on: boolean) => unknown;
     operateGoal?: (op: "create" | "get" | "resume" | "pause" | "complete" | "drop", objective?: string) => Promise<unknown>;

package/dist/types/extensibility/shared-events.d.ts

@@ -148,6 +148,8 @@ export interface AgentStartEvent {
 export interface AgentEndEvent {
     type: "agent_end";
     messages: AgentMessage[];
+    /** Internal SDK queue-owner binding for exact lifecycle attribution. */
+    sdkRunToken?: string;
     /** Indicates whether the loop ended normally, suspended, cancelled, or entered maintenance. */
     stopReason?: "completed" | "paused" | "cancelled" | "maintenance";
     /** Present for maintenance checkpoints; non-aborted checkpoints are not terminal. */

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/bus/telegram-daemon-contract.d.ts

@@ -278,8 +278,15 @@ export declare const SDK_LIFECYCLE_ROUTER_PROTOCOL_VERSION = 1;
  * Generation 177 consumes an exact same-window lean settlement receipt only
  * after its autonomous ask lead-in publishes successfully, preventing idle
  * replay without changing the serving protocol.
+ * Generation 178: idle publication waits for positioned identity delivery to
+ * cross the native writer barrier before the independent broadcast lane.
+ * Generation 179 tolerates a bounded consecutive run of refused notification
+ * publications in the router instead of cancelling the subscription on the
+ * first refusal, so an owner still running the generation-178 router keeps
+ * killing a session's mirroring after one transient rejection and must be
+ * replaced across this upgrade.
  */
-export declare const DAEMON_GENERATION = 178;
+export declare const DAEMON_GENERATION = 179;
 /**
  * Serving-compatibility boundary for daemon lifecycle requests. Epoch 7
  * requires durable publication receipts and acknowledged attachment dispatch,

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

@@ -1,5 +1,7 @@
 import { SessionRouter } from "../router";
-export type SdkSessionCliAction = "list" | "inspect" | "send" | "status" | "tail" | "retire" | "raw" | "control" | "query" | "global";
+import { type SdkSessionRowV1 } from "./rows";
+export type SdkSessionCliAction = "list" | "inspect" | "send" | "status" | "tail" | "retire" | "global" | "raw" | "control" | "query" | "global";
+export type SdkSessionListScope = "repo" | "cwd" | "worktree" | "all";
 export type SdkSessionCliRawKind = "control" | "query" | "global";
 export interface SdkSessionCliArgs {
     action?: string;
@@ -13,6 +15,7 @@ export interface SdkSessionCliArgs {
     jsonInputFile?: string;
     jsonInputStdin?: boolean;
     idempotencyKey?: string;
+    scope?: string;
     confirm?: boolean;
     cursor?: string;
     wait?: boolean;
@@ -27,6 +30,43 @@ export interface RetainedTranscriptTailReader {
     readonly size: number;
     readRange(start: number, end: number): Promise<Uint8Array>;
 }
+interface WorkspaceIdentity {
+    /** Canonical workspace path (realpath when it exists, lexical resolve otherwise). */
+    canonicalPath: string;
+    /** Canonical containing worktree root; null outside a Git checkout. */
+    repoRoot: string | null;
+    /** Canonical Git common dir; shared by the main checkout and linked worktrees. */
+    commonDir: string | null;
+}
+export interface SdkSessionListSelection {
+    scope: SdkSessionListScope;
+    selection: WorkspaceIdentity;
+    /** Bounded, credential-free descriptor included in list output. */
+    descriptor: {
+        scope: SdkSessionListScope;
+        path: string;
+        worktreeRoot?: string;
+        commonDir?: string;
+    };
+}
+/** Parses `--scope`; missing means `repo`, anything else invalid is a usage error. */
+export declare function parseSessionListScope(value: string | undefined): SdkSessionListScope;
+/**
+ * Resolves the list selection from `--repo` (default: process cwd) under the
+ * effective scope. Outside Git, `repo`/`worktree` fail typed and actionable —
+ * they never broaden to `all`; `cwd` remains an exact canonical match.
+ */
+export declare function resolveSessionListSelection(scope: SdkSessionListScope, repoArg: string | undefined): Promise<SdkSessionListSelection>;
+/**
+ * Filters fully traversed broker rows by the selection scope. Row workspaces
+ * are canonicalized and cached per distinct locator; `repo` matches the shared
+ * common dir across the main checkout and linked worktrees, `worktree` the
+ * containing worktree only, and `cwd` the exact canonical workspace.
+ */
+export declare function filterSessionRowsByScope(rows: readonly SdkSessionRowV1[], scope: SdkSessionListScope, selection: SdkSessionListSelection): Promise<{
+    sessions: SdkSessionRowV1[];
+    warnings: string[];
+}>;
 /** Creates a lowercase ULID operation reference for prompt reconciliation. */
 export declare function createOperationRef(now?: number): string;
 /** Exported for tests: each status poll must stay inside the caller's wait window. */
@@ -39,3 +79,4 @@ export declare function scanRetainedTranscriptTail(reader: RetainedTranscriptTai
 export declare function runTail(repo: string, agentDir: string, sessionId: string, args: SdkSessionCliArgs): Promise<unknown>;
 /** Runs the broker-bound `gjc sdk session` command family without exposing endpoint credentials. */
 export declare function runSdkSessionCli(args: SdkSessionCliArgs, writeOutput?: (value: unknown) => void, setExitCode?: (exitCode: 1 | 2) => void): Promise<void>;
+export {};

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/host.d.ts

@@ -36,6 +36,8 @@ export interface SessionSdkHostOptions extends HostEndpointAdapters {
     query?: (connectionId: string, frame: SdkFrame) => unknown | Promise<unknown>;
     /** Test/lifecycle seam invoked synchronously before fire-and-forget dispatch. */
     onFrameAdmitted?: (connectionId: string, frame: SdkFrame) => void;
+    /** Synchronously rejects external input while a runtime is being replaced. */
+    onFrameAdmission?: (connectionId: string, frame: SdkFrame) => SdkFrame | undefined;
     /** Best-effort diagnostic observation of accepted control/query frames. */
     onRequest?: SdkRequestObserver;
     /** Runs before a control response is sent; identity transitions use sendTerminal. */

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";
@@ -175,6 +176,10 @@ export interface CreateSdkSessionRuntimeOptions {
     terminalAbortSeams?: SdkOnlyTerminalAbortSeams;
     /** Callback when a frame is admitted to the runtime (test harness). */
     onFrameAdmitted?: () => void;
+    /** Test-only observation of a genuinely timed-out lifecycle drain. */
+    onLifecycleDrainTimeoutForTests?: () => void;
+    /** Test-only observation of bounded failure-diagnostic deduplication state. */
+    onFailureDiagnosticKeyCountForTests?: (count: number) => void;
 }
 export interface InvocationCorrelation {
     commandId: string;
@@ -190,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;
@@ -224,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;