@gajae-code/coding-agent 0.13.3 → 0.14.0

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

@@ -9,7 +9,7 @@ export interface SessionSdkTransport {
     readonly sessionId: string;
     readonly stateRoot: string;
     readonly token: string;
-    sendFrame(connectionId: string, frame: SdkFrame): void | Promise<void>;
+    sendFrame(connectionId: string, frame: SdkFrame): void | "written" | "dropped" | Promise<void> | Promise<"written" | "dropped">;
     onFrame(handler: (connectionId: string, frame: SdkFrame) => void): undefined | (() => void);
     onMalformedFrame?(handler: (connectionId: string, message: string) => void): undefined | (() => void);
     start(): Promise<{
@@ -27,6 +27,105 @@ export interface SessionSdkRuntimeOptions extends Omit<SessionSdkHostOptions, "s
     /** Mutable shadow of patched config values merged into query readback. */
     configOverrides?: Map<string, unknown>;
 }
+export interface SdkOnlyInvocationRecord extends InvocationCorrelation {
+    kind: InvocationKind | "terminal" | "steer";
+    clientRef?: string;
+    status: InvocationStatus | "dispatching" | "rejected";
+    acceptedAt: number;
+    startedAt?: number;
+    terminalAt?: number;
+    error?: {
+        code: string;
+        message: string;
+    };
+    outcome?: unknown;
+    pendingOutcome?: unknown;
+    skillName?: string;
+    /** Steer records (origin/dev) carry their own dispatching lifecycle. */
+    textDigest?: string;
+    createdAt?: number;
+    settledAt?: number;
+}
+export interface SdkOnlyTerminalScopeRecord {
+    selection: "turn" | "owned";
+    idempotencyKeyHash?: string;
+    idempotencyInputHash?: string;
+    turnDisposition: "pending" | "stopped" | "uncertain" | "no_effect" | "no_effect_reserved" | "no_effect_marker_failure";
+    terminalPublished?: boolean;
+    ownedWorkDisposition: "not_requested" | "left_running" | "stopped" | "uncertain";
+    automaticDeliveryDisposition: "enabled" | "none";
+    resumeOnOwnedCompletion: boolean;
+    turnContinuationFence: {
+        state: "retained" | "released";
+        abortedAttemptEpoch: number;
+        blockedContinuationIds: string[];
+        predecessorTombstones: string[];
+        ownedCompletionPolicy: "enabled" | "disabled";
+    };
+    responseState: "pending" | "sent" | "delivered" | "failed";
+    responsePayloadHash: string;
+    replayPayloadHash?: string;
+    acceptedAt: number;
+    terminalAt?: number;
+}
+export interface SdkOnlyEvictedTerminalKeyEntry {
+    keyHash: string;
+    inputHash: string;
+    turnDisposition?: "stopped" | "uncertain" | "no_effect" | "no_effect_reserved" | "no_effect_marker_failure";
+    ownedWorkDisposition?: "not_requested" | "left_running" | "stopped" | "uncertain";
+    responseState?: "pending" | "sent" | "delivered" | "failed";
+    responsePayloadHash?: string;
+    replayPayloadHash?: string;
+    terminalPublished?: boolean;
+}
+export interface SdkOnlyReconciliationStore {
+    readonly path: string | null;
+    load(): Promise<unknown[]>;
+    transact(mutator: (records: SdkOnlyInvocationRecord[]) => SdkOnlyInvocationRecord[]): Promise<void>;
+    snapshotTerminalScopes(): SdkOnlyTerminalScopeRecord[];
+    snapshotTerminalKeys(): SdkOnlyEvictedTerminalKeyEntry[];
+    transactTerminalScopes(mutator: (scopes: SdkOnlyTerminalScopeRecord[]) => SdkOnlyTerminalScopeRecord[]): Promise<void>;
+    transactTerminalState(mutator: (state: {
+        scopes: SdkOnlyTerminalScopeRecord[];
+        keys: SdkOnlyEvictedTerminalKeyEntry[];
+    }) => {
+        scopes: SdkOnlyTerminalScopeRecord[];
+        keys: SdkOnlyEvictedTerminalKeyEntry[];
+    }): Promise<void>;
+}
+export interface SdkOnlyTerminalAbortSeams {
+    getReconciliationStore?: () => SdkOnlyReconciliationStore | undefined;
+    getTerminalTurnEpoch: () => number | undefined;
+    getActivePromptHandle: () => string | undefined;
+    /** Re-read the active prompt's owning SDK connection for the owner-mismatch
+     *  recheck; falls back to the runtime-tracked owner when absent (review
+     *  thread P1). */
+    getActivePromptOwnerConnectionId?: () => string | undefined;
+    cancelPendingPreflightForTerminalAbort: () => void;
+    /** Capture the steering admission snapshot at abort ADMISSION (before any
+     *  durable transaction), so steers admitted while the abort is in flight
+     *  classify as post-snapshot (review thread P1). */
+    captureTerminalAbortSteeringSnapshot?: () => number | undefined;
+    /** Discard the steering snapshot when a replay-only abort never settles
+     *  (review thread P1). */
+    discardTerminalAbortSteeringSnapshot?: (token: number) => void;
+    /** Rebind the snapshot to the current turn when the requester's turn
+     *  wins the race (review thread P1). */
+    rebindTerminalAbortSteeringSnapshot?: (token: number) => void;
+    abortPromptAndWaitWithTerminal: (handle: string, options: {
+        graceMs: number;
+        terminal?: {
+            scope: "turn" | "owned";
+            expectedEpoch?: number;
+            steeringSnapshotToken?: number;
+        };
+    }) => Promise<{
+        status: string;
+        terminalScope?: unknown;
+    }>;
+    /** Test override for the maximum durable terminal reservation rows. */
+    maxDurableTerminalReservationsForTests?: number;
+}
 /**
  * The transport-neutral SDK session runtime.
  *
@@ -71,13 +170,20 @@ export interface CreateSdkSessionRuntimeOptions {
     settings?: Settings;
     /** Mutable shadow of patched config values merged into query readback. */
     configOverrides?: Map<string, unknown>;
+    /** Private session-owned terminal-abort capabilities; never exposed on ExtensionContext. */
+    terminalAbortSeams?: SdkOnlyTerminalAbortSeams;
+    /** Callback when a frame is admitted to the runtime (test harness). */
+    onFrameAdmitted?: () => void;
 }
 export interface InvocationCorrelation {
     commandId: string;
     turnId: string;
 }
