@gajae-code/coding-agent 0.16.7 → 0.17.1

package/dist/types/sdk/bus/doctor-daemon-restart-client.d.ts

@@ -0,0 +1,51 @@
+import type { Settings } from "../../config/settings";
+import type { DoctorDaemonIdentity, DoctorDaemonOwner } from "./doctor-daemon-restart";
+export interface DoctorDaemonRestartOptions {
+    readonly agentDir: string;
+    readonly owner: DoctorDaemonOwner;
+    readonly settings: Settings;
+    readonly requestId?: string;
+    readonly deadlineMs?: number;
+    /** Bounded natural-completion wait; idle attached sessions still count as workload. */
+    readonly drainSeconds?: number;
+}
+/**
+ * Typed before/after-effect outcome. Every refusal names the exact stage it
+ * stopped at, so a caller never has to infer whether an effect began.
+ */
+export type DoctorDaemonRestartOutcome = {
+    kind: "restarted";
+    requestId: string;
+    oldOwner: DoctorDaemonIdentity;
+    successor: DoctorDaemonIdentity;
+    adopted: boolean;
+} | {
+    kind: "owner_unavailable";
+    reason: "no_state" | "owner_not_confirmed_live" | "unsupported_incumbent_protocol";
+} | {
+    kind: "prepare_refused";
+    reason: "control_write_failed" | "not_acknowledged";
+} | {
+    kind: "commit_refused";
+    reason: "control_write_failed";
+} | {
+    kind: "old_owner_exit_timeout";
+    requestId: string;
+    oldOwner: DoctorDaemonIdentity;
+} | {
+    kind: "successor_refused";
+    requestId: string;
+    oldOwner: DoctorDaemonIdentity;
+    reason: "start_refused" | "publication_timeout";
+};
+/**
+ * Owner-side prepare/commit, positive-exit-confirmed cleanup, then exactly one
+ * successor started through the product's own ensure path.
+ *
+ * Ordering is fixed: prepare (owner closes admission) → occupancy settles →
+ * commit → owner exits under its own gate → positive absence proof → successor
+ * start or adoption. A commit is never issued before the owner acknowledged the
+ * prepare, and a successor is never started before the predecessor is proven
+ * gone.
+ */
+export declare function restartDaemonForDoctor(options: DoctorDaemonRestartOptions): Promise<DoctorDaemonRestartOutcome>;

package/dist/types/sdk/bus/doctor-daemon-restart.d.ts

@@ -0,0 +1,39 @@
+export type DoctorDaemonOwner = "telegram" | "discord" | "slack";
+export interface DoctorDaemonIdentity {
+    owner: DoctorDaemonOwner;
+    ownerId: string;
+    generation: number;
+    incarnation: string;
+}
+export interface DoctorDaemonOccupancy {
+    attached: number;
+    inflight: number;
+    inbound: number;
+    outbound: number;
+    cleanup: number;
+}
+export interface DoctorDaemonStatus extends DoctorDaemonIdentity {
+    requestId: string;
+    phase: "idle" | "prepared" | "committed" | "cancelled" | "expired";
+    admitting: boolean;
+    occupancy: DoctorDaemonOccupancy;
+    leaseExpiresAt: number;
+}
+export interface DoctorDaemonControlRequest extends DoctorDaemonIdentity {
+    version: 1;
+    requestId: string;
+    action: "prepare" | "commit" | "cancel" | "status";
+    createdAt: number;
+    leaseExpiresAt?: number;
+}
+export declare function doctorDaemonOccupancyEmpty(): DoctorDaemonOccupancy;
+/**
+ * True only when every named occupancy category is an explicit, valid,
+ * zero-valued integer. An empty object, a partial object, or an object with
+ * extra/malformed keys is never vacuously "settled" — `Object.values({}).
+ * every(...)` was previously `true` for `{}` because there is nothing to
+ * iterate; this checks the exact required key set instead.
+ */
+export declare function doctorDaemonOccupancySettled(occupancy: DoctorDaemonOccupancy | undefined): boolean;
+export declare function doctorDaemonIdentityMatches(left: DoctorDaemonIdentity | undefined, right: DoctorDaemonIdentity): boolean;
+export declare function isDoctorDaemonControlRequest(value: unknown): value is DoctorDaemonControlRequest;

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

