@gajae-code/coding-agent 0.17.2 → 0.17.4

package/dist/types/extensibility/runtime-skill-discovery.d.ts

@@ -23,6 +23,16 @@ export interface RuntimeSkillDiscoveryResult {
     candidates: RuntimeSkillDiscoveryCandidate[];
     /** Deduped skill metadata the query filter ran against, including bundled entries; candidates.length <= scanned. */
     scanned: number;
+    /**
+     * Skills left after the query filter, before the page slice: the denominator
+     * a page is a page *of*. `scanned` counts everything the filter ran against,
+     * so it cannot serve this role.
+     */
+    matching: number;
+    /** Normalized zero-based offset the returned page starts at. */
+    offset: number;
+    /** Offset of the next page, present only while one exists; omitted on the final page. */
+    nextOffset?: number;
     diagnostics: RuntimeSkillDiscoveryDiagnostics;
 }
 export interface DiscoverRuntimeSkillsOptions {
@@ -33,9 +43,17 @@ export interface DiscoverRuntimeSkillsOptions {
     profileAuthority?: "default" | "custom";
     query?: string;
     limit?: number;
+    /** Zero-based index into the matching set the returned page starts at; defaults to 0. */
+    offset?: number;
     source?: RuntimeSkillDiscoveryScope | "all";
     policy?: SkillsSettings;
 }
+/**
+ * Upper bound every caller's `limit` clamps to. Exported so `gjc skills discover`
+ * can default a human to the widest page the library will serve instead of the
+ * model-context-sized `DEFAULT_LIMIT`.
+ */
+export declare const SKILL_DISCOVERY_MAX_LIMIT = 50;
 /**
  * Explain an empty result that is caused by disabled discovery config rather
  * than by an actually empty skill catalog. Uses the user-facing trust

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

@@ -81,9 +81,11 @@ export interface SessionCompactEvent {
     /** Whether the compaction entry was provided by an extension/hook */
     fromExtension: boolean;
 }