-export type InvocationKind = "prompt" | "skill";
+export type InvocationKind = "prompt" | "skill" | "steer";
+type InvocationStatus = "accepted" | "in_flight" | "terminal_ok" | "failed" | "uncertain";
 export interface InvocationReconciliation {
+    /** Shared v2 reconciliation owner; present for durable terminal admission. */
+    readonly store?: SdkOnlyReconciliationStore;
     admit(kind: InvocationKind, clientRef?: string): void;
     release(kind: InvocationKind, clientRef?: string): void;
     noteAccepted(kind: InvocationKind, correlation: InvocationCorrelation, clientRef?: string): Promise<void>;
@@ -98,10 +204,23 @@ export interface InvocationReconciliation {
         clientRef?: string;
     }): unknown;
     hydrate(): Promise<void>;
+    claimPendingOutcome(kind: InvocationKind, correlation: InvocationCorrelation, outcome: {
+        kind: string;
+        code: string;
+        message: string;
+        provenance?: string;
+    }): Promise<unknown>;
+    finalizeOutcome(kind: InvocationKind, correlation: InvocationCorrelation, outcome?: {
+        kind: string;
+        code: string;
+        message: string;
+        provenance?: string;
+    }): Promise<void>;
 }
 export declare function createInvocationReconciliation(options?: {
     stateRoot?: string;
     sessionId?: string;
+    store?: SdkOnlyReconciliationStore;
 }): InvocationReconciliation;
 export interface SdkSurfaceFactoryOptions {
     ctx: ExtensionContext;
@@ -123,12 +242,12 @@ export interface SdkSurfaceFactoryOptions {
         turnId?: string;
         clientRef?: string;
     }) => unknown;
