@gajae-code/coding-agent 0.17.2 → 0.17.4

package/dist/types/runtime-mcp/pool.d.ts

@@ -145,6 +145,13 @@ export interface MCPPoolLease {
     onEvent(listener: LeaseListener): () => void;
     release(): Promise<void>;
 }
+export interface MCPPreparedReplacement {
+    readonly lease: MCPPoolLease;
+    canCommit(): boolean;
+    publish(): void;
+    commit(): void;
+    abort(): Promise<void>;
+}
 declare class MCPPoolLeaseImpl implements MCPPoolLease {
     #private;
     readonly generation: number;
@@ -187,7 +194,11 @@ export declare class MCPConnectionPool {
     awaitRestart(key: string): Promise<boolean>;
     finishRestart(key: string, error?: unknown): void;
     releaseRestart(key: string): void;
+    private retiredCleanupId;
+    private getRetiredAcquisitionCleanup;
+    private getRetiredAcquisitionCleanupForKey;
     private retainCancelledAcquireCleanup;
+    private retainPreparedCleanup;
     private notifyPendingAcquireCleanup;
     /** @internal Whether this pool still owns the notified abandoned-acquire flight. */
     hasPendingAcquireCleanup(error: MCPPoolAcquireAbortError): boolean;
@@ -202,6 +213,12 @@ export declare class MCPConnectionPool {
     /** @internal Join and retry one generation of abandoned acquisition cleanup. */
     closePendingAcquireCleanup(key: string, generation: number): Promise<void>;
     acquire(name: string, config: MCPServerConfig, options?: MCPPoolAcquireOptions): Promise<MCPPoolLease>;
+    /**
+     * Prepared MCP replacements fence and retain acquisition cleanup ownership
+     * The caller validates its catalog first, then commits the key swap
+     * synchronously or aborts and closes only the candidate.
+     */
+    prepareReplacement(name: string, config: MCPServerConfig, options?: MCPPoolAcquireOptions): Promise<MCPPreparedReplacement>;
     private waitForPendingEntry;
     private scheduleZeroClaimCleanup;
     private cancelPendingEntry;

package/dist/types/runtime-mcp/redaction.d.ts

@@ -1,2 +1,22 @@
+import type { AgentSession } from "../session/agent-session";
 export declare function redactMCPEndpoint(value: string | undefined): string | undefined;
 export declare function redactMCPDiagnosticValue(value: unknown): unknown;
+/**
+ * Capability granted to a session that the root interactive entry point created
+ * with an explicit `--mcp-config` path. Holding it is the only way to read exact
+ * MCP status; it carries no manager, transport, or configuration reference.
+ */
+export interface ExactMcpControls {
+    readonly grantSource: "root-interactive-exact-config";
+    /**
+     * The exact config this session was started with. Status needs it because a
+     * tools-only manager deletes a server from its own bookkeeping when the
+     * connection fails, so the manager alone can never report a server that did
+     * not come up — the very case an operator runs `/mcp` to see.
+     */
+    readonly configPath: string;
+}
+export declare function attachExactMcpControls(session: AgentSession, controls: ExactMcpControls): void;
+export declare function getExactMcpControls(session: AgentSession): ExactMcpControls | undefined;
+/** Revoke controls when the AgentSession object adopts a new logical identity. */
+export declare function revokeExactMcpControls(session: AgentSession): void;

package/dist/types/runtime-mcp/startup-policy.d.ts

@@ -1,4 +1,10 @@
 import type { MCPServerConfig } from "./types";
 export type AutoloadStatus = "autoload" | "autoload-off" | "disabled";
+/** Ordinary standalone sessions stop blocking on MCP startup after this wait. */
+export declare const DEFAULT_MCP_STARTUP_WAIT_MS = 250;
+/** Grace added to the largest declared per-server startup window. */
+export declare const MCP_STARTUP_WAIT_GRACE_MS = 500;
+/** Ordinary startup never blocks longer than this batch ceiling. */
+export declare const MAX_MCP_STARTUP_WAIT_MS = 1750;
 /** Pure startup policy shared by runtime-facing CLI inspection and doctor. */
 export declare function computeAutoloadStatus(name: string, config: Pick<MCPServerConfig, "enabled" | "autoload">, disabledServers: ReadonlySet<string>): AutoloadStatus;

package/dist/types/runtime-mcp/tool-bridge.d.ts

@@ -22,6 +22,13 @@ export interface MCPToolOptions {
      * owning manager/runtime. Resolved per call so late registration still applies.
      */
     inputHandler?: () => MCPInputRequestHandler | undefined;
+    /**
+     * Exact MCP session control: false while the owning manager has this server
+     * suspended. Checked alongside `#sessionControlInvalidated` so a wrapper that
+     * outlives a resume/reconnect still fails locally instead of reaching the
+     * transport for a server this session no longer has active.
+     */
+    isAvailable?: () => boolean;
 }
 export declare function isRetriableConnectionError(error: unknown): boolean;
 /** Details included in MCP tool results for rendering */
@@ -66,6 +73,7 @@ export declare class MCPTool implements CustomTool<TSchema, MCPToolDetails> {
     /** Server name */
     readonly mcpServerName: string;
     private connection;
+    invalidateForSessionControl(): void;
     /** Create MCPTool instances for all tools from an MCP server lease/connection. */
     static fromTools(target: MCPToolTarget, tools: MCPToolDefinition[], reconnect?: MCPReconnect, options?: MCPToolOptions): MCPTool[];
     constructor(target: MCPToolTarget, tool: MCPToolDefinition, reconnect?: MCPReconnect | undefined, options?: MCPToolOptions);
@@ -90,6 +98,7 @@ export declare class DeferredMCPTool implements CustomTool<TSchema, MCPToolDetai
     readonly mcpToolName: string;
     /** Server name */
     readonly mcpServerName: string;
+    invalidateForSessionControl(): void;
     /** Create DeferredMCPTool instances for all tools from an MCP server */
     static fromTools(serverName: string, tools: MCPToolDefinition[], getConnection: () => Promise<MCPServerConnection>, source?: SourceMeta, reconnect?: MCPReconnect, options?: MCPToolOptions): DeferredMCPTool[];
     constructor(serverName: string, tool: MCPToolDefinition, getConnection: () => Promise<MCPServerConnection>, source?: SourceMeta, reconnect?: MCPReconnect | undefined, options?: MCPToolOptions);

package/dist/types/runtime-mcp/transports/http.d.ts

@@ -1,5 +1,7 @@
 import type { MCPHttpServerConfig, MCPRequestOptions, MCPSseServerConfig, MCPTransport } from "../../runtime-mcp/types";
 import { type MCPModernClientContext, type MCPProtocolEra } from "../protocol";
+/** Live HTTP/SSE MCP transports awaiting postmortem release. Exposed for leak assertions/tests. */
+export declare function liveHttpTransportCount(): number;
 /**
  * HTTP transport for MCP servers.
  * Uses POST for requests, supports SSE responses.
@@ -38,6 +40,15 @@ export declare class HttpTransport implements MCPTransport {
     startSSEListener(): Promise<void>;
     request<T = unknown>(method: string, params?: Record<string, unknown>, options?: MCPRequestOptions): Promise<T>;
     notify(method: string, params?: Record<string, unknown>): Promise<void>;
+    /**
+     * Terminate the server-side session on a signal or fatal exit, without the
+     * reader drain `close()` does: postmortem runs inside the signal handler,
+     * where an aborted SSE body read is never observed by JS, so awaiting the
+     * readers there never settles and the DELETE stays unreachable. `onClose` is
+     * deliberately not fired - the manager reacts to it by reconnecting, which
+     * would open a fresh server session on the way out.
+     */
+    releaseForPostmortem(signal: AbortSignal): Promise<void>;
     close(): Promise<void>;
 }
 /**

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

@@ -4,7 +4,7 @@ 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";
-import { SessionIndex } from "./session-index";
+import { type IndexedSession, SessionIndex } from "./session-index";
 import { type MasterCapabilityVerifier, type SpawnSubstrateFailure, type SpawnSubstrateProvider } from "./spawn-authority";
 export interface BrokerSettings {
     agentDir: string;
@@ -149,6 +149,9 @@ export type BrokerResponse = {
     durableEffects?: LifecycleDurableEffectsReceipt;
     startupFailure?: LifecycleStartupFailureReceipt;
 };
+export type InputNormalization = {
+    input: Record<string, unknown>;
+} | BrokerResponse;
 /** Complete five-leg child endpoint pin captured at registration. */
 export type SpawnHostRegistration = {
     sessionId: string;
@@ -201,6 +204,13 @@ export interface SpawnPromptLayer {
         pinned: SpawnHostRegistration;
     }): Promise<SpawnQ26Reconciliation>;
 }
+/** Exact admission predicate for the child host row published after launch. */
+export declare function spawnRegistrationMatches(candidate: IndexedSession, expected: {
+    childId: string;
+    cwd: string;
+    stateRoot: string;
+}): boolean;
+export declare function normalizeBrokerInput(operation: string, input: Record<string, unknown>): InputNormalization;
 /** Test seam for lifecycle serialization identity. */
 export declare function lifecycleTargetForTest(operation: string, input: Record<string, unknown>): unknown;
 /** Tombstone prefix used by {@link Broker.reclaimStaleLock} when a dead owner's lock is renamed aside. */
@@ -235,7 +245,8 @@ export interface BrokerLockArtifactReapResult {
  * of the lock's dev+ino, so a machine accrues one directory per dead owner and
  * nothing ever removed them (54 on the install in #3963). Reaping is
  * best-effort and fail-closed: anything live, unreadable, permission-denied, or
- * otherwise ambiguous is kept and the reason is logged.
+ * otherwise ambiguous is kept. Retained paths are logged at debug level and
+ * summarized in one warning per reap pass.
  */
 export declare function reapStaleBrokerLockArtifacts(input: {
     agentDir: string;

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

@@ -1,4 +1,6 @@
 export declare function brokerIdentityPath(agentDir: string): string;
 export declare function getBrokerIdentityKey(agentDir: string): Promise<string>;
-export declare function deriveIdempotencyIdentity(agentDir: string, operation: string, callerKey: string, _protocolVersionOrLegacyTargetHash?: string): Promise<string>;
+export declare function deriveIdempotencyIdentity(agentDir: string, operation: string, callerKey: string, targetHash?: string): Promise<string>;
+/** Identity format used by lifecycle rows written before target binding. */
+export declare function deriveLegacyIdentity(agentDir: string, operation: string, callerKey: string): Promise<string>;
 export declare function deriveLegacyTargetIdentity(agentDir: string, operation: string, callerKey: string, canonicalTargetHash: string): Promise<string>;

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

@@ -95,6 +95,23 @@ export type BeginResult = {
     kind: "in_progress";
     entry: LifecycleLedgerEntry;
 };
+type BoundedSourceReadRejection = "not-regular-file" | "oversized-by-stat" | "oversized-by-read" | "read-error";
+/**
+ * Why a terminal read-back produced no entry. `absent` means nothing terminal is
+ * recorded for the request; `rejected` means the source or a row was refused, which
+ * is evidence of a damaged ledger rather than of an unpersisted operation. Collapsing
+ * the two lets a corrupt source or row read as "not yet written" and unfence the session.
+ */
+export type TerminalReadBackRejection = "bounds" | "shape" | "undecodable" | "row-not-attributable" | "partial-row" | BoundedSourceReadRejection;
+export type TerminalReadBack = {
+    kind: "terminal";
+    entry: LifecycleLedgerEntry;
+} | {
+    kind: "absent";
+} | {
+    kind: "rejected";
+    reason: TerminalReadBackRejection;
+};
 export interface LifecycleLedgerLimits {
     maxBytes?: number;
     maxLineBytes?: number;
@@ -121,14 +138,15 @@ export declare class LifecycleLedger {
      * uncertainly persists that conclusion, and refusing to read it back would report a
      * synced row as unpersisted and replace its true reason with a generic one.
      */
-    readTerminal(identity: string, requestHash: string): Promise<LifecycleLedgerEntry | undefined>;
-    findByOperationKey(operationKey: string): LifecycleLedgerEntry | undefined;
+    readTerminal(identity: string, requestHash: string): Promise<TerminalReadBack>;
+    findByOperationKey(operationKey: string, fingerprint?: string): LifecycleLedgerEntry | undefined;
+    findAnyByOperationKey(operationKey: string): LifecycleLedgerEntry | undefined;
     /**
      * Legacy target-inclusive rows predate the operation/key index. Their opaque
      * identities cannot establish that a different target is safe, so callers
      * must reject rather than create a second admission.
      */
-    hasLegacyIdentity(): boolean;
+    hasLegacyIdentity(excludedIdentities?: ReadonlySet<string>): boolean;
     migrateIdentity(from: string, to: string, metadata: {
         operationKey: string;
         fingerprint: string;
@@ -137,6 +155,7 @@ export declare class LifecycleLedger {
     begin(identity: string, requestHash: string, metadata?: {
         operationKey?: string;
         fingerprint?: string;
+        intendedSessionId?: string;
     }): Promise<BeginResult>;
     transition(identity: string, state: LifecycleState, fields?: Omit<Partial<LifecycleLedgerEntry>, "identity" | "requestHash" | "state" | "ts">): Promise<LifecycleLedgerEntry>;
     assertSupportedStateVersions(): Promise<void>;
@@ -152,3 +171,4 @@ export declare class LifecycleLedger {
     listUncertainCreatesBySessionId(sessionId: string, effectMarker?: string, remoteCreateKey?: string): LifecycleLedgerEntry[];
     findPendingCleanupByTarget(sessionId: string, cwd: string, transcriptPath: string): LifecycleLedgerEntry | undefined;
 }
+export {};

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

@@ -1,5 +1,6 @@
 import { type ChildProcess } from "node:child_process";
 import { type GjcLaunchWorktreePlan } from "../../gjc-runtime/launch-worktree";
+import type { SessionWorkLease } from "../../session/session-work-lease";
 import type { SessionLifecycleMcpServer } from "../acp/mcp";
 import { type SdkStartupFailure, type SdkStartupRollbackResult } from "../startup-capability";
 import type { Broker, BrokerCleanupEvidence, BrokerResponse } from "./broker";
@@ -8,8 +9,11 @@ import { type ProcessIncarnationCommandRunner, type ProcessIncarnationOptions, p
 import { type SdkInternalSpawnCommand } from "./runtime";
 import { type IndexedSession } from "./session-index";
 export { type ProcessIncarnationCommandRunner, type ProcessIncarnationOptions, parseDarwinProcessIncarnation, processIncarnation, };
+/** Remove lifecycle stderr artifacts abandoned by a broker or detached host crash. */
+export declare function reapOrphanedChildStderrLogs(agentDir: string, limit?: number): Promise<number>;
+export declare function lifecycleFailureMessage(message: string, child?: ChildProcess): string;
 export declare function terminalUncertainStartupMessage(response: BrokerResponse): string;
-export declare function waitForChildSpawn(spawned: Pick<ChildProcess, "off" | "on" | "once">, onPostSpawnError?: (error: Error) => void): Promise<void>;
+export declare function waitForChildSpawn(spawned: Pick<ChildProcess, "off" | "on" | "once" | "pid">, onPostSpawnError?: (error: Error) => void): Promise<void>;
 export interface LifecycleDeadlines {
     receivedAt: number;
     requestedReadinessTimeoutMs: number;
@@ -245,8 +249,9 @@ export interface LifecycleExecutionOutcome {
 /** Returns the response together with every durable lifecycle fact needed for truthful replay. */
 export declare function executeLifecycle(broker: Broker, operation: string, input: Input, identity: string, cleanup?: CleanupEvidence): Promise<LifecycleExecutionOutcome>;
 /**
- * The live client/socket subscription count of the SDK session endpoint this
- * process serves, or `undefined` while this process serves no endpoint.
+ * The live SDK demand count of the session endpoint this process serves, or
+ * `undefined` while this process serves no endpoint. Observer-only sockets are
+ * excluded by {@link SessionHostRuntimeEvidence.observerClients}.
  *
  * Only the SDK session runtime owns the real socket table, so it publishes a
  * reader here instead of every consumer re-deriving attachment from the OS.
@@ -257,8 +262,10 @@ export type SessionHostAttachmentReader = () => number;
 export interface SessionHostRuntimeEvidence {
     /** This runtime's own live SDK client/socket subscription count. */
     attachedClients: SessionHostAttachmentReader;
-    /** Whether this runtime currently has agent work in flight. */
-    workInFlight: () => boolean;
+    /** Optional subset of attached sockets that only observes the host. */
+    observerClients?: SessionHostAttachmentReader;
+    /** One authoritative lease held by every admitted or continuing work state. */
+    workLease: SessionWorkLease;
 }
 /** One runtime's live publication, retractable only by its owner. */
 export interface SessionHostRuntimePublication {
@@ -275,19 +282,19 @@ export interface SessionHostRuntimePublication {
  */
 export declare function publishSessionHostRuntimeEvidence(evidence: SessionHostRuntimeEvidence): SessionHostRuntimePublication;
 /**
- * This process's currently attached SDK client count, summed across every
+ * This process's currently demanding SDK client count, summed across every
  * serving runtime, or `undefined` when no runtime publishes a readable count
  * (before startup, after teardown, or when every reader itself fails). Never
  * guesses: absence of a reader is absence of evidence.
  */
 export declare function sessionHostAttachedClients(): number | undefined;
 /**
- * Whether any runtime in this process has agent work in flight right now.
+ * Whether any runtime in this process still holds its authoritative work lease.
  *
  * Positive evidence only: a runtime that publishes nothing, or whose reader
  * fails, reports no work, so this can never keep an abandoned host alive.
  */
-export declare function sessionHostWorkInFlight(): boolean;
+export declare function sessionHostWorkLeaseActive(): boolean;
 /**
  * How often a live broker re-checks its own session registrations against OS
  * process liveness.

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

@@ -1,4 +1,4 @@
-export type SdkInternalAction = "broker-internal" | "session-host-internal";
+export type SdkInternalAction = "broker-internal" | "session-host-internal" | "stderr-drain-internal";
 export type SdkInternalSpawnCommand = {
     kind: "bun-source";
     file: string;

package/dist/types/sdk/broker/session-index.d.ts

@@ -1,7 +1,7 @@
 import { SDK_STATE_VERSION, SESSION_INDEX_EVENT_VERSION } from "./state-version";
 export type SessionIndexEventType = "host_registered" | "host_heartbeat" | "host_unregistered" | "lifecycle_started" | "lifecycle_terminal" | "session_closed" | "session_deleted" | "record_reconciled";
 export type SessionActivityState = "active" | "idle";
-/** Coalesced broker-owned heartbeat checkpoint (C2): state plus the observation time. */
+/** Host-reported or broker-coalesced heartbeat: state plus the observation time. */
 export interface SessionActivity {
     state: SessionActivityState;
     at: number;
@@ -9,6 +9,8 @@ export interface SessionActivity {
 /** Events persisted without an OS process incarnation (v1/v2 era) are legacy provenance. */
 export type SessionIdentityProvenance = "composite" | "legacy";
 export type SessionTombstoneRule = "retain" | "expire";
+/** Durable provenance for a retired host registration. */
+export type HostUnregisteredReason = "process_exited" | "detached_idle";
 /**
  * Injected retention policy (C3). The broker schedules compaction independently of
  * rotation; settings apply at the next scheduled compaction. `clock` drives both
@@ -76,6 +78,7 @@ export interface SessionIndexEvent {
     /** Immutable endpoint file identity captured by the broker at registration. */
     endpointFileId?: string;
     lifecycleRequestId?: string;
+    hostUnregisteredReason?: HostUnregisteredReason;
     terminalUncertain?: boolean;
     /**
      * Distinguishes the terminal-uncertain claim written by a forced stop of a
@@ -105,6 +108,7 @@ export interface IndexedSession {
     live: boolean;
     indexSeq: number;
     lifecycleRequestId?: string;
+    hostUnregisteredReason?: HostUnregisteredReason;
     terminalUncertain?: boolean;
     /** True only for a terminal-uncertain claim written by a forced stale-worktree release. */
     forcedStaleRelease?: boolean;
@@ -174,6 +178,8 @@ export interface SessionIndexAuditRecord {
 export declare const sessionIndexChecksum: (event: Omit<SessionIndexEvent, "checksum">) => string;
 /** Coalesced heartbeat checkpoint rate cap (C2): at most one per session per minute. */
 export declare const SESSION_HEARTBEAT_INTERVAL_MS = 60000;
+/** A stale-host retirement requires silence well beyond the broker freshness window. */
+export declare const DEAD_HOST_HEARTBEAT_SILENCE_MS: number;
 export declare const DEFAULT_SESSION_RETENTION_MAX_AGE_MS: number;
 export declare const DEFAULT_SESSION_RETENTION_MAX_ROWS = 25000;
 export declare class SessionIndex {
@@ -201,7 +207,20 @@ export declare class SessionIndex {
     refresh(): Promise<void>;
     get indexSeq(): number;
     append(input: Omit<SessionIndexEvent, "version" | "indexSeq" | "checksum" | "ts"> & Partial<Pick<SessionIndexEvent, "ts">>): Promise<SessionIndexEvent>;
-    unregisterIfCurrent(expected: Pick<SessionIndexEvent, "sessionId" | "locator" | "endpointGeneration" | "pid" | "indexSeq" | "endpointMtimeMs" | "endpointFileId" | "lifecycleRequestId" | "processIncarnation" | "hostIncarnation">): Promise<boolean>;
+    /**
+     * Atomically fence an exact, long-silent dead-host authority before a caller
+     * removes state outside the broker index. The comparison and terminal event
+     * append share the machine-global index lock, so a heartbeat, successor
+     * registration, or unresolved-authority update that wins the lock prevents
+     * destructive coordinator cleanup.
+     */
+    retireStaleIfCurrent(expected: {
+        sessionId: string;
+        workspace: string;
+        endpointGeneration: number;
+        endpointIncarnation: string;
+    }): Promise<"retired" | "already_retired" | "not_found" | "stale">;
+    unregisterIfCurrent(expected: Pick<SessionIndexEvent, "sessionId" | "locator" | "endpointGeneration" | "pid" | "indexSeq" | "endpointMtimeMs" | "endpointFileId" | "lifecycleRequestId" | "processIncarnation" | "hostIncarnation">, reason?: HostUnregisteredReason): Promise<boolean>;
     /** Hold the canonical index lock across an authority-sensitive operation. */
     withLocked<T>(callback: () => Promise<T>): Promise<T>;
     snapshot(): Promise<void>;
@@ -210,7 +229,7 @@ export declare class SessionIndex {
      * injected retention policy to a fresh snapshot and truncates the log.
      */
     compact(): Promise<void>;
-    listSessions(): SessionList;
+    listSessions(probedIncarnations?: ReadonlyMap<string, string | undefined>): SessionList;
     /**
      * Credential-free proof for one exact public endpoint generation.
      *

package/dist/types/sdk/broker/spawn-authority.d.ts

@@ -12,6 +12,8 @@ export type SpawnClaimV2 = {
         status: "owned" | "consumed";
     };
     childId?: string;
+    /** Launch proof retained while registration is still unbound so a later retry can re-prove or close it. */
+    substrateProof?: SpawnSubstrateProof;
     seed?: SeedDeliveryV2;
     authorityRef?: string;
     createdAt: number;
@@ -122,6 +124,8 @@ export type SpawnClaimTransition = {
     leaseEpoch?: string;
     /** The fresh child ID is committed before substrate launch. */
     childId?: string;
+    /** Launch proof may be appended to the pre-registration state for later reconciliation. */
+    substrateProof?: SpawnSubstrateProof;
     /** Required for seed and terminal state transitions that carry Q26 facts. */
     seed?: SeedDeliveryV2;
     failure?: SpawnSubstrateFailure;

package/dist/types/sdk/broker/stderr-drainer.d.ts

@@ -0,0 +1,13 @@
+/** Parse and run the private source/compiled CLI drainer route. */
+export declare function runSdkStderrDrainerFromArgv(argv: readonly string[]): Promise<void>;
+/**
+ * Drain a detached lifecycle host's stderr without letting a noisy child grow
+ * its diagnostic artifact. The drainer owns the read side of the pipe, so the
+ * host remains attached to a process that outlives the broker itself.
+ *
+ * The artifact is written through one descriptor opened up front: once the
+ * broker has finished reading the startup diagnostic it unlinks the path, and
+ * the remaining output lands on an unlinked inode that disappears with this
+ * process instead of accumulating under the agent directory.
+ */
+export declare function runSdkStderrDrainer(logPath: string, maxBytes: number): Promise<void>;

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

@@ -25,6 +25,7 @@ import { Settings } from "../../config/settings";
 import type { ExtensionAPI, ExtensionContext } from "../../extensibility/extensions";
 import { type WorkflowGateEmitter, type WorkflowGateTerminalProof } from "../../modes/shared/agent-wire/workflow-gate-broker";
 import type { AgentSessionEvent } from "../../session/agent-session";
+import { type SessionWorkLease, type SessionWorkLeaseHandle } from "../../session/session-work-lease";
 import type { AskAnswerSource, AskAnswerSourceResult, AskRemoteControl } from "../../tools";
 import { type SessionHostRuntimePublication } from "../broker/lifecycle";
 import { type SessionSdkHost } from "../host";
@@ -342,6 +343,17 @@ interface SessionRuntime {
     serverStopped: boolean;
     /** This runtime's own host-liveness publication; only its teardown may retract it. */
     evidencePublication?: SessionHostRuntimePublication;
+    /** Authoritative lease held by admitted input, execution, and recovery work. */
+    workLease: SessionWorkLease;
+    /** Lease retained while an uncorrelated agent loop is active. */
+    activeWorkLease?: SessionWorkLeaseHandle;
+    /** Lease retained while an agent loop is paused awaiting resumption. */
+    pausedWorkLease?: SessionWorkLeaseHandle;
+    /**
+     * Handles of queued submissions promoted to their own run, handed over at
+     * the promotion boundary and retired by that run's agent_start.
+     */
+    promotedWorkLeases: SessionWorkLeaseHandle[];
     brokerRegistrationReleased: boolean;
     verbosity: "lean" | "verbose";
     /** Whether the agent loop is currently running (drives the typing indicator). */
@@ -639,5 +651,12 @@ export declare function createNotificationsExtension(api: ExtensionAPI, options?
                 expectedEpoch?: number;
             };
         }) => Promise<RunSettlementProof>;
+        /**
+         * Live, SYNCHRONOUS view of the dispatched tool calls the run resource
+         * ledger holds for an execution handle (#5637). Strictly read-only: it
+         * never claims, seals or otherwise mutates ledger state. Optional so an
+         * older host that does not thread it degrades to the event-derived set.
+         */
+        pendingToolExecutions?: (handle: string) => readonly string[];
     };
 }): void;

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

@@ -285,8 +285,10 @@ export declare const SDK_LIFECYCLE_ROUTER_PROTOCOL_VERSION = 1;
  * 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.
+ * Generation 190 acknowledges the protected prompt-deadline boundary change,
+ * so generation-189 owners are replaced instead of retaining the old path.
  */
-export declare const DAEMON_GENERATION = 187;
+export declare const DAEMON_GENERATION = 192;
 /**
  * Serving-compatibility boundary for daemon lifecycle requests. Epoch 7
  * requires durable publication receipts and acknowledged attachment dispatch,

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

@@ -725,6 +725,11 @@ export interface TelegramDaemonOptions {
         enabled: boolean;
     };
     idleTimeoutMs?: number;
+    /**
+     * Standalone daemon owners keep Telegram command ingress alive while no SDK
+     * endpoints are attached. Embedded/test daemons retain finite-idle behavior.
+     */
+    keepAliveWithoutAttachments?: boolean;
     /** TTL for durable topic-adoption intents (default 10 minutes). Observed, not a fixed contract. */
     adoptionIntentTtlMs?: number;
     pid?: number;

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

@@ -1,8 +1,9 @@
+import { PublicCommandFailure } from "../../cli/public-command-errors";
 import { type IndexedSession } from "../broker/session-index";
-export declare class SdkMasterCliError extends Error {
+export declare class SdkMasterCliError extends PublicCommandFailure {
     readonly code: string;
     readonly exitCode: 1 | 2;
-    constructor(code: string, message: string, exitCode?: 1 | 2);
+    constructor(code: string, _message: string, exitCode?: 1 | 2);
 }
 export interface SdkSpawnArgs {
     cwd?: string;
@@ -26,11 +27,6 @@ export interface SdkSpawnRendered {
         turnId?: string;
         status?: string;
     };
-    idempotencyKey?: string;
-    error?: {
-        code: string;
-        message: string;
-    };
 }
 export interface SdkSpawnDependencies {
     env: Record<string, string | undefined>;
@@ -48,9 +44,9 @@ export interface SdkSpawnDependencies {
  */
 export declare function selectNewestMasterAttestationEpoch(rows: readonly IndexedSession[], ownerSessionId: string): string | undefined;
 /** Projects an arbitrary Broker response onto the allowlisted render shape. */
-export declare function safeSpawnRender(response: unknown): {
+export declare function safeSpawnRender(response: unknown, idempotencyKey?: string): {
     rendered: SdkSpawnRendered;
-    exitCode: 0 | 1;
+    exitCode: 0;
 };
 export declare function renderSpawnTable(rendered: SdkSpawnRendered): string;
 /**
@@ -59,5 +55,5 @@ export declare function renderSpawnTable(rendered: SdkSpawnRendered): string;
  */
 export declare function runSdkSpawn(args: SdkSpawnArgs, dependencies?: Partial<SdkSpawnDependencies>): Promise<{
     rendered: SdkSpawnRendered;
-    exitCode: 0 | 1;
+    exitCode: 0;
 }>;

package/dist/types/sdk/cli/rows.d.ts

@@ -76,7 +76,25 @@ export interface SdkTailEnvelopeV1 {
     items: SdkTailItemV1[];
 }
 export declare function tailItemKey(item: SdkTailItemV1): string;
-/** Holds positioned live frames until the checkpoint can stamp their authoritative revision. */
+/**
+ * Holds positioned live frames until the checkpoint can stamp their
+ * authoritative revision, and keeps stamping after it.
+ *
+ * A positioned frame (generation+seq) that carries no revision after the
+ * checkpoint used to abort the whole tail with protocol_error. The host emits
+ * such frames whenever its transcript provider is momentarily unavailable
+ * (`eventRevision` returns undefined), which is ordinary during a turn - and
+ * one such frame turned a live, answering session into one no consumer could
+ * observe: every poll failed, the caller held the turn, and after five minutes
+ * reported it failed while the answer sat in the transcript (2026-09-17/18,
+ * five sessions). A frame is never a reason to lose the tail.
+ *
+ * The stamp is the LATEST revision observed, not the checkpoint's: revisions
+ * advance during a turn, and lifecycle order is compared revision-first. A
+ * terminal frame stamped with the initial checkpoint revision would sort
+ * before a start that carried a later one, and `--until-idle` would wait on a
+ * turn that had already ended.
+ */
 export declare class TailRevisionBuffer {
     #private;
     push(item: SdkTailItemV1): SdkTailItemV1[];

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

@@ -1,8 +1,9 @@
+import { PublicCommandFailure, type PublicEffectProof } from "../../cli/public-command-errors";
 import { type SdkSearchResultV1, type SdkSearchRowV1 } from "../broker/session-scope";
-import type { SessionLifecycleService } from "../lifecycle/service";
+import type { SessionLifecycleResult, SessionLifecycleService } from "../lifecycle/service";
 import { SessionRouter } from "../router";
 import { type SdkSessionRowV1 } from "./rows";
-export type SdkSessionCliAction = "list" | "search" | "inspect" | "send" | "status" | "tail" | "retire" | "global" | "raw" | "control" | "query" | "global";
+export type SdkSessionCliAction = "list" | "search" | "inspect" | "send" | "status" | "tail" | "close" | "retire" | "global" | "raw" | "control" | "query";
 export type SdkSessionListScope = "repo" | "cwd" | "worktree" | "all";
 export type SdkSessionCliRawKind = "control" | "query" | "global";
 export interface SdkSessionCliArgs {
@@ -24,6 +25,8 @@ export interface SdkSessionCliArgs {
     strict?: boolean;
     untilIdle?: boolean;
     allEvents?: boolean;
+    /** tail --cursor: transcript row id the caller has already processed; rows up to and including it are omitted. */
+    afterTranscriptId?: string;
     page?: boolean;
     repo?: string;
     scope?: string;
@@ -31,16 +34,28 @@ export interface SdkSessionCliArgs {
     json?: boolean;
     agentDir?: string;
 }
+export interface SdkSessionCliDependencies {
+    readonly lifecycleService?: SessionLifecycleService;
+}
 type JsonRecord = Record<string, unknown>;
 export interface RetainedTranscriptTailReader {
     readonly size: number;
     readRange(start: number, end: number): Promise<Uint8Array>;
 }
+export declare const SDK_JSON_INPUT_FILE_MAX_BYTES: number;
+/** Translate only SDK-owned codes and explicitly allowlisted reconciliation fields. */
+export declare function sdkPublicFailure(code: string, details?: unknown, proof?: PublicEffectProof): PublicCommandFailure;
+/** Lifecycle terminality/retryability is not, by itself, proof of an effect outcome. */
+export declare function lifecyclePublicFailure(outcome: Extract<SessionLifecycleResult, {
+    ok: false;
+}>): PublicCommandFailure;
+/** Reads a 0600 JSON input through one descriptor, never through a replaceable pathname. */
+export declare function readSecureJsonInputFile(filePath: string): Promise<string>;
 export declare function mergeProbedSearchRows(rows: readonly SdkSearchRowV1[], probedRows: readonly SdkSearchRowV1[]): readonly SdkSearchRowV1[];
 /** Resolves, lists, and probes only the exact rows selected by the Broker-scoped search. */
 export declare function runSdkSearch(args: Pick<SdkSessionCliArgs, "agentDir" | "repo" | "scope" | "limit" | "cursor">, createService?: (agentDir: string) => SessionLifecycleService, probe?: (agentDir: string, result: SdkSearchResultV1) => Promise<SdkSearchResultV1>): Promise<{
     result: SdkSearchResultV1;
-    exitCode: 0 | 1;
+    exitCode: 0;
 }>;
 /** Renders a credential-free scope/status preamble and bounded search table. */
 export declare function renderSdkSearchTable(result: SdkSearchResultV1): string;
@@ -93,8 +108,10 @@ export declare function waitForTerminalStatus(router: SessionRouter, sessionId:
     status: string;
     detail: unknown;
 }>;
-export declare function scanRetainedTranscriptTail(reader: RetainedTranscriptTailReader): Promise<unknown[]>;
+export declare function scanRetainedTranscriptTail(reader: RetainedTranscriptTailReader, options?: {
+    boundaryId?: string;
+}): Promise<unknown[]>;
 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 declare function runSdkSessionCli(args: SdkSessionCliArgs, writeOutput?: (value: unknown) => void, setExitCode?: (exitCode: 1 | 2) => void, deps?: SdkSessionCliDependencies): Promise<void>;
 export {};

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

@@ -41,6 +41,8 @@ export interface SdkClientOptions {
     timeoutMs?: number;
     /** Absolute wall-clock deadline shared by connect, hello, retry, and request work. */
     deadline?: number;
+    /** Optional client capabilities sent in the protocol hello handshake. */
+    capabilities?: readonly string[];
     reconnectAttempts?: number;
     reconnectBackoffMs?: number;
     /**