-/** Fired on process exit (SIGINT/SIGTERM) */
+/** Fired during session teardown, including process exit and SDK host self-reap. */
 export interface SessionShutdownEvent {
     type: "session_shutdown";
+    /** Set only when the SDK host reaped itself after detached-idle grace. */
+    reason?: "detached_idle";
 }
 /** Preparation data for tree navigation (used by session_before_tree event) */
 export interface TreePreparation {

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

@@ -1,3 +1,4 @@
+import { type LinuxProcPidProbeResult } from "./linux-proc";
 /**
  * How a `<file>.lock` owner record can be opened safely on this platform.
  *
@@ -43,6 +44,13 @@ export declare const SessionStateLockTestHooks: {
      * configuration.
      */
     probeProcessSignal?: (pid: number) => void;
+    /**
+     * @internal How an owner pid's `/proc` entry is read. Whether a killed pid is still an
+     * unreaped zombie depends on when its parent happens to reap it, so it cannot be
+     * arranged deterministically from a test. Production code never sets it, and it is
+     * never serialized or exposed as runtime configuration.
+     */
+    probeLinuxProcPid?: (pid: number) => LinuxProcPidProbeResult;
     /**
      * @internal Runs inside a NEW owner record's write, after the exclusive create has
      * taken the pathname and before the record's bytes land. Throwing from it fails that
@@ -90,6 +98,32 @@ export declare const SessionStateLockTestHooks: {
 };
 /** Raised when the lock could not be acquired; callers map it to their own refusal. */
 export type SessionStateLockUnavailableReason = "acquire_timeout" | "legacy_directory_owner_unprovenanced" | "lock_initialization_failed" | "lock_inspection_failed" | "lock_owner_live_or_unverifiable" | "lock_owner_record_fresh" | "lock_owner_record_unprovenanced" | "lock_release_failed" | "transition_claim_timeout" | "unsafe_lock_path_type";
+/**
+ * Why a stale-transition reclaim refused, as a bounded classifier.
+ *
+ * `transition_claim_timeout` collapsed several structurally different refusals into
+ * one message, so an operator could not tell a foreign-host tombstone from a
+ * live owner from a directory an external process was stamping — the gap #5606
+ * asked for. Every member is a fixed enum: never a path, token, host id, pid or
+ * raw errno, because this rides on an error message users paste into reports.
+ */
+export type TransitionReclaimRefusal = 
+/** The claim vanished, or its owner sidecar was absent/unparseable/invalid. */
+"claim_or_owner_unreadable"
+/** A released tombstone carrying no `owner_host_id` at all. */
+ | "released_owner_unprovenanced"
+/** A released tombstone belonging to a different installation. */
+ | "released_owner_foreign_host"
+/** A released tombstone still inside `RELEASED_TRANSITION_GRACE_MS`. */
+ | "released_owner_within_grace"
+/** The owner is alive, or its liveness could not be disproven. */
+ | "owner_live_or_unverifiable"
+/** The claim changed between inspection and capture — an external writer. */
+ | "claim_generation_changed"
+/** The claim was not empty when captured, so it is not ours to remove. */
+ | "claim_not_empty"
+/** The claim's canonical path or directory snapshot could not be taken. */
+ | "claim_capture_failed";
 interface SessionStateLockUnavailableDetails {
     lockPath: string;
     reason: SessionStateLockUnavailableReason;
@@ -170,6 +204,33 @@ export declare function setSessionStateLockNativeBindings(load: SessionStateLock
  * and deletion has a different inode identity and is refused by construction.
  */
 export declare function removeVerifiedEmptyQuarantine(directory: string, name: string): Promise<void>;
+/**
+ * Outcome of one stale-transition reclaim attempt. `reclaimed` drives the
+ * caller's retry accounting exactly as the previous boolean did; `refusal`
+ * exists only so the eventual `transition_claim_timeout` can name which
+ * precondition said no (#5606).
+ */
+interface TransitionReclaimOutcome {
+    reclaimed: boolean;
+    reclaimReason?: "released_handoff" | "dead_owner";
+    refusal?: TransitionReclaimRefusal;
+}
+/**
+ * Classify one stale-transition reclaim attempt.
+ *
+ * @internal exported as the seam the refusal classifier is tested through. Driving
+ * a real `transition_claim_timeout` would mean waiting out `LOCK_ACQUIRE_MAX_WAIT_MS`
+ * (60s) per case, and `tryWithSessionStateFileLock` throws BUSY before the timeout
+ * is ever built, so the per-branch reasons have no other reachable surface (#5606).
+ */
+export declare function classifyTransitionReclaimForTests(transitionDir: string, quarantineName: string): Promise<TransitionReclaimOutcome>;
+/**
+ * Build the timeout error exactly as the transition loop does.
+ *
+ * @internal exported so the message contract — a bounded enum suffix and nothing
+ * else — is pinned without a 60s wait (#5606).
+ */
+export declare function transitionClaimTimeoutForTests(transitionDir: string, refusal: TransitionReclaimRefusal | undefined): SessionStateLockUnavailableError;
 export declare function reclaimStaleSessionStateLock(lockFile: string, quarantineName?: string): Promise<void>;
 /**
  * Serialize one read-modify-write of `stateFile` against every other holder of

package/dist/types/internal-urls/embedded-protocol.d.ts

@@ -0,0 +1,9 @@
+import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
+/**
+ * Handler for `embedded:` URLs.
+ */
+export declare class EmbeddedProtocolHandler implements ProtocolHandler {
+    readonly scheme = "embedded";
+    readonly immutable = true;
+    resolve(url: InternalUrl): Promise<InternalResource>;
+}

package/dist/types/internal-urls/index.d.ts

@@ -9,6 +9,7 @@
  */
 export * from "./agent-protocol";
 export * from "./artifact-protocol";
+export * from "./embedded-protocol";
 export * from "./gjc-protocol";
 export * from "./issue-pr-protocol";
 export * from "./json-query";

package/dist/types/internal-urls/parse.d.ts

@@ -10,10 +10,18 @@
  * MUST use this function instead of calling `new URL()` directly.
  */
 import type { InternalUrl } from "./types";
+/**
+ * Canonicalize an internal URL so slashless schemes carry an authority.
+ *
+ * Every entry point that inspects or routes an internal URL (router,
+ * read/write tools, selector splitting) MUST normalize first, so handlers only
+ * ever see the `scheme://authority/path` form.
+ */
+export declare function normalizeInternalUrlInput(input: string): string;
 /**
  * Parse an internal URL into an InternalUrl.
  *
  * Handles URLs where `new URL()` would fail (e.g., `skill://plugin:name`
  * where the colon is not a port separator).
  */
-export declare function parseInternalUrl(input: string): InternalUrl;
+export declare function parseInternalUrl(rawInput: string): InternalUrl;

package/dist/types/main.d.ts

@@ -5,6 +5,7 @@
  * createAgentSession() options. The SDK does the heavy lifting.
  */
 import type { ImageContent } from "@gajae-code/ai/core";
+import { postmortem } from "@gajae-code/utils";
 import type { Args } from "./cli/args";
 import { ModelRegistry } from "./config/model-registry";
 import { Settings } from "./config/settings";
@@ -17,6 +18,8 @@ import { initTheme } from "./modes/theme/theme";
 import type { SubmittedUserInput } from "./modes/types";
 import type { MCPManager } from "./runtime-mcp";
 import { type CreateAgentSessionOptions, type CreateAgentSessionResult, createAgentSession, discoverAuthStorage } from "./sdk";
+import { processIncarnation } from "./sdk/broker/process-incarnation";
+import { SessionIndex } from "./sdk/broker/session-index";
 import type { AgentSession } from "./session/agent-session";
 import { type ResumeSessionIdentity, type SessionDestination, type SessionDirectoryMigrationPolicy, type SessionInfo, SessionManager, type StrictSessionOpenResult } from "./session/session-manager";
 import { resolveStartupAuthConfig } from "./session/startup-auth-config";
@@ -117,6 +120,7 @@ export declare class SessionNotFoundError extends Error {
     get sessionId(): string;
 }
 export declare function operatorFacingSessionOpenMessage(value: unknown): string | undefined;
+export declare function shouldNotifyModelFallback(authBootstrap: boolean | undefined, isInteractive: boolean): boolean;
 export declare function runInteractiveMode(session: AgentSession, version: string, changelogMarkdown: string | undefined, notifs: (InteractiveModeNotify | null)[], startupUpdate: StartupUpdateOrchestrator, initialMessages: string[], setExtensionUIContext: (uiContext: ExtensionUIContext, hasUI: boolean) => void, lspServers: LspStartupServerInfo[] | undefined, mcpManager: MCPManager | undefined, eventBus?: EventBus, initialMessage?: string, initialImages?: ImageContent[], createInteractiveMode?: CreateInteractiveMode, resumeAction?: "continue-tail" | "open-idle", startDeferredMcpConfig?: CreateAgentSessionResult["startDeferredMcpConfig"], startDeferredModelProfiles?: DeferredModelProfileStartup, options?: {
     stopAfterFirstPaint?: boolean;
 }): Promise<void>;
@@ -153,6 +157,24 @@ export interface RunRootCommandDependencies {
     initializeSettings?: typeof Settings.init;
     loadSettingsForScope?: typeof Settings.loadForScope;
 }
+type DirectSessionManager = Pick<SessionManager, "getCwd" | "getSessionFile" | "getSessionId">;
+/**
+ * Direct CLI liveness is meaningful only for sessions with a durable transcript.
+ * An in-memory manager has no artifacts for GC to fence and must not touch the
+ * shared SDK session-index lock.
+ */
+export declare function directSessionRegistrationId(sessionManager: DirectSessionManager | undefined, lifecycleRequestId: string | undefined): string | undefined;
+interface DirectSessionRegistrationDependencies {
+    createIndex?: (agentDir: string) => SessionIndex;
+    processIncarnation?: typeof processIncarnation;
+    registerPostmortem?: typeof postmortem.register;
+    masterRole?: {
+        ownerSessionId: string;
+        attestationEpoch: string;
+    };
+}
+/** Register a durable direct CLI session while leaving ephemeral sessions lock-free. */
+export declare function registerDirectSession(sessionManager: DirectSessionManager | undefined, agentDir: string, lifecycleRequestId: string | undefined, dependencies?: DirectSessionRegistrationDependencies): Promise<void>;
 export interface ModelRoleOverrides {
     smol?: string;
     slow?: string;

package/dist/types/modes/acp/acp-agent.d.ts

@@ -1,6 +1,6 @@
 import { type Agent, type AgentSideConnection, type AuthenticateRequest, type AuthenticateResponse, type AvailableCommand, type CancelNotification, type ClientCapabilities, type CloseSessionRequest, type CloseSessionResponse, type DeleteSessionRequest, type DeleteSessionResponse, type ForkSessionRequest, type ForkSessionResponse, type InitializeRequest, type InitializeResponse, type ListSessionsRequest, type ListSessionsResponse, type LoadSessionRequest, type LoadSessionResponse, type NewSessionRequest, type NewSessionResponse, type PromptRequest, type PromptResponse, type ResumeSessionRequest, type ResumeSessionResponse, type SetSessionConfigOptionRequest, type SetSessionConfigOptionResponse, type SetSessionModeRequest, type SetSessionModeResponse } from "@agentclientprotocol/sdk";
 import { type AcpProviderRegistration, type AcpReverseConnection, AcpSdkAdapter, AcpSdkAdapterError } from "../../sdk/acp";
-import type { SdkPromptTerminalOutcome } from "../../sdk/prompt-status";
+import type { SdkPromptFailureCategory, SdkPromptFailurePhase, SdkPromptTerminalOutcome } from "../../sdk/prompt-status";
 import { type PromptWatchdogClock } from "../../sdk/prompt-watchdog";
 import type { AcpStartupOptions } from "./startup-options";
 /**
@@ -58,6 +58,60 @@ export declare class AcpPromptFailureError extends AcpSdkAdapterError {
     readonly failure: SdkPromptFailedOutcome;
     constructor(failure: SdkPromptFailedOutcome);
 }
+/**
+ * The wire projection of a prompt terminal's classification (issue #5615).
+ *
+ * `super(failure.code, failure.message)` above narrows the error to the generic
+ * `prompt_failed` plus its fixed redacted message, so the classification the
+ * terminal already computed used to die at the JSON-RPC boundary: an ACP client
+ * saw only `-32603 {code, details}` and could not tell a transient provider blip
+ * from a dead session without parsing English. These fields carry it across.
+ *
+ * `providerCode` is re-checked against the safe-token rule rather than trusted:
+ * `terminalOutcome` accepts the host's `providerCode` on a `typeof` check alone,
+ * and this is the first path that puts it on the wire, so an unbounded value is
+ * dropped instead of becoming a leak of provider text (the redaction contract in
+ * `sanitizePromptFailure`). A dropped or absent code is omitted, never nulled.
+ */
+export declare const OPERATOR_UPSTREAM_LABEL = "Upstream provider failure";
+export declare const OPERATOR_UPSTREAM_SUFFIX = ": the model provider ended this turn.";
+/**
+ * `post_start` proves execution began, so tools may already have run and had effects before the
+ * provider died. The wording therefore qualifies the turn rather than absolving the task: saying
+ * the task was unaffected would assert something the bounded classifiers do not establish.
+ */
+export declare const OPERATOR_PARTIAL_WORK_NOTE = " Work this turn had already performed may have taken effect; check before retrying.";
+/**
+ * Operator-facing wording for a post-start terminal, assembled ONLY from bounded safe tokens: the
+ * classifier `phase`, the `category`, and a `providerCode` that passes `isSafePromptFailureCode`.
+ * Raw provider text never reaches this function and must never reach it.
+ *
+ * Gated on BOTH `phase === "post_start"` and `category === "provider_transport"`. A submission-phase
+ * provider failure is rejected by the phase gate: nothing executed, so wording about a turn the
+ * provider ended would describe an event that never occurred.
+ *
+ * It claims only what those tokens prove — that the upstream provider ended the turn — and says
+ * nothing about whether the operator's work survived. `post_start` proves execution began, so the
+ * wording qualifies that earlier work may already have taken effect instead of absolving the task.
+ *
+ * This is additive. The wire `code`/`details` pair and every `PROMPT_FAILURE_MESSAGE_*` constant
+ * stay exactly as they are — pinned ACP core-v1 conformance asserts on them — so this wording
+ * travels alongside the redacted message instead of repurposing it.
+ *
+ * It says NOTHING about the worktree, deliberately. Nothing on this path inspects the worktree, so
+ * any sentence about uncommitted work would assert a check that never ran — reporting an
+ * uninspected tree as clean is the absence-of-evidence-as-evidence-of-absence error, and an
+ * operator who believed it would sweep work away. Silence is the only honest option until something
+ * actually looks.
+ *
+ * Returns `undefined` for every other category: `phase` and `category` are already on the wire, so
+ * restating them in prose tells an operator nothing they do not already have.
+ */
+export declare function postStartOperatorMessage(input: {
+    phase: SdkPromptFailurePhase;
+    category: SdkPromptFailureCategory;
+    providerCode?: string;
+}): string | undefined;
 /**
  * What an ACP `plan` update said the turn intended to do. Structural rather than the SDK's
  * `PlanEntry` so only the fields this evidence reads are depended on.

package/dist/types/modes/acp/startup-provenance.d.ts

@@ -0,0 +1,16 @@
+type JsonObject = Record<string, unknown>;
+export type PrimaryControlSurface = "cli" | "sdk";
+/**
+ * Startup-control provenance is the authority record ACP needs before it may take
+ * permission, provider, and lifecycle ownership of a session. Hosts serving that
+ * record report capabilities carrying `promptTerminalOutcomeVersion`
+ * and `primaryControlSurface`; a host that predates the record reports neither, and a
+ * host that cannot answer at all reports nothing. Those are three different operator
+ * problems, so they get three different messages instead of one "restart the session".
+ */
+export declare function resolveStartupProvenance(input: {
+    sessionId: string;
+    capabilities: JsonObject | undefined;
+    queryFailure: unknown;
+}): PrimaryControlSurface;
+export {};

package/dist/types/modes/components/custom-provider-wizard.d.ts

@@ -2,10 +2,28 @@ import { Container } from "@gajae-code/tui";
 import type { ProviderSetupInput } from "../../setup/provider-onboarding";
 export type CustomProviderCredentialSource = "env" | "literal";
 export type CustomProviderWizardSubmit = ProviderSetupInput;
+export interface CustomProviderWizardDiscoveryDeps {
+    discoverModels?: (input: {
+        baseUrl: string;
+        apiKeyEnv?: string;
+        apiKey?: string;
+        signal?: AbortSignal;
+    }) => Promise<{
+        models: string[];
+    }>;
+}
 export declare class CustomProviderWizardComponent extends Container {
     #private;
-    constructor(onSubmit: (input: CustomProviderWizardSubmit) => void, onCancel: () => void, onRender?: () => void);
+    constructor(onSubmit: (input: CustomProviderWizardSubmit) => void, onCancel: () => void, onRender?: () => void, discoveryDeps?: CustomProviderWizardDiscoveryDeps);
     setSubmitError(error: string): void;
     handleInput(keyData: string): void;
     complete(): void;
+    /** Generation token for the latest submit attempt. */
+    currentSubmitGeneration(): number;
+    /**
+     * Whether a submit attempt is still current: same generation and not
+     * dismissed. Revision or cancel invalidates pending completions so a
+     * stale refresh cannot report success or rerender over new inputs.
+     */
+    isSubmitCurrent(generation: number): boolean;
 }

package/dist/types/modes/components/session-selector.d.ts

@@ -19,14 +19,16 @@ declare class SessionList implements Component {
     onCancel?: () => void;
     onExit: () => void;
     onDeleteRequest?: (session: SessionInfo) => void;
+    onToggleStarRequest?: (session: SessionInfo) => void;
     constructor(allSessions: SessionInfo[], showCwd?: boolean);
     setInputFrozen(frozen: boolean): void;
     removeSession(sessionPath: string): void;
+    setSessionStarred(sessionPath: string, starred: boolean): void;
     invalidate(): void;
     render(width: number): string[];
     handleInput(keyData: string): void;
 }
-/** A one-shot resume consent selector. It never opens or mutates sessions. */
+/** A one-shot resume consent selector with host-owned deletion and star persistence. */
 export declare class SessionSelectorComponent extends Container {
     #private;
     private readonly onSelect;
@@ -35,7 +37,8 @@ export declare class SessionSelectorComponent extends Container {
     private readonly onDelete?;
     private readonly inspector?;
     private readonly onSelection?;
-    constructor(sessions: SessionInfo[], onSelect: (sessionPath: string) => void | Promise<void>, onCancel: () => void, onExit: () => void, onDelete?: ((session: SessionInfo) => Promise<boolean>) | undefined, inspector?: SessionInspector | undefined, onSelection?: ((selection: SessionSelectionResult) => void) | undefined);
+    private readonly onSetStarred?;
+    constructor(sessions: SessionInfo[], onSelect: (sessionPath: string) => void | Promise<void>, onCancel: () => void, onExit: () => void, onDelete?: ((session: SessionInfo) => Promise<boolean>) | undefined, inspector?: SessionInspector | undefined, onSelection?: ((selection: SessionSelectionResult) => void) | undefined, onSetStarred?: ((session: SessionInfo, starred: boolean) => Promise<void>) | undefined);
     setOnRequestRender(callback: () => void): void;
     handleInput(keyData: string): void;
     getSessionList(): SessionList;

package/dist/types/modes/components/user-message-selector.d.ts

@@ -13,16 +13,19 @@ declare class UserMessageList implements Component {
     onSelect?: (entryId: string) => void;
     onCancel?: () => void;
     constructor(messages: UserMessageItem[]);
+    setAvailableRows(rows: number): void;
     invalidate(): void;
     render(width: number): string[];
     handleInput(keyData: string): void;
 }
 /**
- * Component that renders a user message selector for branching
+ * Component that renders a prompt selector for creating a new session
  */
 export declare class UserMessageSelectorComponent extends Container {
     #private;
-    constructor(messages: UserMessageItem[], onSelect: (entryId: string) => void, onCancel: () => void);
+    private readonly getViewportRows;
+    constructor(messages: UserMessageItem[], onSelect: (entryId: string) => void, onCancel: () => void, getViewportRows: () => number);
+    render(width: number): string[];
     getMessageList(): UserMessageList;
 }
 export {};

package/dist/types/modes/controllers/command-controller.d.ts

@@ -30,7 +30,7 @@ export declare class CommandController {
     handleDropCommand(): Promise<boolean>;
     handleForkCommand(): Promise<void>;
     handleMoveCommand(targetPath: string): Promise<void>;
-    handleRenameCommand(title: string): Promise<void>;
+    handleRenameCommand(title?: string): Promise<void>;
     handleBashCommand(command: string, excludeFromContext?: boolean): Promise<void>;
     handlePythonCommand(code: string, excludeFromContext?: boolean): Promise<void>;
     handleCompactCommand(customInstructions?: string): Promise<CompactionOutcome>;

package/dist/types/modes/controllers/selector-controller.d.ts

@@ -131,7 +131,7 @@ export declare class SelectorController {
         smartRoutingOnly?: boolean;
     }): void;
     showPluginSelector(mode?: "install" | "uninstall"): Promise<void>;
-    showUserMessageSelector(): void;
+    showUserMessageSelector(onCommitted?: () => void): void;
     showTreeSelector(): void;
     showSessionSelector(): Promise<void>;
     handleResumeSession(sessionPath: string): Promise<void>;

package/dist/types/modes/interactive-mode.d.ts

@@ -257,7 +257,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     handleDropCommand(): Promise<boolean>;
     handleForkCommand(): Promise<void>;
     handleMoveCommand(targetPath: string): Promise<void>;
-    handleRenameCommand(title: string): Promise<void>;
+    handleRenameCommand(title?: string): Promise<void>;
     handleMemoryCommand(text: string): Promise<void>;
     handleSTTToggle(): Promise<void>;
     showDebugSelector(): void;

package/dist/types/modes/shared/agent-wire/workflow-gate-broker.d.ts

@@ -8,6 +8,8 @@ export type PersistedResolutionOrigin = {
     kind: "telegram_notification";
     interactionActionId: string;
 };
+/** Keep accepted diagnostics below the coordinator's cumulative Q12 snapshot cap. */
+export declare const MAX_ACCEPTED_WORKFLOW_GATE_QUERY_RECORDS = 32;
 export type PersistedAckPolicy = {
     kind: "none";
     reason: "non_telegram" | "semantic_noncommit" | "legacy_unproven";
@@ -95,7 +97,7 @@ export interface WorkflowGateEmitter {
  */
 export declare class BrokerWorkflowGateEmitter implements WorkflowGateEmitter {
     #private;
-    constructor(runId: string, store: GateStore, emitterHooks?: Pick<BrokerHooks, "advance">);
+    constructor(runId: string, store: GateStore, emitterHooks?: Pick<BrokerHooks, "advance" | "continuationLost">);
     supportsRemoteGateAnswers(): boolean;
     setRuntimeTurnProvider(provider: (() => string | undefined) | null): void;
     emitGate(input: OpenGateInput): Promise<unknown>;
@@ -193,6 +195,11 @@ export type GateAuditEvent = {
 } | {
     event: "gate_response_idempotent_replay";
     gate_id: string;
+}
+/** An idempotent replay refused because this runtime cannot prove the continuation ran. */
+ | {
+    event: "gate_response_replay_unproven";
+    gate_id: string;
 } | {
     event: "gate_response_idempotency_conflict";
     gate_id: string;
@@ -225,6 +232,8 @@ export interface BrokerHooks {
     terminalizeAccepted?(record: PersistedGate): WorkflowGateTerminalProof | Promise<WorkflowGateTerminalProof>;
     /** Runs only after a successful advance has been durably marked advanced. */
     completeAccepted?(record: PersistedGate): void | Promise<void>;
+    /** Notifies the owning runtime when the accepted answer cannot reach its continuation. */
+    continuationLost?(record: PersistedGate): void;
     /** Append-only audit sink. */
     audit?(event: GateAuditEvent): void;
 }
@@ -277,6 +286,7 @@ export declare class WorkflowGateBroker {
     lookupCompletedResolution(response: WorkflowGateResponse): WorkflowGateCompletedResolutionLookup;
     private runShort;
     private hasLiveContinuation;
+    private recordContinuationLoss;
     hasRecoverableAcceptedGate(): boolean;
     prepareTerminalization(gateId: string, proof: WorkflowGateTerminalProof): boolean;
     clearPreparedTerminalization(gateId: string): void;

package/dist/types/modes/shared/agent-wire/workflow-gate-types.d.ts

@@ -117,13 +117,26 @@ export interface WorkflowGateDiagnostic extends WorkflowGate {
     id: string;
     tag: "quarantined";
     lifecycle: WorkflowGateLifecycle;
+    /** Whether the durable broker retained an answer for this gate. */
+    answer_recorded: boolean;
+}
+/** Durable acceptance evidence for a gate that is no longer pending. */
+export interface WorkflowGateResolutionDiagnostic extends WorkflowGate {
+    id: string;
+    tag: "accepted";
+    /** True when the accepted record contains the answer body. */
+    answer_recorded: true;
+    resolved_at: string;
+    /** Single post-accept disposition; raw answers and derived answer values stay private. */
+    post_accept_disposition: "accepted" | "terminalized" | "advanced" | "continuation_lost" | "unknown";
 }
 /** Stable Q12 row preserving the root WorkflowGate shape. */
 export type WorkflowGateQueryRecord = (WorkflowGate & {
     id: string;
     tag: "pending";
     lifecycle?: undefined;
-}) | WorkflowGateDiagnostic;
+    answer_recorded: false;
+}) | WorkflowGateDiagnostic | WorkflowGateResolutionDiagnostic;
 /** Inbound: the agent's answer to a workflow gate. */
 export interface WorkflowGateResponse {
     gate_id: string;

package/dist/types/modes/types.d.ts

@@ -303,7 +303,7 @@ export interface InteractiveModeContext {
     handleHandoffCommand(customInstructions?: string): Promise<void>;
     handleContributionPrepCommand(customInstructions?: string): Promise<void>;
     handleMoveCommand(targetPath: string): Promise<void>;
-    handleRenameCommand(title: string): Promise<void>;
+    handleRenameCommand(title?: string): Promise<void>;
     handleMemoryCommand(text: string): Promise<void>;
     handleSTTToggle(): Promise<void>;
     executeCompaction(customInstructionsOrOptions?: string | CompactOptions, isAuto?: boolean): Promise<CompactionOutcome>;
@@ -367,7 +367,7 @@ export interface InteractiveModeContext {
     initHooksAndCustomTools(): Promise<void>;
     emitCustomToolSessionEvent(reason: "start" | "switch" | "branch" | "tree" | "shutdown", previousSessionFile?: string): Promise<void>;
     planModeController: Pick<import("./controllers/plan-mode-controller").PlanModeController, "enabled" | "paused" | "planFilePath" | "handleCommand" | "handleApproval" | "flushPendingModelSwitch">;
-    goalModeController: Pick<import("./controllers/goal-mode-controller").GoalModeController, "enabled" | "paused" | "handleCommand">;
+    goalModeController: Pick<import("./controllers/goal-mode-controller").GoalModeController, "enabled" | "paused" | "handleCommand" | "cancelContinuation" | "scheduleContinuation">;
     setHookWidget(key: string, content: ExtensionWidgetContent, options?: ExtensionWidgetOptions): void;
     setHookStatus(key: string, text: string | undefined): void;
     showHookSelector(title: string, options: string[], dialogOptions?: ExtensionUIDialogOptions): Promise<string | undefined>;

package/dist/types/runtime/process-lifecycle.d.ts

@@ -80,6 +80,8 @@ type ResourceDisposer = () => void | Promise<void>;
 export declare function registerResourceOwner(name: string, disposer: ResourceDisposer): () => void;
 /** Number of registered resource owners. Exposed for leak assertions/tests. */
 export declare function resourceOwnerCount(): number;
+/** True while a process-level resource-owner sweep is in progress. */
+export declare function isResourceOwnerDisposalActive(): boolean;
 /**
  * Run and clear every registered resource disposer. Attempts all disposers even
  * if some throw, then surfaces the failures as an `AggregateError` so callers

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

@@ -14,6 +14,7 @@ import type { MCPProtocolObservation } from "./protocol";
 import type { MCPToolDetails } from "./tool-bridge";
 import type { MCPToolCache } from "./tool-cache";
 import type { MCPGetPromptResult, MCPInputRequestHandler, MCPPrompt, MCPRequestOptions, MCPResource, MCPResourceReadResult, MCPResourceTemplate, MCPServerConfig, MCPServerConnection } from "./types";
+export declare function isMCPStartupTimeoutError(error: unknown): boolean;
 export declare function resolveStartupTimeoutMs(configs: MCPServerConfig[], maxStartupTimeoutMs?: number): number;
 export declare function resolveExactConfigStartupTimeoutMs(configs: MCPServerConfig[]): number;
 /**
@@ -56,6 +57,20 @@ export interface MCPLoadResult {
     /** Extracted Exa API keys from filtered MCP servers */
     exaApiKeys: string[];
 }
+export type MCPToolCatalogPublication = "unpublished" | "published" | "fenced";
+/**
+ * Atomic view of the manager's fenced tool catalog and its publication state.
+ *
+ * `unpublished` is reserved for the initial deferred window where no manager
+ * catalog has been published and no exact control is fencing it. An empty
+ * `published` or `fenced` catalog is authoritative and must not be replaced
+ * with an in-flight discovery result.
+ */
+export interface MCPToolCatalogSnapshot {
+    tools: CustomTool<TSchema, MCPToolDetails>[];
+    publication: MCPToolCatalogPublication;
+    generation: number;
+}
 /** Options for discovering and connecting to MCP servers */
 export interface MCPDiscoverOptions {
     /** Whether to load project-level config (default: true) */
@@ -100,6 +115,30 @@ export interface MCPManagerOptions {
     /** Test seam for fencing the acquisition-to-registration replacement race. */
     afterLeaseAcquiredForTests?: (name: string, lease: MCPPoolLease) => void | Promise<void>;
 }
+export type ExactMcpServerControlStatus = "suspended" | "already-suspended" | "resumed" | "not-suspended" | "reconnected" | "unavailable" | "unknown-server";
+export interface ExactMcpServerControlResult {
+    readonly name: string;
+    readonly status: ExactMcpServerControlStatus;
+    readonly toolCount: number;
+}
+/**
+ * A staged catalog the caller can validate against before it is published.
+ * `commit` is the single publication point; `abort` releases anything the
+ * preparation opened and leaves the manager on its predecessor.
+ */
+export interface PreparedExactMcpCatalog {
+    readonly tools: CustomTool<TSchema, MCPToolDetails>[];
+    canCommit(): boolean;
+    commit(): Promise<void>;
+    abort(): Promise<void>;
+}
+export interface PreparedExactMcpServerControl extends PreparedExactMcpCatalog {
+    readonly result: ExactMcpServerControlResult;
+    /** Validate a resumed replacement before an atomic multi-server publication. */
+    precommit?(): void;
+    /** Publish after every replacement in the catalog has passed precommit. */
+    publish?(): void;
+}
 /**
  * MCP Server Manager.
  *
@@ -164,6 +203,23 @@ export declare class MCPManager {
      * Get all loaded tools.
      */
     getTools(): CustomTool<TSchema, MCPToolDetails>[];
+    /**
+     * Read the fenced catalog and publication state atomically.
+     *
+     * An empty catalog is still authoritative after publication or while an
+     * exact control is in flight. Deferred startup may fall back to its discovery
+     * result only for the explicit `unpublished` state.
+     */
+    getToolCatalogSnapshot(): MCPToolCatalogSnapshot;
+    isExactServerSuppressed(name: string): boolean;
+    /**
+     * Prepare one exact-config control without publishing manager state. Session
+     * registry and prompt validation run against `tools`; commit is the single
+     * publication point and abort releases only an unpublished candidate.
+     */
+    prepareExactServerControl(action: "suspend" | "resume" | "reconnect", name: string): Promise<PreparedExactMcpServerControl>;
+    /** Clear all session-local suppression before this owner adopts a new identity. */
+    prepareExactServerControlReset(): Promise<PreparedExactMcpCatalog>;
     /**
      * Get a specific connection.
      */