+    steerStatusLookup?: (selector: {
+        commandId?: string;
+        turnId?: string;
+        clientRef?: string;
+    }) => unknown;
     hostTools?: boolean | (() => boolean);
-    /** Q30 event-ring watermark source (the live session event stream); synchronous. */
-    getEventWatermark?: () => {
-        generation: number;
-        seq: number;
-    };
 }
 /** Shared policy, capability, and query-surface factory for every SDK transport. */
 export interface SdkSurfaceFactory {
@@ -148,3 +267,4 @@ export declare function createSdkSurfaceFactory(options: SdkSurfaceFactoryOption
 export declare function registerSdkOnlyNotificationCommand(api: ExtensionAPI): void;
 /** Install a complete SDK host for a session when notifications are inactive. */
 export declare function createSdkSessionRuntimeExtension(api: ExtensionAPI, options: CreateSdkSessionRuntimeOptions): void;
+export {};

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

@@ -15,7 +15,7 @@ export interface HostEndpointAdapters {
     sessionId: string;
     stateRoot: string;
     token: string;
-    sendFrame: (connectionId: string, frame: SdkFrame) => void | Promise<void>;
+    sendFrame: (connectionId: string, frame: SdkFrame) => "written" | "dropped" | Promise<"written" | "dropped">;
     onFrame: (handler: (connectionId: string, frame: SdkFrame) => void) => undefined | (() => void);
 }
 export interface BrokerIndexWriter {

package/dist/types/sdk/host/websocket-transport.d.ts

@@ -1,7 +1,7 @@
 import * as fs from "node:fs/promises";
 import type { SessionSdkTransport } from "./session-runtime";
 export interface SdkWebSocketTransportDependencies {
-    readonly filesystem?: Pick<typeof fs, "mkdir" | "writeFile" | "chmod" | "rename" | "readFile" | "rm">;
+    readonly filesystem?: Pick<typeof fs, "mkdir" | "writeFile" | "chmod" | "rename" | "rm" | "stat">;
     readonly serve?: typeof Bun.serve;
 }
 export type SdkTransportLifecycleErrorCode = "endpoint_write_failed" | "endpoint_chmod_failed" | "endpoint_remove_failed" | "server_stop_failed";

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

@@ -1,11 +1,12 @@
 export { MODEL_PROFILE_DISCOVERY_QUERY, MODEL_PROFILE_ERROR_DETAIL_MAX_BYTES, type ModelProfileCatalogItem, type ModelProfileErrorCode, type ModelProfileErrorDetails, ModelProfileRegistryError, type ModelProfileRegistryErrorDetails, type UnknownModelProfileDetails, UnknownModelProfileError, } from "../config/model-profile-contract";
 export * as bus from "./bus";
-export * from "./client";
 export * as host from "./host";
+export * as lifecycle from "./lifecycle";
 export * as mcp from "./mcp";
 export type { Q10CurrentThinkingLevel, Q10Model, Q10SettableThinkingLevel, Q10ThinkingCapabilities, Q10ThinkingEffort, Q10ThinkingMode, } from "./models";
 export * from "./prompt-status";
 export type { ActiveProviderConnectionKind, ActiveProviderDescriptor } from "./providers";
+export * as router from "./router";
 export * from "./session";
 export * from "./session-directory";
 export * from "./turn-result";

package/dist/types/sdk/lifecycle/broker-client.d.ts

@@ -0,0 +1,8 @@
+import { type SessionLifecycleClient, type SessionLifecycleClientRequestOptions, type SessionLifecycleOperation, SessionLifecycleService } from "./service";
+/** SDK-core Broker client that keeps Broker credentials inside the lifecycle boundary. */
+export declare class AgentDirSessionLifecycleClient implements SessionLifecycleClient {
+    #private;
+    constructor(agentDir: string);
+    global(operation: SessionLifecycleOperation, input: Record<string, unknown>, options: SessionLifecycleClientRequestOptions): Promise<unknown>;
+}
+export declare function createBrokerSessionLifecycleService(agentDir: string): SessionLifecycleService;

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

@@ -0,0 +1,59 @@
+import { type ListRecentSessionsResult } from "./recent-sessions";
+import { type SessionCreateOutcome, type SessionLifecycleActor, SessionLifecycleService, type SessionResumeOutcome } from "./service";
+export type ExternalSessionCreateTarget = {
+    readonly kind: "existing_path";
+    readonly path: string;
+} | {
+    readonly kind: "worktree";
+    readonly repo: string;
+    readonly branch: string;
+} | {
+    readonly kind: "plain_dir";
+    readonly path: string;
+};
+export interface ExternalSessionResumeTarget {
+    readonly sessionIdOrPrefix: string;
+    readonly path?: string;
+}
+export type ExternalSessionResumeResult = {
+    readonly kind: "result";
+    readonly outcome: SessionResumeOutcome;
+} | {
+    readonly kind: "not_found";
+} | {
+    readonly kind: "ambiguous";
+    readonly candidates: readonly {
+        readonly sessionId: string;
+        readonly path?: string;
+    }[];
+} | {
+    readonly kind: "unavailable";
+    readonly message: string;
+};
+export declare class AgentDirSessionLifecycleService extends SessionLifecycleService {
+    #private;
+    constructor(agentDir: string);
+    createExternal(request: {
+        readonly actor: SessionLifecycleActor;
+        readonly capability: "session.create";
+        readonly requestKey: string;
+        readonly target: ExternalSessionCreateTarget;
+        readonly modelPreset?: string;
+        readonly readinessTimeoutMs?: number;
+    }): Promise<SessionCreateOutcome>;
+    listRecent(input: {
+        readonly cwd: string;
+        readonly limit?: number;
+        readonly includeInternal?: boolean;
+        readonly allWorkspaces?: boolean;
+    }): Promise<ListRecentSessionsResult>;
+    resumeExternal(request: {
+        readonly actor: SessionLifecycleActor;
+        readonly capability: "session.resume";
+        readonly requestKey: string;
+        readonly target: ExternalSessionResumeTarget;
+        readonly modelPreset?: string;
+        readonly readinessTimeoutMs?: number;
+    }): Promise<ExternalSessionResumeResult>;
+}
+export declare function createSessionLifecycleService(agentDir: string): AgentDirSessionLifecycleService;

package/dist/types/sdk/lifecycle/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./client";
+export * from "./recent-sessions";
+export * from "./service";

package/dist/types/sdk/lifecycle/service.d.ts

@@ -0,0 +1,232 @@
+export type SessionLifecycleOperation = "session.create" | "session.fork" | "session.resume" | "session.close" | "session.delete" | "session.list";
+export interface SessionLifecycleActor {
+    readonly id: string;
+    readonly namespace: string;
+}
+export interface SessionLifecycleClientRequestOptions {
+    readonly idempotencyKey?: string;
+    readonly timeoutMs?: number;
+}
+/** The deliberately small client surface needed by the lifecycle facade. */
+export interface SessionLifecycleClient {
+    global(operation: SessionLifecycleOperation, input: Record<string, unknown>, options: SessionLifecycleClientRequestOptions): Promise<unknown>;
+}
+export interface SessionLifecycleWorktreeTarget {
+    readonly enabled: true;
+    readonly name?: string;
+}
+export interface SessionLifecycleTranscriptIdentity {
+    readonly dev: string;
+    readonly ino: string;
+    readonly size: number;
+    readonly mtimeMs: number;
+    readonly mtimeNs: string;
+    readonly sha256: string;
+}
+export interface SessionLifecycleSavedSessionIdentity extends SessionLifecycleTranscriptIdentity {
+    readonly nlink: string;
+    readonly ctimeNs: string;
+}
+export interface SessionLifecycleSavedSession {
+    readonly id: string;
+    readonly path: string;
+    readonly identity: SessionLifecycleSavedSessionIdentity;
+}
+export interface SessionLifecycleCoordinatorTarget {
+    readonly coordinatorStateDir?: string;
+    readonly coordinatorSessionId?: string;
+    readonly coordinatorSessionBranch?: string;
+}
+export interface SessionCreateTarget extends SessionLifecycleCoordinatorTarget {
+    readonly cwd: string;
+    readonly stateRoot?: string;
+    readonly body?: string;
+    readonly modelPreset?: string;
+    readonly mcpServers?: readonly Record<string, unknown>[];
+    readonly worktree?: SessionLifecycleWorktreeTarget;
+    readonly readiness?: "immediate" | "deferred";
+    readonly readinessTimeoutMs?: number;
+}
+export interface SessionForkTarget extends SessionLifecycleCoordinatorTarget {
+    readonly cwd: string;
+    readonly stateRoot?: string;
+    readonly sourceSessionId?: string;
+    readonly sourceSessionPath?: string;
+    readonly sourceSessionIdentity?: SessionLifecycleTranscriptIdentity;
+    readonly body?: string;
+    readonly modelPreset?: string;
+    readonly mcpServers?: readonly Record<string, unknown>[];
+    readonly worktree?: SessionLifecycleWorktreeTarget;
+    readonly readinessTimeoutMs?: number;
+}
+export interface SessionResumeTarget extends SessionLifecycleCoordinatorTarget {
+    readonly sessionId: string;
+    readonly cwd?: string;
+    readonly stateRoot?: string;
+    readonly sessionPath?: string;
+    readonly sessionIdentity?: SessionLifecycleTranscriptIdentity;
+    readonly body?: string;
+    readonly modelPreset?: string;
+    readonly mcpServers?: readonly Record<string, unknown>[];
+    readonly worktree?: SessionLifecycleWorktreeTarget;
+    readonly readinessTimeoutMs?: number;
+}
+export interface SessionCloseTarget {
+    readonly sessionId: string;
+    readonly endpointGeneration?: number;
+    readonly endpointIncarnation?: string;
+}
+export interface SessionDeleteTarget {
+    readonly sessionId: string;
+    readonly cwd?: string;
+    readonly stateRoot?: string;
+    readonly sessionPath?: string;
+}
+export interface SessionListTarget {
+    readonly cwd?: string;
+    readonly resolveSessionId?: string;
+}
+interface SessionLifecycleMutationRequestBase<TOperation extends Exclude<SessionLifecycleOperation, "session.list">, TTarget> {
+    readonly operation: TOperation;
+    readonly actor: SessionLifecycleActor;
+    readonly capability: TOperation;
+    readonly requestKey: string;
+    readonly target: TTarget;
+    readonly timeoutMs?: number;
+}
+export type SessionCreateRequest = SessionLifecycleMutationRequestBase<"session.create", SessionCreateTarget>;
+export type SessionForkRequest = SessionLifecycleMutationRequestBase<"session.fork", SessionForkTarget>;
+export type SessionResumeRequest = SessionLifecycleMutationRequestBase<"session.resume", SessionResumeTarget>;
+export type SessionCloseRequest = SessionLifecycleMutationRequestBase<"session.close", SessionCloseTarget>;
+export type SessionDeleteRequest = SessionLifecycleMutationRequestBase<"session.delete", SessionDeleteTarget>;
+export interface SessionListRequest {
+    readonly operation: "session.list";
+    readonly actor: SessionLifecycleActor;
+    readonly capability: "session.list";
+    readonly target?: SessionListTarget;
+    readonly timeoutMs?: number;
+}
+export type SessionLifecycleRequest = SessionLifecycleMutationRequest | SessionListRequest;
+export type SessionLifecycleMutationRequest = SessionCreateRequest | SessionForkRequest | SessionResumeRequest | SessionCloseRequest | SessionDeleteRequest;
+export type SessionLifecycleCertainty = "terminal" | "retryable" | "cleanup_pending" | "uncertain";
+export interface SessionLifecycleSessionResult {
+    readonly sessionId: string;
+    readonly cwd?: string;
+    readonly endpointGeneration?: number;
+    readonly reused?: boolean;
+    readonly note?: string;
+}
+export interface SessionLifecycleListEntry {
+    readonly sessionId: string;
+    readonly live?: boolean;
+    readonly endpointGeneration?: number;
+    readonly terminalUncertain?: boolean;
+    readonly repo?: string;
+}
+export interface SessionLifecycleListResult {
+    readonly indexSeq: number;
+    readonly sessions: readonly SessionLifecycleListEntry[];
+    readonly warnings: readonly string[];
+    readonly savedSession?: SessionLifecycleSavedSession;
+}
+export interface SessionCreateResult {
+    readonly ok: true;
+    readonly operation: "session.create";
+    readonly result: SessionLifecycleSessionResult;
+}
+export interface SessionForkResult {
+    readonly ok: true;
+    readonly operation: "session.fork";
+    readonly result: SessionLifecycleSessionResult;
+}
+export interface SessionResumeResult {
+    readonly ok: true;
+    readonly operation: "session.resume";
+    readonly result: SessionLifecycleSessionResult;
+}
+export interface SessionCloseResult {
+    readonly ok: true;
+    readonly operation: "session.close";
+    readonly result: SessionLifecycleSessionResult;
+}
+export interface SessionDeleteResult {
+    readonly ok: true;
+    readonly operation: "session.delete";
+    readonly result: SessionLifecycleSessionResult;
+}
+export interface SessionListSuccessResult {
+    readonly ok: true;
+    readonly operation: "session.list";
+    readonly result: SessionLifecycleListResult;
+}
+export interface SessionLifecycleError {
+    readonly code: string;
+    readonly message: string;
+}
+export type SessionCreateFailure = {
+    readonly ok: false;
+    readonly operation: "session.create";
+    readonly certainty: SessionLifecycleCertainty;
+    readonly error: SessionLifecycleError;
+};
+export type SessionForkFailure = {
+    readonly ok: false;
+    readonly operation: "session.fork";
+    readonly certainty: SessionLifecycleCertainty;
+    readonly error: SessionLifecycleError;
+};
+export type SessionResumeFailure = {
+    readonly ok: false;
+    readonly operation: "session.resume";
+    readonly certainty: SessionLifecycleCertainty;
+    readonly error: SessionLifecycleError;
+};
+export type SessionCloseFailure = {
+    readonly ok: false;
+    readonly operation: "session.close";
+    readonly certainty: SessionLifecycleCertainty;
+    readonly error: SessionLifecycleError;
+};
+export type SessionDeleteFailure = {
+    readonly ok: false;
+    readonly operation: "session.delete";
+    readonly certainty: SessionLifecycleCertainty;
+    readonly error: SessionLifecycleError;
+};
+export type SessionListFailure = {
+    readonly ok: false;
+    readonly operation: "session.list";
+    readonly certainty: SessionLifecycleCertainty;
+    readonly error: SessionLifecycleError;
+};
+export type SessionCreateOutcome = SessionCreateResult | SessionCreateFailure;
+export type SessionForkOutcome = SessionForkResult | SessionForkFailure;
+export type SessionResumeOutcome = SessionResumeResult | SessionResumeFailure;
+export type SessionCloseOutcome = SessionCloseResult | SessionCloseFailure;
+export type SessionDeleteOutcome = SessionDeleteResult | SessionDeleteFailure;
+export type SessionListOutcome = SessionListSuccessResult | SessionListFailure;
+export type SessionLifecycleResult = SessionCreateOutcome | SessionForkOutcome | SessionResumeOutcome | SessionCloseOutcome | SessionDeleteOutcome | SessionListOutcome;
+/** Shared, side-effect-free validation for lifecycle mutation requests. */
+export type SessionLifecycleMutationValidation = {
+    readonly ok: true;
+    readonly operation: Exclude<SessionLifecycleOperation, "session.list">;
+    readonly actor: SessionLifecycleActor;
+    readonly requestKey: string;
+    readonly target: Readonly<Record<string, unknown>>;
+} | SessionCreateFailure | SessionForkFailure | SessionResumeFailure | SessionCloseFailure | SessionDeleteFailure;
+/** Derives a stable Broker idempotency key without exposing caller identity to Broker inputs. */
+export declare function deriveSessionLifecycleIdempotencyKey(actor: SessionLifecycleActor, requestKey: string, operation: SessionLifecycleOperation): string;
+/** Validates lifecycle authority and shape without contacting the Broker. */
+export declare function validateSessionLifecycleMutationRequest(request: unknown): SessionLifecycleMutationValidation;
+export declare class SessionLifecycleService {
+    #private;
+    constructor(client: SessionLifecycleClient);
+    execute(request: SessionLifecycleMutationRequest): Promise<SessionCreateOutcome | SessionForkOutcome | SessionResumeOutcome | SessionCloseOutcome | SessionDeleteOutcome>;
+    create(request: Omit<SessionCreateRequest, "operation">): Promise<SessionCreateOutcome>;
+    fork(request: Omit<SessionForkRequest, "operation">): Promise<SessionForkOutcome>;
+    resume(request: Omit<SessionResumeRequest, "operation">): Promise<SessionResumeOutcome>;
+    close(request: Omit<SessionCloseRequest, "operation">): Promise<SessionCloseOutcome>;
+    delete(request: Omit<SessionDeleteRequest, "operation">): Promise<SessionDeleteOutcome>;
+    list(request: Omit<SessionListRequest, "operation">): Promise<SessionListOutcome>;
+}
+export {};

package/dist/types/sdk/mcp/server.d.ts

@@ -1,4 +1,5 @@
-import { SdkClient } from "../client/client";
+import type { SessionLifecycleService } from "../lifecycle/service";
+import { SessionRouter } from "../router";
 type Arguments = Record<string, unknown>;
 type JsonRpcRequest = {
     jsonrpc: "2.0";
@@ -16,22 +17,24 @@ type JsonRpcResponse = {
     };
 };
 export interface SdkMcpServerOptions {
-    repo?: string;
     agentDir?: string;
-    connect?: (url: string, token: string) => Promise<SdkClient>;
+    router?: SessionRouter;
+    lifecycleService?: SessionLifecycleService;
 }
 export declare const SDK_MCP_TOOL_NAMES: readonly ["gjc_session_control", "gjc_session_query", "gjc_session_global", "gjc_session_list"];
-/** Creates the model-facing MCP adapter; session targeting is broker-bound (C10). */
+/** Creates the model-facing MCP adapter with Router-owned live session authority. */
 export declare function createSdkMcpServer(options?: SdkMcpServerOptions): {
     callTool: (name: string, args?: Arguments) => Promise<unknown>;
     handleJsonRpc: (request: JsonRpcRequest) => Promise<JsonRpcResponse>;
     handle: (request: JsonRpcRequest) => Promise<JsonRpcResponse>;
+    start: () => Promise<void>;
+    close: () => Promise<void>;
     tools: Record<string, unknown>[];
 };
 /**
  * Runs the SDK MCP server over stdio (newline-delimited JSON-RPC), the shipped
- * `gjc mcp-serve sdk` entrypoint. Pure SDK client: session control/query flows
- * through the broker and v3 WebSockets only.
+ * `gjc mcp-serve sdk` entrypoint. SessionRouter owns live endpoint authority and starts lazily
+ * on the first live-session tool, then stops after stdin and in-flight requests drain.
  */
 export declare function runSdkMcpStdio(options?: SdkMcpServerOptions): Promise<void>;
 export {};

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

@@ -0,0 +1,43 @@
+/**
+ * Bounded progress-aware lease for the SDK prompt terminal deadline (#4334).
+ *
+ * The accepted prompt deadline is no longer a fixed wall-clock window from
+ * acceptance: fresh *attributable* progress — tool/skill execution events
+ * correlated to the exact accepted `commandId`/`turnId` at the prompt/agent
+ * runtime boundary — renews the terminal deadline up to a deterministic hard
+ * maximum runtime. Unrelated session noise, heartbeats, other turns, streaming
+ * chatter, and retry bookkeeping never renew the lease, and there is no
+ * unbounded disable value: `maxMs` is always a finite bound.
+ */
+export interface PromptDeadlineLease {
+    /** When the prompt was accepted; anchors the hard maximum runtime. */
+    readonly acceptedAt: number;
+    /** Last verified attributable progress (starts at acceptance). */
+    lastProgressAt: number;
+    /** Inactivity window: the deadline is this far past the last verified progress. */
+    readonly leaseMs: number;
+    /** Deterministic hard maximum runtime from acceptance; never unbounded. */
+    readonly maxMs: number;
+}
+export declare function createPromptDeadlineLease(input: {
+    now: number;
+    leaseMs: number;
+    maxMs: number;
+}): PromptDeadlineLease;
+/**
+ * Current terminal deadline: the inactivity lease from last verified progress,
+ * bounded by the hard maximum runtime from acceptance.
+ */
+export declare function promptDeadlineAt(lease: PromptDeadlineLease): number;
+/**
+ * Record fresh attributable progress. Monotonic: a stale or equal timestamp
+ * never moves the lease backwards, so out-of-order delivery cannot shorten it.
+ */
+export declare function recordAttributableProgress(lease: PromptDeadlineLease, now: number): void;
+/**
+ * Whether an agent session event at the prompt/agent runtime boundary is
+ * attributable progress for the accepted prompt. Only tool execution
+ * boundaries qualify: skills do their work through tools, so skill progress is
+ * covered; streaming text/thinking deltas, retries, and bookkeeping are not.
+ */
+export declare function isAttributableProgressEventType(type: string): boolean;

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

@@ -0,0 +1,28 @@
+import type { KindAwareReconciliation } from "./bus/kind-aware-reconciliation";
+import type { InvocationCorrelation, InvocationReconciliation } from "./host/session-runtime";
+type DeadlineReconciliation = InvocationReconciliation | KindAwareReconciliation;
+export type PromptDeadlineOutcome = {
+    kind: "failed";
+    code: "prompt_deadline_exceeded";
+    message: string;
+    provenance: "deadline";
+};
+export declare class PromptDeadlineManager {
+    #private;
+    constructor(options: {
+        reconciliation: DeadlineReconciliation;
+        getLeaseMs: () => number;
+        getMaxMs: () => number;
+        now?: () => number;
+    });
+    onAccepted(correlation: InvocationCorrelation): void;
+    onProgress(correlation: InvocationCorrelation, now?: number): void;
+    onAttributableEvent(correlation: InvocationCorrelation, eventType: string, now?: number): void;
+    clear(correlation: InvocationCorrelation): void;
+    clearAll(): void;
+    /** For tests: current deadline or undefined if no lease. */
+    deadlineAt(correlation: InvocationCorrelation): number | undefined;
+    /** For tests: whether a lease exists. */
+    has(correlation: InvocationCorrelation): boolean;
+}
+export {};