@@ -601,6 +601,8 @@ export declare function createNotificationsExtension(api: ExtensionAPI, options?
     controller?: NotificationSessionController;
     /** Whether this host mode can own the root SDK endpoint. Default: true. */
     sdkHostModeSupported?: boolean;
+    /** Startup surface that owns host-level permission and lifecycle authority. */
+    primaryControlSurface?: "cli" | "sdk";
     /** In-memory master capability for private broker verification only. */
     masterCapability?: string;
     /** Opaque direct-role epoch this effective host may adopt. */

package/dist/types/sdk/bus/notification-service.d.ts

@@ -3,6 +3,7 @@ import type { Settings } from "../../config/settings";
 import { type NotificationProvider, type NotificationRuntime, type ProviderResolution } from "./config";
 import type { DiscordDiagnosticProvider } from "./discord-provider";
 import type { SlackDiagnosticProvider } from "./slack-provider";
+import { type TelegramDaemonStopCause } from "./telegram-daemon";
 /**
  * Strip secrets from a human-facing diagnostic string. Redacts the configured
  * bot token (exact match) and any token-shaped substring so health/test details
@@ -162,6 +163,8 @@ export interface DaemonHealth {
     stopped: boolean;
     heartbeatAt: number | undefined;
     heartbeatAgeMs: number | undefined;
+    /** Bounded persisted stop cause; absent means this record predates diagnostics or is unknown. */
+    stopCause?: TelegramDaemonStopCause;
     /**
      * Session endpoints the live owner reported an OPEN socket to in its latest
      * matching heartbeat sidecar. `undefined` means the owner never published the

package/dist/types/sdk/bus/telegram-daemon-cli.d.ts

@@ -5,6 +5,16 @@ import { type DaemonState, type TelegramDaemonOptions } from "./telegram-daemon"
 type TelegramDaemonRunner = {
     run(): Promise<void>;
     requestStop(reason?: "reload" | "signal" | "stop"): void;
+    prepareDoctorRestart?(): void;
+    cancelDoctorRestart?(): void;
+    doctorOccupancy?(): {
+        attached: number;
+        inflight: number;
+        inbound: number;
+        outbound: number;
+        cleanup: number;
+    };
+    doctorRestartReady?(): boolean;
 };
 type TelegramDaemonConstructor = new (opts: TelegramDaemonOptions) => TelegramDaemonRunner;
 export type LightweightDaemonSettings = Pick<Settings, "get" | "getAgentDir" | "set" | "flush"> & NotificationSettingsReader;
@@ -47,6 +57,7 @@ export declare function ownerPidFromOwnerId(ownerId: string): number | undefined
 /** Creates owner-fenced daemon control hooks for the CLI lifecycle boundary. */
 export declare function createDaemonControlHooks(settings: Settings): {
     shouldStop: (owner: string) => Promise<boolean>;
+    requestedAction: (owner: string) => Promise<"reload" | "stop" | undefined>;
     clear: (owner: string) => Promise<void>;
 };
 export declare function runDaemonSmoke(opts?: {

package/dist/types/sdk/bus/telegram-daemon-contract.d.ts

@@ -286,7 +286,7 @@ export declare const SDK_LIFECYCLE_ROUTER_PROTOCOL_VERSION = 1;
  * killing a session's mirroring after one transient rejection and must be
  * replaced across this upgrade.
  */
-export declare const DAEMON_GENERATION = 181;
+export declare const DAEMON_GENERATION = 187;
 /**
  * Serving-compatibility boundary for daemon lifecycle requests. Epoch 7
  * requires durable publication receipts and acknowledged attachment dispatch,

package/dist/types/sdk/bus/telegram-daemon-control.d.ts

@@ -9,6 +9,7 @@
  */
 import type { Settings } from "../../config/settings";
 import type { BuiltInDaemonController, DaemonOperationOptions, DaemonOperationResult, DaemonStatus } from "../../daemon/control-types";
+import { type DoctorDaemonControlRequest } from "./doctor-daemon-restart";
 import { type TelegramDaemonDeps, type TelegramDaemonFs } from "./telegram-daemon";
 export interface TelegramDaemonControlRequest {
     version: 1;
@@ -19,6 +20,10 @@ export interface TelegramDaemonControlRequest {
     createdAt: number;
 }
 export declare function telegramControlRequestPath(agentDir: string): string;
+export declare function telegramDoctorControlRequestPath(agentDir: string): string;
+export declare function readTelegramDoctorControlRequest(settings: Settings, fsImpl?: TelegramDaemonFs): Promise<DoctorDaemonControlRequest | undefined>;
+export declare function writeTelegramDoctorControlRequest(settings: Settings, request: DoctorDaemonControlRequest, fsImpl?: TelegramDaemonFs): Promise<void>;
+export declare function clearTelegramDoctorControlRequest(settings: Settings, requestId?: string, fsImpl?: TelegramDaemonFs): Promise<void>;
 export declare function readTelegramControlRequest(settings: Settings, fsImpl?: TelegramDaemonFs): Promise<TelegramDaemonControlRequest | undefined>;
 export declare function writeTelegramControlRequest(settings: Settings, request: TelegramDaemonControlRequest, fsImpl?: TelegramDaemonFs): Promise<void>;
 export declare function clearTelegramControlRequest(settings: Settings, requestId?: string, fsImpl?: TelegramDaemonFs): Promise<void>;

package/dist/types/sdk/bus/telegram-daemon-owner-registry.d.ts

@@ -10,6 +10,7 @@ export interface TelegramOwnerMarker {
     createdAt: number;
     startedAt: number;
 }
+export declare function validMarker(value: unknown): value is TelegramOwnerMarker;
 export declare function writeTelegramOwnerMarker(fsImpl: TelegramDaemonFs, agentDir: string, marker: TelegramOwnerMarker): Promise<void>;
 export declare function removeTelegramOwnerMarker(fsImpl: TelegramDaemonFs, agentDir: string, acquisitionId: string): Promise<void>;
 export declare function readTelegramOwnerMarker(fsImpl: TelegramDaemonFs, agentDir: string, acquisitionId: string): Promise<TelegramOwnerMarker | undefined>;

package/dist/types/sdk/bus/telegram-daemon.d.ts

@@ -3,6 +3,7 @@ import { type NativeExactFileIdentity, type NativeExactUnlinkResult } from "@gaj
 import type { Settings } from "../../config/settings";
 import type { DaemonRuntimeInfo } from "../../daemon/control-types";
 import { HEARTBEAT_TTL_MS } from "./daemon-paths";
+import { type DoctorDaemonOccupancy } from "./doctor-daemon-restart";
 import { type DaemonTransitionLock, type NotificationEndpointFile, type NotificationEndpointFileIdentity, type NotificationExactUnlinkResult } from "./notification-service";
 import { type DaemonProcessReference } from "./telegram-daemon-control";
 import { type TelegramSetupPreflight } from "./telegram-setup";
@@ -17,6 +18,9 @@ export type EnsureDaemonResult = "owner_spawned" | "attached" | "disabled" | "bl
 /** Detailed result for orchestration that must distinguish a #2028 handoff from a fresh spawn. */
 export type EnsureTelegramDaemonDetailedResult = "spawned" | "reloaded" | "attached" | "disabled" | "blocked_identity";
 export type TelegramDaemonOwnershipPhase = "provisional" | "ready" | "retired";
+/** Closed vocabulary for the durable reason an owner stopped serving. */
+export type TelegramDaemonStopCause = "stop" | "reload" | "signal" | "idle_timeout" | "ownership_loss" | "startup_failed" | "unexpected_exception" | "postmortem";
+export declare function isTelegramDaemonStopCause(value: unknown): value is TelegramDaemonStopCause;
 export interface DaemonState {
     pid: number;
     /** OS process-start provenance; mandatory for PID-authorized ownership actions. */
@@ -45,6 +49,8 @@ export interface DaemonState {
     /** Lifecycle-serving compatibility epoch; absent pre-epoch records are epoch 1. */
     servingEpoch?: number;
     stoppedAt?: number;
+    /** Bounded, secret-free explanation for a stopped owner; absent on legacy/unknown records. */
+    stopCause?: TelegramDaemonStopCause;
 }
 interface ExactFileStat {
     dev: bigint;
@@ -476,6 +482,7 @@ export declare function releaseDaemonOwnership(input: {
     pidIncarnation?: (pid: number) => string | undefined;
     fs?: TelegramDaemonFs;
     now?: () => number;
+    stopCause?: TelegramDaemonStopCause;
 }): Promise<void>;
 /**
  * Record that this owner's process is gone, without claiming a clean handoff.
@@ -487,9 +494,9 @@ export declare function releaseDaemonOwnership(input: {
  * `ownershipPhase: "ready"` and a fresh-looking lock behind forever, so later
  * readers attached to an owner that had not existed for hours.
  *
- * This writes `stoppedAt` and nothing else. The lock is left in place for the
- * existing reclaim path to adjudicate, because a process on its way out is the
- * least qualified party to decide who owns what next.
+ * This writes `stoppedAt` and a closed-vocabulary `stopCause`. The lock is left
+ * in place for the existing reclaim path to adjudicate, because a process on
+ * its way out is the least qualified party to decide who owns what next.
  *
  * Fenced on full owner identity: if the state no longer names this exact
  * owner, acquisition, pid and incarnation, a successor already took over and
@@ -686,6 +693,12 @@ export declare class TelegramEventDispatchState {
 export interface DaemonControlHooks {
     /** Returns true when a stop/reload has been requested for this owner. */
     shouldStop(ownerId: string): Promise<boolean>;
+    /**
+     * Returns the owner-fenced action behind `shouldStop`, when the control
+     * plane can provide one. This is a diagnostic projection, not an alternate
+     * stop authority: callers must still gate it behind `shouldStop`.
+     */
+    requestedAction?(ownerId: string): Promise<"reload" | "stop" | undefined>;
     /** Clear a consumed control request (best-effort). */
     clear?(ownerId: string): Promise<void>;
 }
@@ -900,9 +913,27 @@ export declare class TelegramNotificationDaemon {
     /**
      * Cooperatively stop the daemon: set the stop flag and abort the in-flight
      * long poll so the run loop wakes immediately instead of waiting out the
-     * ~25s getUpdates timeout. Safe to call from a signal handler.
+     * ~25s getUpdates timeout. Safe to call from a signal handler. The
+     * no-argument form is the generic finally fallback and never overwrites a
+     * previously observed specific cause.
+     */
+    requestStop(reason?: TelegramDaemonStopCause): void;
+    /** Doctor reservation hook: stop admitting new provider work without killing the owner. Synchronous fence; returns a real acknowledgement. */
+    prepareDoctorRestart(): boolean;
+    /**
+     * Real occupancy read from the live runtime structures the daemon actually
+     * uses, not synthetic zeros. `inflight` is turns currently executing;
+     * `inbound` is inbound work accepted but not yet resolved (pending /btw
+     * turns, topic-adoption session_create dispatches in flight, and inbound
+     * reaction acks not yet terminal); `outbound` is the real rate-limit pool
+     * backlog plus terminal /btw deliveries still in flight; `cleanup` counts
+     * only genuinely outstanding cleanup — non-completed cleanup receipts plus
+     * live archive/compensation fences — never a completed receipt or an
+     * unrelated rejected-topic notice timer.
      */
-    requestStop(_reason?: "reload" | "stop" | "signal"): void;
+    doctorOccupancy(): DoctorDaemonOccupancy;
+    doctorRestartReady(): boolean;
+    cancelDoctorRestart(): void;
     /** Handle a paired-chat /session_* command through the SDK lifecycle service. */
     private handleLifecycleCommand;
     private refreshBotIdentity;

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

@@ -24,6 +24,7 @@ export interface SdkSessionCliArgs {
     strict?: boolean;
     untilIdle?: boolean;
     allEvents?: boolean;
+    page?: boolean;
     repo?: string;
     scope?: string;
     limit?: number;

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

@@ -211,6 +211,8 @@ export interface CreateSdkSessionRuntimeOptions {
     brokerRegistrationRequired?: boolean;
     /** Trusted broker-issued lifecycle marker bound to lifecycle host index events. */
     lifecycleRequestId?: string;
+    /** Startup surface that owns host-level permission and lifecycle authority. */
+    primaryControlSurface?: "cli" | "sdk";
     createTransport(input: {
         sessionId: string;
         stateRoot: string;
@@ -306,6 +308,8 @@ export interface SdkSurfaceFactoryOptions {
     ctx: ExtensionContext;
     id: string;
     api: ExtensionAPI;
+    /** Startup surface that owns host-level permission and lifecycle authority. */
+    primaryControlSurface?: "cli" | "sdk";
     policy?: SdkSurfacePolicy;
     getInstalledDefinitions?: (capability: string) => unknown | undefined;
     getLiveState?: () => {

package/dist/types/sdk/host/surface-policy.d.ts

@@ -15,7 +15,9 @@ export interface SdkCapabilities {
     operations: string[];
     hostTools: boolean;
     promptTerminalOutcomeVersion: 1;
+    /** Startup surface that owns host-level permission and lifecycle authority. */
+    primaryControlSurface: "cli" | "sdk";
 }
-export declare function createSdkCapabilities(policy: SdkSurfacePolicy, hostTools?: boolean): SdkCapabilities;
+export declare function createSdkCapabilities(policy: SdkSurfacePolicy, hostTools?: boolean, primaryControlSurface?: SdkCapabilities["primaryControlSurface"]): SdkCapabilities;
 /** Derive the shared policy from an extension context without importing adapters. */
 export declare function createSdkSurfacePolicyForContext(ctx: ExtensionContext, workflowGateAvailable?: boolean): SdkSurfacePolicy;

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

@@ -1,5 +1,9 @@
 import { type ScopeRequestV1, type SdkSearchResultV1 } from "../broker/session-scope";
-export type SessionLifecycleOperation = "session.create" | "session.fork" | "session.resume" | "session.close" | "session.delete" | "session.reconcile_uncertain" | "session.list";
+import type { SessionBindingAuthority } from "../session-authority";
+export type { SessionBindingAuthority, SessionEndpointAuthority } from "../session-authority";
+export type SessionLifecycleOperation = "session.create" | "session.fork" | "session.resume" | "session.close" | "session.delete" | "session.reconcile_uncertain" | "session.lookup" | "session.list";
+export type SessionLifecycleMutationOperation = Exclude<SessionLifecycleOperation, "session.lookup" | "session.list">;
+export type SessionLifecycleLookupOperation = "session.create";
 export interface SessionLifecycleActor {
     readonly id: string;
     readonly namespace: string;
@@ -80,11 +84,11 @@ export type SessionResumeTarget = SessionLifecycleCoordinatorTarget & {
     readonly worktree?: SessionLifecycleWorktreeTarget;
     readonly readinessTimeoutMs?: number;
 };
-export interface SessionCloseTarget {
+export type SessionCloseTarget = {
     readonly sessionId: string;
-    readonly endpointGeneration?: number;
-    readonly endpointIncarnation?: string;
-}
+    readonly endpointGeneration?: never;
+    readonly endpointIncarnation?: never;
+} | SessionBindingAuthority;
 export interface SessionReconcileUncertainTarget {
     readonly sessionId: string;
     readonly cwd: string;
@@ -109,7 +113,7 @@ export interface SessionListTarget {
     readonly limit?: number;
     readonly cursor?: string;
 }
-interface SessionLifecycleMutationRequestBase<TOperation extends Exclude<SessionLifecycleOperation, "session.list">, TTarget> {
+interface SessionLifecycleMutationRequestBase<TOperation extends SessionLifecycleMutationOperation, TTarget> {
     readonly operation: TOperation;
     readonly actor: SessionLifecycleActor;
     readonly capability: TOperation;
@@ -130,7 +134,15 @@ export interface SessionListRequest {
     readonly target?: SessionListTarget;
     readonly timeoutMs?: number;
 }
-export type SessionLifecycleRequest = SessionLifecycleMutationRequest | SessionListRequest;
+export interface SessionLifecycleLookupRequest {
+    readonly operation: SessionLifecycleLookupOperation;
+    readonly actor: SessionLifecycleActor;
+    readonly capability: "session.lookup";
+    readonly requestKey: string;
+    readonly target: Readonly<Record<string, unknown>>;
+    readonly timeoutMs?: number;
+}
+export type SessionLifecycleRequest = SessionLifecycleMutationRequest | SessionListRequest | SessionLifecycleLookupRequest;
 export type SessionLifecycleMutationRequest = SessionCreateRequest | SessionForkRequest | SessionResumeRequest | SessionCloseRequest | SessionDeleteRequest | SessionReconcileUncertainRequest;
 export type SessionLifecycleCertainty = "terminal" | "retryable" | "cleanup_pending" | "uncertain";
 export interface SessionLifecycleSessionResult {
@@ -145,6 +157,7 @@ export interface SessionLifecycleListEntry {
     readonly sessionId: string;
     readonly live?: boolean;
     readonly endpointGeneration?: number;
+    readonly endpointIncarnation?: string;
     readonly terminalUncertain?: boolean;
     readonly cwd?: string;
     readonly locator?: {
@@ -195,6 +208,26 @@ export interface SessionListSuccessResult {
     readonly operation: "session.list";
     readonly result: SessionLifecycleListResult | SessionScopedListResult;
 }
+export interface SessionLifecycleLookupIdentity {
+    readonly operation: SessionLifecycleLookupOperation;
+    readonly requestKey: string;
+}
+export type SessionLifecycleLookupStatus = "found" | "pending" | "not_found" | "conflict" | "uncertain" | "terminal";
+export interface SessionLifecycleLookupSuccessResult {
+    readonly ok: true;
+    readonly operation: "session.lookup";
+    readonly status: "found";
+    readonly request: SessionLifecycleLookupIdentity;
+    readonly result: SessionLifecycleSessionResult;
+}
+export interface SessionLifecycleLookupFailure {
+    readonly ok: false;
+    readonly operation: "session.lookup";
+    readonly status: Exclude<SessionLifecycleLookupStatus, "found"> | "unavailable";
+    readonly request: SessionLifecycleLookupIdentity;
+    readonly certainty: SessionLifecycleCertainty;
+    readonly error: SessionLifecycleError;
+}
 export interface SessionLifecycleError {
     readonly code: string;
     readonly message: string;
@@ -249,11 +282,12 @@ export type SessionCloseOutcome = SessionCloseResult | SessionCloseFailure;
 export type SessionDeleteOutcome = SessionDeleteResult | SessionDeleteFailure;
 export type SessionReconcileUncertainOutcome = SessionReconcileUncertainResult | SessionReconcileUncertainFailure;
 export type SessionListOutcome = SessionListSuccessResult | SessionListFailure;
-export type SessionLifecycleResult = SessionCreateOutcome | SessionForkOutcome | SessionResumeOutcome | SessionCloseOutcome | SessionDeleteOutcome | SessionReconcileUncertainOutcome | SessionListOutcome;
+export type SessionLifecycleLookupOutcome = SessionLifecycleLookupSuccessResult | SessionLifecycleLookupFailure;
+export type SessionLifecycleResult = SessionCreateOutcome | SessionForkOutcome | SessionResumeOutcome | SessionCloseOutcome | SessionDeleteOutcome | SessionReconcileUncertainOutcome | SessionListOutcome | SessionLifecycleLookupOutcome;
 /** Shared, side-effect-free validation for lifecycle mutation requests. */
 export type SessionLifecycleMutationValidation = {
     readonly ok: true;
-    readonly operation: Exclude<SessionLifecycleOperation, "session.list">;
+    readonly operation: SessionLifecycleMutationOperation;
     readonly actor: SessionLifecycleActor;
     readonly requestKey: string;
     readonly target: Readonly<Record<string, unknown>>;
@@ -266,6 +300,7 @@ export declare function validateSessionLifecycleMutationRequest(request: unknown
 export declare class SessionLifecycleService {
     #private;
     constructor(client: SessionLifecycleClient);
+    lookup(request: SessionLifecycleLookupRequest): Promise<SessionLifecycleLookupOutcome>;
     scopedList(scope: ScopeRequestV1, limit?: number, cursor?: string): Promise<SessionListOutcome>;
     execute(request: SessionLifecycleMutationRequest, idempotencyKeyOverride?: string): Promise<SessionCreateOutcome | SessionForkOutcome | SessionResumeOutcome | SessionCloseOutcome | SessionDeleteOutcome | SessionReconcileUncertainOutcome>;
     executeWithIdempotencyKey(request: SessionLifecycleMutationRequest, idempotencyKey: string): Promise<SessionCreateOutcome | SessionForkOutcome | SessionResumeOutcome | SessionCloseOutcome | SessionDeleteOutcome | SessionReconcileUncertainOutcome>;
@@ -277,4 +312,3 @@ export declare class SessionLifecycleService {
     reconcileUncertain(request: Omit<SessionReconcileUncertainRequest, "operation">): Promise<SessionReconcileUncertainOutcome>;
     list(request: Omit<SessionListRequest, "operation">): Promise<SessionListOutcome>;
 }
-export {};

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

@@ -38,8 +38,11 @@ export declare function promptDeadlineAt(lease: PromptDeadlineLease): number;
 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.
+ * attributable progress for the accepted prompt. Tool execution boundaries and
+ * streaming updates qualify: skills do their work through tools, so skill
+ * progress is covered; `tool_execution_update` keeps long-running tools (e.g.
+ * a multi-minute Gradle compile that streams stdout) from tripping the
+ * inactivity deadline mid-run. Streaming text/thinking deltas, retries, and
+ * bookkeeping are not attributable.
  */
 export declare function isAttributableProgressEventType(type: string): boolean;

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

@@ -3,10 +3,10 @@ import type { InvocationCorrelation, InvocationReconciliation } from "./host/ses
 import type { SdkPromptTerminalOutcome } from "./prompt-status";
 import type { TurnResultContent } from "./turn-result";
 type DeadlineReconciliation = InvocationReconciliation | KindAwareReconciliation;
-export type PromptDeadlineOutcome = {
+export type PromptDeadlineOutcome = Extract<SdkPromptTerminalOutcome, {
     kind: "failed";
+}> & {
     code: "prompt_deadline_exceeded";
-    message: string;
     provenance: "deadline";
 };
 export interface PromptTerminalTransitionEvidence {

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

@@ -3,7 +3,54 @@
  * Provider error text is retained only in the local diagnostic log; wire and
  * persisted reconciliation details expose a fixed redacted message.
  */
+import type { SdkPromptFailureCategory, SdkPromptFailurePhase, SdkPromptTerminalOutcome } from "./prompt-status";
 export declare const PROMPT_FAILURE_CODE_MAX = 64;
+export declare const PROMPT_FAILURE_MESSAGE_SUBMISSION = "Prompt submission failed.";
+export declare const PROMPT_FAILURE_MESSAGE_POST_START_PROVIDER = "Provider failure after execution started.";
+export declare const PROMPT_FAILURE_MESSAGE_POST_START_AGENT = "Agent run failed after execution started.";
+export declare const PROMPT_FAILURE_MESSAGE_DEADLINE = "Prompt deadline exceeded.";
+/** Evidence that decides whether a failure happened before or after the run started. */
+export interface PromptFailureEvidence {
+    startedAt?: number;
+    hasActivity?: boolean;
+}
+/** Start/activity evidence for phase derivation from a reconciliation record. */
+export declare function failureEvidence(record: {
+    startedAt?: number;
+}, hasActivity?: boolean): PromptFailureEvidence;
+/** Whether the run had already started when the failure was recorded. */
+export declare function promptFailurePhase(evidence: PromptFailureEvidence): SdkPromptFailurePhase;
+export declare function isSdkPromptFailurePhase(value: unknown): value is SdkPromptFailurePhase;
+/** Allowlisted origin category for a bounded safe classifier + provenance. */
+export declare function promptFailureCategory(code: string | undefined, provenance: "agent_failed" | "deadline"): SdkPromptFailureCategory;
+/**
+ * Phase- and category-aware safe wording. A post-start failure is never
+ * described as a submission rejection; the wording says only what the bounded
+ * category actually proves.
+ */
+export declare function promptFailureMessage(phase: SdkPromptFailurePhase, category: SdkPromptFailureCategory): string;
+/**
+ * Recompute `phase`, `category` and `message` for a failed outcome from the
+ * bounded classifier plus the record's start/activity evidence. Non-failed
+ * outcomes pass through untouched. Idempotent.
+ */
+export declare function rephaseFailedOutcome(outcome: SdkPromptTerminalOutcome, evidence: PromptFailureEvidence): SdkPromptTerminalOutcome;
+/** Build a complete failed outcome from a bounded classifier and evidence. */
+export declare function failedPromptOutcome(input: {
+    code: "prompt_failed" | "prompt_deadline_exceeded";
+    provenance: "agent_failed" | "deadline";
+    providerCode?: string;
+    phase?: SdkPromptFailurePhase;
+    evidence: PromptFailureEvidence;
+}): Extract<SdkPromptTerminalOutcome, {
+    kind: "failed";
+}>;
+/**
+ * Bounded safe classifier read off a terminal assistant message: the provider's
+ * own `errorCode`, else the typed transport fact's `providerCode`. Only a safe
+ * token is accepted; anything else is dropped rather than forwarded.
+ */
+export declare function assistantFailureCode(assistant: unknown): string | undefined;
 /** Safe-token code capped at 64; arbitrary failure text is never retained. */
 export declare function sanitizePromptFailure(error: unknown): {
     code: string;

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

@@ -52,6 +52,19 @@ import type { ReceiptState } from "./receipt-state";
 export type PromptReconciliationStatus = "accepted" | "in_flight" | "terminal_ok" | "failed";
 export type SdkPromptStopReason = "end_turn" | "max_tokens" | "max_turn_requests" | "refusal" | "cancelled";
 export type SdkPromptFailureCode = "prompt_failed" | "prompt_deadline_exceeded";
+/**
+ * Stable, safe execution phase of a failed prompt. `submission` means the
+ * failure happened before the run started (a genuine submission rejection);
+ * `post_start` means the run had already started, so it must never be described
+ * as a submission rejection.
+ */
+export type SdkPromptFailurePhase = "submission" | "post_start";
+/**
+ * Allowlisted, bounded origin category for a failed prompt. It is derived only
+ * from safe classifiers (never raw provider text) and preserves `unknown` when
+ * attribution is uncertain instead of guessing.
+ */
+export type SdkPromptFailureCategory = "provider_transport" | "provider_rejected" | "agent_runtime" | "deadline" | "unknown";
 export type SdkPromptTerminalOutcome = {
     kind: "stopped";
     reason: SdkPromptStopReason;
@@ -61,6 +74,12 @@ export type SdkPromptTerminalOutcome = {
     code: SdkPromptFailureCode;
     message: string;
     provenance: "agent_failed" | "deadline";
+    /** Execution phase at failure time; never a submission rejection when post_start. */
+    phase: SdkPromptFailurePhase;
+    /** Bounded failure-origin category; `unknown` when attribution is uncertain. */
+    category: SdkPromptFailureCategory;
+    /** Bounded safe provider/transport classifier when the provider supplied one. */
+    providerCode?: string;
 };
 /** Exactly one selector per lookup. */
 export type TurnPromptStatusSelector = {

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

@@ -1,6 +1,8 @@
 import { type SessionIndex } from "../broker/session-index";
 import { type SdkDispatchContext, type SdkDispatchHandler } from "../client/client";
 import { type ActivatedPreparedSession } from "../session-activation";
+import type { SessionBindingAuthority } from "../session-authority";
+export type { SessionBindingAuthority, SessionEndpointAuthority } from "../session-authority";
 export interface SessionEndpointIdentity {
     readonly dev: bigint;
     readonly mtimeMs: number;
@@ -216,10 +218,7 @@ export declare class SessionRouter {
         dispatchFence?: (dispatch: () => Promise<Record<string, unknown>>) => Promise<Record<string, unknown>>;
     }): Promise<Record<string, unknown>>;
     /** Resolves the exact provider-neutral binding authority for operator adoption. */
-    bindingAuthority(sessionId: string): Promise<{
-        sessionId: string;
-        endpointGeneration: number;
-    } | undefined>;
+    bindingAuthority(sessionId: string): Promise<SessionBindingAuthority | undefined>;
     /**
      * Reconciles one exact endpoint generation without exposing endpoint or process
      * credentials. Retirement is returned only from a retained positive terminal

package/dist/types/sdk/service-artifact-paths.d.ts

@@ -0,0 +1,16 @@
+/** Shared path names; importing this module never initializes a service. */
+export declare const BROKER_ARTIFACT_PATHS: {
+    readonly discovery: "sdk/broker.json";
+    readonly ownerLock: "sdk/broker.lock";
+    readonly ownerRecord: "sdk/broker.lock/owner.json";
+    readonly restartIntent: "sdk/broker.restart.json";
+};
+/** Existing-root identity only; never creates a directory or identity file. */
+export declare function canonicalServiceRootDigest(agentDir: string): Promise<string>;
+export declare const DOCTOR_RESTART_CONTROL_FILE = "doctor-restart.control.json";
+export declare const CHAT_DAEMON_DIRECTORY = "sdk/daemons";
+export declare const CHAT_DAEMON_FILES: {
+    readonly ownerLock: "owner.lock";
+    readonly state: "state.json";
+    readonly control: "control.json";
+};

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

@@ -0,0 +1,9 @@
+/** Exact endpoint authority captured from a verified SDK session binding. */
+export interface SessionEndpointAuthority {
+    readonly endpointGeneration: number;
+    readonly endpointIncarnation: string;
+}
+/** Session identity plus the endpoint authority bound to that exact session. */
+export interface SessionBindingAuthority extends SessionEndpointAuthority {
+    readonly sessionId: string;
+}

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

@@ -137,7 +137,9 @@ export interface CreateAgentSessionOptions {
     /** Disable extension discovery (explicit paths still load). */
     disableExtensionDiscovery?: boolean;
     /**
-     * Pre-loaded extensions (skips file discovery).
+     * Pre-loaded extensions (skips file discovery). A COMPLETE result is required:
+     * the session reuses its live `runtime`, so a partial result dereferences a
+     * missing runtime instead of degrading.
      * @internal Used by CLI when extensions are loaded early to parse custom flags.
      */
     preloadedExtensions?: LoadExtensionsResult;

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

@@ -300,7 +300,7 @@ export interface AgentSessionConfig {
     discoveryMode?: "off" | "mcp-only" | "all";
     /** MCP tool names to activate for the current session when discovery mode is enabled. */
     initialSelectedMCPToolNames?: string[];
-    /** Keep persisted MCP names until a deferred exact catalog becomes available. */
+    /** Keep persisted MCP names until a deferred (exact or conventional) catalog becomes available. */
     preserveUnavailableInitialMCPToolSelection?: boolean;
     /** Built-in discoverable tool names restored for the current all-discovery session. */
     initialSelectedDiscoveredBuiltinToolNames?: string[];

package/dist/types/session/blob-store.d.ts

@@ -124,7 +124,7 @@ export declare class MemoryBlobStore extends BlobStore {
     #private;
     constructor(options?: MemoryBlobStoreOptions);
     put(data: Buffer): Promise<BlobPutResult>;
-    putSync(data: Buffer): BlobPutResult;
+    putSync(data: Buffer, ownership?: typeof TAKE_BLOB_BUFFER_OWNERSHIP): BlobPutResult;
     putImmutableSync(data: Buffer): CheckedBlobPutResult;
     get(hash: string): Promise<Buffer | null>;
     getSync(hash: string): Buffer | null;