@gajae-code/coding-agent 0.14.2 → 0.15.0

package/dist/types/gjc-runtime/workflow-recovery-projection.d.ts

@@ -0,0 +1,100 @@
+/** Skills whose durable state can produce a structured recovery projection. */
+export type WorkflowRecoverySkill = "ralplan" | "ultragoal";
+export interface WorkflowRecoveryScopeItem {
+    kind: "accepted" | "non_goal";
+    text: string;
+}
+export interface WorkflowRecoveryProjection {
+    skill: WorkflowRecoverySkill;
+    /** Canonical durable state that produced this projection. */
+    source: "ralplan-final" | "ralplan-run" | "ultragoal-plan";
+    /** Bounded accepted objective for the current work contract. */
+    objective: string;
+    /** Bounded accepted scope + explicit non-goals (scope reload, not expansion). */
+    scope: WorkflowRecoveryScopeItem[];
+    /** Bounded acceptance criteria / verification obligations. */
+    acceptanceCriteria: string[];
+    /** Unresolved decisions carried from the durable contract, bounded. */
+    unresolved: string[];
+    /** Durable identity + integrity digest of the source state. */
+    provenance: {
+        planPath?: string;
+        runId?: string;
+        stage?: string;
+        sha256?: string;
+    };
+    /** Current goal + measurable progress counters from canonical state. */
+    currentGoal?: {
+        goalId: string;
+        status: string;
+        objective: string;
+    };
+    progress: {
+        totalGoals?: number;
+        completedGoals?: number;
+        outstandingGoals?: number;
+        /** Latest boundary review generation recorded in the ledger. */
+        latestReviewGeneration?: number;
+        /** Frozen source hash of the latest joined review cohort, if any. */
+        latestCohortSourceHash?: string;
+        /** Ledger event id of the newest event backing this projection. */
+        latestLedgerEventId?: string;
+    };
+    /** Exact next bounded action class for resumption. */
+    nextAction: {
+        actionClass: "continue-current-goal" | "start-next-goal" | "resolve-review-blockers" | "run-boundary-cohort" | "run-plan-review" | "revise-plan" | "reconcile-intent" | "final-aggregate-checkpoint" | "awaiting-approval" | "unknown";
+        goalId?: string;
+        detail?: string;
+    };
+    /** #4560: measurable-progress basis for bounding zero-progress cycles. */
+    zeroProgress: {
+        fingerprint: string;
+        unchangedObservations: number;
+        stalled: boolean;
+    };
+}
+/** #4560: compaction-observation memory for zero-progress bounding. */
+export interface WorkflowRecoveryZeroProgressMemory {
+    /** Last observed progress fingerprint per skill. */
+    lastFingerprint?: string;
+    /** Consecutive compaction observations with an unchanged fingerprint. */
+    unchangedObservations: number;
+}
+/** #4560: bound repeated zero-progress continuation cycles (#4560). */
+export declare const ZERO_PROGRESS_STALL_THRESHOLD = 2;
+export declare function trackWorkflowRecoveryZeroProgress(memory: WorkflowRecoveryZeroProgressMemory | undefined, projection: WorkflowRecoveryProjection): WorkflowRecoveryZeroProgressMemory;
+export declare function isWorkflowRecoveryStalled(memory: WorkflowRecoveryZeroProgressMemory | undefined): boolean;
+export interface RalplanFinalProjectionInput {
+    cwd: string;
+    sessionId: string;
+    runId: string;
+}
+interface RalplanProjectionInput extends RalplanFinalProjectionInput {
+    lastReviewVerdict?: string;
+    lastReviewVerdictLane?: string;
+}
+export declare function projectRalplanFinalRun(input: RalplanFinalProjectionInput): Promise<WorkflowRecoveryProjection | undefined>;
+export declare function projectRalplanRun(input: RalplanProjectionInput): Promise<WorkflowRecoveryProjection | undefined>;
+/**
+ * Project the active Ralplan run recorded in durable mode state. When legacy
+ * state has no run id, fall back to complete runs ordered by index freshness,
+ * skipping unfinished or malformed candidates instead of letting them shadow
+ * the newest usable final contract.
+ */
+export declare function projectLatestRalplanRun(input: {
+    cwd: string;
+    sessionId: string;
+}): Promise<WorkflowRecoveryProjection | undefined>;
+/**
+ * Build a recovery projection from Ultragoal canonical durable state. The
+ * accepted contract is the aggregate objective plus the goal list; progress
+ * and next action are derived from `goals.json` status plus the newest ledger
+ * receipts, never from conversation memory.
+ */
+export declare function projectUltragoalRun(input: {
+    cwd: string;
+    sessionId: string;
+}): Promise<WorkflowRecoveryProjection | undefined>;
+/** Stable digest over the projection's contract-relevant fields. */
+export declare function hashWorkflowRecoveryProjection(projection: WorkflowRecoveryProjection): string;
+export {};

package/dist/types/hooks/skill-keywords.d.ts

@@ -5,7 +5,7 @@ export interface SkillKeywordDefinition {
     priority: number;
     guidance: string;
 }
-export declare const GJC_WORKFLOW_SKILLS: readonly ["deep-interview", "ralplan", "ultragoal", "team"];
+export declare const GJC_WORKFLOW_SKILLS: readonly ["deep-interview", "ralplan", "ultragoal", "autoresearch"];
 export type GjcWorkflowSkill = CanonicalGjcWorkflowSkill;
 export declare const GJC_SKILL_KEYWORD_DEFINITIONS: readonly SkillKeywordDefinition[];
 export declare function isGjcWorkflowSkill(value: string): value is GjcWorkflowSkill;

package/dist/types/main.d.ts

@@ -102,15 +102,6 @@ export declare const BARE_RESUME_OPEN_ERROR = "Could not open the selected sessi
 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): Promise<void>;
 export declare function getChangelogForDisplay(parsed: Args): Promise<string | undefined>;
 export declare function createSessionManager(parsed: Args, cwd: string, activeSettings?: Settings): Promise<SessionManager | undefined>;
-/**
- * Research-mode (RLM) preset hook. Lets `gjc rlm` augment the session options
- * (system prompt, restricted toolset, custom python tool) and assert the tool
- * boundary once the session's tool registry is fully assembled.
- */
-export interface RlmPreset {
-    applyOptions: (options: CreateAgentSessionOptions, settings: Settings) => void;
-    onSessionCreated?: (session: AgentSession) => void | Promise<void>;
-}
 type RunPrintMode = (session: AgentSession, options: PrintModeOptions) => Promise<void>;
 export interface RunRootCommandDependencies {
     createAgentSession?: typeof createAgentSession;
@@ -120,7 +111,6 @@ export interface RunRootCommandDependencies {
         agentDir?: string;
     }) => Promise<void>;
     settings?: Settings;
-    rlmPreset?: RlmPreset;
     suppressProcessExit?: boolean;
     startupUpdate?: {
         check: () => Promise<string | undefined>;

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

@@ -75,13 +75,20 @@ export declare function transcriptContinuations(entry: unknown): TranscriptConti
  */
 export declare function collectActiveProviderIds(adapter: Pick<AcpSdkAdapter, "query">): Promise<ReadonlySet<string> | undefined>;
 /**
- * Collect every page of `models.list/current` (Q10) into one catalog so the
- * active-provider filter never drops models that only appear on later pages.
- * The SDK pages Q10 at a fixed byte target (256 KiB), which a fully
- * configured catalog can exceed. Returns the same
- * `{ result: { page: { items } } }` envelope `pageItems` consumes.
+ * Collect the model catalog (Q10) and the active-provider set (Q29) under one
+ * credential ordering. Assembling the first Q10 page is what finalizes host-side
+ * credential state — expired or invalid OAuth credentials are refreshed or
+ * disabled while that snapshot is built, and continuation pages replay the
+ * frozen revision without further side effects — so Q29 must not start until
+ * page 1 has resolved. Starting both together would let Q29 snapshot pre-refresh
+ * credential state and mix catalog rows and provider availability from different
+ * credential states. After page 1, the provider walk overlaps the remaining
+ * catalog pages instead of adding its latency after them.
  */
-export declare function collectModelCatalog(adapter: Pick<AcpSdkAdapter, "query">): Promise<unknown>;
+export declare function collectModelCatalogAndActiveProviders(adapter: Pick<AcpSdkAdapter, "query">): Promise<{
+    modelCatalog: unknown;
+    activeProviders: ReadonlySet<string> | undefined;
+}>;
 /** Maps live canonical SDK config and the selected model catalog into the ACP 1.2.1 session state surface. */
 export declare function acpSessionStateFromConfig(query: unknown, modelCatalogQuery?: unknown, modelPreset?: string, activeProviders?: ReadonlySet<string>): {
     configOptions: ({

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

@@ -1,10 +1,13 @@
 import { ThinkingLevel } from "@gajae-code/agent-core";
 import { type Model } from "@gajae-code/ai/core";
 import { Container, Input, type TUI } from "@gajae-code/tui";
+import { type AutoroutingSetup } from "../../config/autorouting-contract";
 import type { GjcModelAssignmentTargetId, ModelRegistry } from "../../config/model-registry";
 import { type ScopedModelSelection } from "../../config/model-resolver";
 import type { ModelProfileConfig } from "../../config/models-config-schema";
 import type { Settings } from "../../config/settings";
+import type { SmartRoutingIntent, SmartRoutingPreview } from "./smart-routing-panel";
+import { SmartRoutingPanelComponent } from "./smart-routing-panel";
 type ScopedModelItem = ScopedModelSelection;
 export type ModelSelectorSelection = {
     kind: "assignment";
@@ -26,8 +29,12 @@ export type ModelSelectorSelection = {
 } | {
     kind: "deleteProfile";
     profileName: string;
+} | {
+    kind: "smartRouting";
+    intent: SmartRoutingIntent;
 };
 type RoleSelectCallback = (selection: ModelSelectorSelection) => void | Promise<void>;
+type ModelSelectorViewMode = "presets" | "models" | "smart-routing";
 /**
  * Component that renders a canonical model selector with provider tabs.
  * - Preset landing Left/Right: Collapse/expand selected provider
@@ -48,6 +55,9 @@ export declare class ModelSelectorComponent extends Container {
         currentThinkingLevel?: ThinkingLevel;
         activeModelProfile?: string;
         configuredDefaultChain?: readonly string[];
+        smartRoutingPreview?: (draft: AutoroutingSetup) => SmartRoutingPreview;
+        /** Open the smart-routing panel directly instead of the preset landing. */
+        smartRoutingOnly?: boolean;
     });
     dispose(): void;
     refreshRoleAssignments(options?: {
@@ -55,6 +65,7 @@ export declare class ModelSelectorComponent extends Container {
         currentThinkingLevel?: ThinkingLevel;
         activeModelProfile?: string;
     }): void;
+    refreshSmartRoutingState(): void;
     handleInput(keyData: string): void;
     refreshPresetProfiles(profileName?: string): void;
     getSearchInput(): Input;
@@ -64,5 +75,8 @@ export declare class ModelSelectorComponent extends Container {
     }>, "kind">): Promise<void>;
     __testSelectPresetAction(profileName: string, action: "rename" | "delete"): Promise<void>;
     __testSelectedPresetRowIdentity(): string | undefined;
+    __testGetSmartRoutingPanel(): SmartRoutingPanelComponent | undefined;
+    __testViewMode(): ModelSelectorViewMode;
+    __testOpenSmartRoutingPanel(): void;
 }
 export {};

package/dist/types/modes/components/skill-hud/render.d.ts

@@ -1,2 +1,7 @@
 import { type SkillActiveEntry } from "../../../skill-state/active-state";
-export declare function renderSkillHudBar(entries: readonly SkillActiveEntry[], width: number): string | null;
+/**
+ * Render the HUD as physical rows rather than embedding a newline in one row.
+ * The bottom-pinned TUI layout counts array elements as rows; a newline inside
+ * one element corrupts that accounting and can overwrite the editor.
+ */
+export declare function renderSkillHudBar(entries: readonly SkillActiveEntry[], width: number): string[] | null;

package/dist/types/modes/components/smart-routing-panel.d.ts

@@ -0,0 +1,82 @@
+import { Container } from "@gajae-code/tui";
+import type { AutoroutingProvenance, AutoroutingProviderOrderHint, AutoroutingSetup, TierMap } from "../../config/autorouting-contract";
+import type { AutoroutingSourceIdentity } from "../../config/autorouting-generator";
+/** Longest rendered panel line before truncation. */
+export declare const MAX_PANEL_LINE_WIDTH = 200;
+export type SmartRoutingPreview = {
+    readonly setup: AutoroutingSetup;
+    readonly tiers: TierMap;
+    readonly provenance: AutoroutingProvenance;
+    readonly sourceIdentity: AutoroutingSourceIdentity;
+};
+export type SmartRoutingIntent = {
+    kind: "apply";
+    draft: AutoroutingSetup;
+    preview: SmartRoutingPreview;
+    confirmHandEdit?: boolean;
+} | {
+    kind: "refresh";
+    confirmHandEdit?: boolean;
+} | {
+    kind: "clear";
+} | {
+    kind: "toggle";
+    enabled: boolean;
+};
+export type SmartRoutingPanelMode = "editing" | "confirming" | "committing" | "done" | "error";
+export type SmartRoutingConfirmation = "clear" | "hand-edit" | undefined;
+export interface SmartRoutingPanelOptions {
+    setup: AutoroutingSetup;
+    tiers?: TierMap;
+    provenance?: AutoroutingProvenance;
+    /** Advisory drift between the recorded declaration and current provider priority. */
+    providerOrderHint?: AutoroutingProviderOrderHint;
+    enabled: boolean;
+    readOnly: boolean;
+    stale: boolean;
+    preview: SmartRoutingPreview;
+    generatePreview: (draft: AutoroutingSetup) => SmartRoutingPreview;
+    onSelect: (intent: SmartRoutingIntent) => undefined | Promise<SmartRoutingPreview | undefined>;
+    onCancel: () => void;
+}
+/**
+ * Presentational smart-routing setup editor. It owns only ephemeral draft and
+ * preview state; all durable changes are emitted as typed intents.
+ */
+export declare class SmartRoutingPanelComponent extends Container {
+    #private;
+    constructor(options: SmartRoutingPanelOptions);
+    get mode(): SmartRoutingPanelMode;
+    get confirmation(): SmartRoutingConfirmation;
+    getDraft(): AutoroutingSetup;
+    getPreviewPayload(): SmartRoutingPreview;
+    getProviderOrder(): readonly string[];
+    /**
+     * Advisory-only, non-destructive hint update.
+     *
+     * `refreshState` deliberately replaces the draft and clears editor state, so it
+     * must never be used for a background settings change: an external
+     * `modelProviderOrder` edit would then discard the user's unsaved reordering,
+     * allowlist buffer, cursor, and confirmation. This replaces the hint and nothing
+     * else.
+     */
+    updateProviderOrderHint(hint: AutoroutingProviderOrderHint | undefined): void;
+    /** Replace the panel's persisted snapshot after a controller mutation. */
+    refreshState(options: {
+        setup: AutoroutingSetup;
+        tiers?: TierMap;
+        provenance?: AutoroutingProvenance;
+        enabled: boolean;
+        providerOrderHint?: AutoroutingProviderOrderHint;
+        stale: boolean;
+        preview: SmartRoutingPreview;
+    }): void;
+    handleInput(data: string): void;
+    __testApply(): Promise<void>;
+    /** Test hook mirroring an in-panel provider reorder/edit: mutates the draft and re-previews. */
+    __testSetProviders(providers: string[]): void;
+    __testRefresh(confirmHandEdit?: boolean): Promise<void>;
+    __testToggle(enabled?: boolean): Promise<void>;
+    __testClear(): Promise<void>;
+    __testConfirm(): Promise<void>;
+}

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

@@ -1,4 +1,5 @@
 import type { Component, SlashCommand } from "@gajae-code/tui";
+import { type AutoroutingSetup } from "../../config/autorouting-contract";
 import type { ModelProfileConfig } from "../../config/models-config-schema";
 import { type Settings } from "../../config/settings";
 import { type InteractiveModeContext, type OAuthSelectorOptions } from "../../modes/types";
@@ -11,6 +12,7 @@ import { type CredentialAutoImportStateStore } from "../../setup/credential-auto
 import { type CommandPaletteAction } from "../components/command-palette";
 import type { NotificationsEditorOperations } from "../components/notifications-settings-editor";
 import { type PlanPreviewOptions, type PlanPreviewResult } from "../components/plan-preview-overlay";
+import type { SmartRoutingPreview } from "../components/smart-routing-panel";
 import type { StatusLineSettings } from "../components/tool-status-header";
 import type { JobsObserver } from "../jobs-observer";
 import type { SessionObserverRegistry } from "../session-observer-registry";
@@ -112,8 +114,20 @@ export declare class SelectorController {
      * This handles side effects and session-specific settings.
      */
     handleSettingChange(id: string, value: unknown): void;
+    /** Generate the immutable preview used by the smart-routing panel. */
+    previewSmartRouting(draft: AutoroutingSetup): SmartRoutingPreview;
+    applySmartRouting(draft: AutoroutingSetup, options?: {
+        preview?: SmartRoutingPreview;
+        confirmHandEdit?: boolean;
+    }): Promise<SmartRoutingPreview>;
+    refreshSmartRouting(options?: {
+        confirmHandEdit?: boolean;
+    }): Promise<SmartRoutingPreview>;
+    clearGeneratedSetup(): Promise<void>;
+    setAutoroutingEnabled(enabled: boolean): Promise<void>;
     showModelSelector(options?: {
         temporaryOnly?: boolean;
+        smartRoutingOnly?: boolean;
     }): void;
     showPluginSelector(mode?: "install" | "uninstall"): Promise<void>;
     showUserMessageSelector(): void;

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

@@ -151,6 +151,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
         display?: boolean;
     }, options?: ComposerSubmissionOptions): SubmittedUserInput;
     cancelPendingSubmission(): boolean;
+    hasPendingSubmission(): boolean;
     markPendingSubmissionStarted(input: SubmittedUserInput): boolean;
     finishPendingSubmission(input: SubmittedUserInput): void;
     updateEditorChrome(): void;
@@ -265,7 +266,9 @@ export declare class InteractiveMode implements InteractiveModeContext {
     showAgentsDashboard(): void;
     showModelSelector(options?: {
         temporaryOnly?: boolean;
+        smartRoutingOnly?: boolean;
     }): void;
+    setAutoroutingEnabled(enabled: boolean): Promise<void>;
     showEffortSelector(): void;
     showProviderOnboarding(): void;
     showPluginSelector(mode?: "install" | "uninstall"): void;

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

@@ -213,6 +213,13 @@ export interface InteractiveModeContext {
         display?: boolean;
     }, options?: ComposerSubmissionOptions): SubmittedUserInput;
     cancelPendingSubmission(): boolean;
+    /**
+     * True while a submission is pending: not yet started, or started but still
+     * awaiting prompt delivery (`session.prompt()` has not flipped streaming yet).
+     * Interrupt handling uses this to keep a started-preflight submission
+     * cancellable instead of misclassifying its loader as stale (#4741).
+     */
+    hasPendingSubmission(): boolean;
     markPendingSubmissionStarted(input: SubmittedUserInput): boolean;
     finishPendingSubmission(input: SubmittedUserInput): void;
     /**
@@ -306,7 +313,9 @@ export interface InteractiveModeContext {
     showAgentsDashboard(): void;
     showModelSelector(options?: {
         temporaryOnly?: boolean;
+        smartRoutingOnly?: boolean;
     }): void;
+    setAutoroutingEnabled(enabled: boolean): Promise<void>;
     showEffortSelector(): void;
     showProviderOnboarding(): void;
     showPluginSelector(mode?: "install" | "uninstall"): void;

package/dist/types/rlm/artifacts.d.ts

@@ -1,9 +1,9 @@
 import type { RlmArtifactPaths } from "./types";
-export declare const RLM_DIR_SEGMENT = "rlm";
+export declare const RLM_DIR_SEGMENT = "runs";
 export declare function isValidRlmSessionId(sessionId: string): boolean;
 /** Generate a filesystem-safe, sortable session id (timestamp + random suffix). */
 export declare function generateRlmSessionId(now?: Date): string;
-export declare function resolveRlmArtifactPaths(cwd: string, sessionId: string): RlmArtifactPaths;
+export declare function resolveRlmArtifactPaths(cwd: string, sessionId: string, gjcSessionId?: string): RlmArtifactPaths;
 export declare function ensureRlmSessionDir(paths: RlmArtifactPaths): Promise<void>;
-export declare function rlmSessionExists(cwd: string, sessionId: string): Promise<boolean>;
-export declare function readRlmNotebookIfPresent(cwd: string, sessionId: string): Promise<import("../edit/notebook").NotebookDocument | undefined>;
+export declare function rlmSessionExists(cwd: string, sessionId: string, gjcSessionId?: string): Promise<boolean>;
+export declare function readRlmNotebookIfPresent(cwd: string, sessionId: string, gjcSessionId?: string): Promise<import("../edit/notebook").NotebookDocument | undefined>;

package/dist/types/runtime/optional-runtime-services.d.ts

@@ -13,7 +13,8 @@ export interface OptionalRuntimeServices {
 export type OptionalRuntimeServicesOverrides = Partial<OptionalRuntimeServices>;
 /** Context needed by services whose identity is scoped to the session cwd. */
 export interface OptionalRuntimeServicesContext {
-    cwd?: string;
+    /** Session cwd. Pass a getter when the session can rescope (`move_session`). */
+    cwd?: string | (() => string);
 }
 /**
  * Fill the optional runtime-service container with the defaults for this

package/dist/types/runtime/workspace-tree-service.d.ts

@@ -12,5 +12,9 @@ export interface WorkspaceTreeRuntime {
  * Build the workspace-tree service without importing the native scanner until
  * the service is activated. The scan itself remains the single authority for
  * both eager startup and the lazy first-turn barrier.
+ *
+ * `cwd` is resolved per scan rather than captured once: a session that rescopes
+ * (`move_session`, `/move`) must have its refreshes re-root at the new cwd,
+ * otherwise every later tree describes the abandoned launcher root.
  */
-export declare function createWorkspaceTreeService(settings: Settings, cwd: string): LazyService<WorkspaceTreeRuntime>;
+export declare function createWorkspaceTreeService(settings: Settings, cwd: string | (() => string)): LazyService<WorkspaceTreeRuntime>;

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

@@ -24,6 +24,12 @@ export interface LoadMCPConfigsOptions {
     nativeOnly?: boolean;
     /** Load only this explicit MCP config file. */
     configPath?: string;
+    /**
+     * Agent directory that holds the user scope (`<agentDir>/mcp.json`).
+     * Default: `getAgentDir()`. Sessions created with their own `agentDir` pass it
+     * so discovery and `gjc mcp add --scope user` read and write the same file.
+     */
+    agentDir?: string;
 }
 /** Result of loading MCP configs */
 export interface LoadMCPConfigsResult {

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

@@ -15,6 +15,16 @@ import type { MCPToolCache } from "./tool-cache";
 import type { MCPGetPromptResult, MCPInputRequestHandler, MCPPrompt, MCPRequestOptions, MCPResource, MCPResourceReadResult, MCPResourceTemplate, MCPServerConfig, MCPServerConnection } from "./types";
 export declare function resolveStartupTimeoutMs(configs: MCPServerConfig[], maxStartupTimeoutMs?: number): number;
 export declare function resolveExactConfigStartupTimeoutMs(configs: MCPServerConfig[]): number;
+/**
+ * Whether `config` declared a connection window that is still open `elapsedMs`
+ * into startup.
+ *
+ * The startup wait bounds how long session start blocks; a declared `timeout`
+ * bounds how long the server itself may take to come up (`connectToServer`
+ * enforces it). Those are different budgets: the wait elapsing says nothing
+ * about whether the operator's declared window has been spent.
+ */
+export declare function withinDeclaredConnectionWindow(config: MCPServerConfig, elapsedMs: number): boolean;
 export declare class MCPManagerLifecycleError extends Error {
     readonly code: "MCP_MANAGER_LIFECYCLE_CLOSED";
     readonly phase: "disconnect" | "reconnect";

package/dist/types/sdk/acp/adapter.d.ts

@@ -40,10 +40,6 @@ export declare function acpMcpLaunchFailure(error: unknown, mcpServers: SessionL
 export type AcpReconnectFailedHandler = (error: SdkClientError) => void;
 export type AcpFrameHandler = (frame: Record<string, unknown>) => void;
 export { ACP_SESSION_RECONNECT };
-/**
- * Pure ACP-to-SDK adapter. It deliberately owns neither an AgentSession nor an
- * ACP bridge: all session work is performed through authenticated v3 frames.
- */
 export declare class AcpSdkAdapter {
     #private;
     constructor(options: AcpSdkAdapterOptions);

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

@@ -19,7 +19,7 @@ type ResolvedBrokerSettings = {
     heartbeatTtlMs: number;
     resolveDirectoryMigration: (_cwd: string) => Promise<DirectoryMigrationPolicy>;
 };
-export type BrokerErrorCode = "idempotency_conflict" | "terminal_uncertain" | "broker_restarting" | "unavailable" | "endpoint_stale" | "resource_gone" | "invalid_input" | "spawn_failed" | "startup_admission_timeout" | "startup_admission_refused" | "readiness_timeout" | "close_refused" | "not_found" | "live_session" | "cleanup_pending" | (string & {});
+export type BrokerErrorCode = "idempotency_conflict" | "terminal_uncertain" | "broker_restarting" | "unavailable" | "endpoint_stale" | "resource_gone" | "invalid_input" | "spawn_failed" | "ready_then_exited" | "endpoint_unreadable" | "startup_admission_timeout" | "startup_admission_refused" | "readiness_timeout" | "close_refused" | "not_found" | "live_session" | "cleanup_pending" | (string & {});
 export type BrokerCleanupIdentity = {
     dev: string;
     ino: string;

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

@@ -26,6 +26,9 @@ type LifecycleCommandResolver = () => LifecycleCommand;
 export declare function setLifecycleCleanupHookForTest(broker: Broker, hook: (() => void) | undefined): void;
 export declare function setLifecycleCommandResolverForTest(broker: Broker, resolver: LifecycleCommandResolver | undefined): void;
 export declare function setLifecycleTimingForTest(broker: Broker, timing: LifecycleTiming | undefined): void;
+/** Deterministic platform seam for Windows-only ready-then-exit tolerance. */
+export declare function setLifecycleHostPlatformForTest(platform: NodeJS.Platform | undefined): void;
+export declare function readyThenExitToleranceEnabledForTest(): boolean;
 export declare function hasValidLifecycleDeadlines(value: LifecycleDeadlines, now?: number): boolean;
 type Input = Record<string, unknown>;
 export declare const isCanonicalSessionId: (value: string) => boolean;
@@ -71,6 +74,14 @@ export interface SessionLifecycleLaunchRequest {
     sessionIdentity?: SessionLifecycleTranscriptIdentity;
     /** Broker-issued effect marker which the child echoes only after host readiness. */
     effectMarker?: string;
+    /**
+     * Explicit `provider/model` pin with `gjc --model` grammar (#4707). The
+     * coordinator resolves it before the broker; the session host applies it
+     * exactly like a CLI `--model` selection, so it wins over `modelPreset`
+     * (mirroring CLI precedence where an explicit `--model` overrides
+     * activated profiles).
+     */
+    modelId?: string;
     modelPreset?: string;
     mcpServers?: SessionLifecycleMcpServer[];
     worktree?: SessionLifecycleWorktreeTarget;
@@ -94,6 +105,11 @@ export declare function sdkSessionCommandOverrideForTest(): {
     file: string;
     args: string[];
 } | undefined;
+type EffectMarker = {
+    pid: number;
+    effectMarker: string;
+    incarnation: string;
+};
 type BrokerIndex = Pick<Broker, "index">;
 export declare function setProcessIncarnationForTest(broker: Broker, value: ((pid: number) => string | undefined) | undefined): void;
 type ProcessObservation = "alive" | "exited" | "uncertain";
@@ -105,13 +121,52 @@ export interface LifecycleTranscriptEvidence {
     digest: string;
     identity: SessionLifecycleTranscriptIdentity;
 }
-/** The child writes bounded startup diagnostics before exiting without readiness. */
-export declare function writeSessionLifecycleFailure(root: string, id: string, effectMarker: string, failure: SdkStartupFailure, rollback: SdkStartupRollbackResult, transcript?: LifecycleTranscriptEvidence, ownerIncarnation?: string): Promise<void>;
+/** Writes bounded startup diagnostics. The child stamps its own pid; the broker may stamp a proven child identity. */
+export declare function writeSessionLifecycleFailure(root: string, id: string, effectMarker: string, failure: SdkStartupFailure, rollback: SdkStartupRollbackResult, transcript?: LifecycleTranscriptEvidence, ownerIncarnation?: string, ownerPid?: number): Promise<void>;
 export declare function readSessionLifecycleFailureForTest(root: string, id: string, expected: {
     pid: number;
     effectMarker: string;
     incarnation: string;
 }): Promise<SdkStartupFailure | undefined>;
+/**
+ * Typed ready-then-exit probe for a dead child (#4712 review: the earlier
+ * boolean collapsed EACCES/EIO/malformed JSON into "absent", routing the
+ * teardown decision through the secondary authority and finally surfacing as
+ * a false `spawn_failed` claim that the child "exited before registering
+ * readiness" when the real failure was reading the endpoint).
+ *
+ * A host that died hard leaves its endpoint file on disk; a host that tore
+ * down gracefully removed it first. `matched` requires the owned marker +
+ * ready marker chain to still name exactly this child and the endpoint file
+ * to still name the same pid and session. `absent_indexed` means the endpoint
+ * file is gone (ENOENT only) and the broker's own session index recorded a
+ * host registration for exactly this incarnation — the sole permitted
+ * fallback authority. `malformed` and `io_error` are their own fail-closed
+ * outcomes: they feed no teardown decision and assert nothing about the
+ * child process.
+ */
+type ReadyAuthorityProbe = {
+    kind: "matched";
+} | {
+    kind: "absent_indexed";
+} | {
+    kind: "absent_unindexed";
+} | {
+    kind: "not_published";
+} | {
+    kind: "malformed";
+} | {
+    kind: "io_error";
+    code: string;
+};
+/** Test seam for the typed ready-authority probe boundary (#4712 review). */
+export declare function probePublishedReadyAuthorityForTest(root: string, id: string, expected: EffectMarker): Promise<ReadyAuthorityProbe>;
+/**
+ * Test seam for the PID-reuse deletion boundary: a successor launch rewriting
+ * the lifecycle marker must stop the unlink of an endpoint that only matches
+ * by a reused pid (#4712 review).
+ */
+export declare function removeOwnedLifecycleArtifactsForTest(root: string, id: string, expected: EffectMarker): Promise<boolean>;
 export declare function canonicalDeleteLocatorPath(pathname: string): string;
 export interface LifecycleExecutionOutcome {
     response: BrokerResponse;

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

@@ -116,6 +116,21 @@ export declare class SessionIndex {
     constructor(agentDir: string, policy?: RetentionPolicy);
     open(): Promise<this>;
     replay(): Promise<void>;
+    /**
+     * Polling-path refresh (#4689): when both index files carry the exact change
+     * stamp of the last completed locked pass, the in-memory projection is
+     * already current and the locked rescan is skipped entirely — this is what
+     * keeps an idle SessionRouter reconcile (2s cadence) from re-parsing and
+     * re-checksumming the whole index forever. An append committed before the
+     * stat always changes the stamp, so a miss is impossible; a change landing
+     * after the stat is seen on the next poll, the same TOCTOU envelope a
+     * locked read has. A corrupt suffix never takes the fast path: re-scanning
+     * preserves the existing re-diagnosis behavior. Returns true when state was
+     * reloaded. Authority revalidation that needs the strongest available
+     * snapshot inside an already-locked write (append, unregister) keeps using
+     * the exact locked paths.
+     */
+    refreshIfChanged(): Promise<boolean>;
     diagnose(): Promise<SessionIndexDiagnosis>;
     repair(): Promise<SessionIndexRepairResult>;
     refresh(): Promise<void>;

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

@@ -96,6 +96,12 @@ export type ChatDaemonAction = "stop" | "reload";
  * Discord generation 65 / Slack generation 68 fence the off-reconcile-tail
  * initial attachment replay introduced by #4542 so pre-upgrade daemon owners
  * cannot retain the earlier SessionRouter attachment contract.
+ * The Discord 67 / Slack 70 fence covers the SessionRouter idle-poll/change-stamp
+ * rollout (#4689). Both daemons construct a
+ * SessionRouter whose idle tick no longer re-acquires the machine-global
+ * session-index lock every 2s; staleness retirement moved to a 30s sweep and
+ * lease heartbeats no longer force an authority reconcile. A pre-upgrade owner
+ * would retain the old hot polling loop, so replacement is required.
  */
 export declare const CHAT_DAEMON_GENERATIONS: Readonly<Record<ChatDaemonKind, number>>;
 export declare function chatDaemonGeneration(kind: ChatDaemonKind): number;

package/dist/types/sdk/bus/chat-daemon-runtime.d.ts

@@ -51,6 +51,10 @@ export declare class ChatDaemonRuntime {
     }, deps?: ChatDaemonRuntimeDeps);
     start(): Promise<void>;
     transportHealthy(): boolean;
+    /** Reconcile indexed attachments and optionally wait for their replay tails. */
+    reconcile(options?: {
+        waitForReplay?: boolean;
+    }): Promise<void>;
     stop(): Promise<void>;
     /** Adopt an operator-supplied Slack root through the provider's presentation store. */
     bindExistingRoot(request: ChatDaemonCommandBindInput): Promise<ChatDaemonCommandOutcome>;

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

@@ -311,6 +311,14 @@ interface SessionRuntime {
     /** Aborts and fences side turns while notification delivery is disabled. */
     disableEphemeralTurns: () => void;
     waitForGateResolutionQuiescence: () => Promise<void>;
+    /** Awaits durable quiescence of every reconciliation transaction this runtime
+     *  admitted, joining their producers first. Never swallows evidence: producer
+     *  and store rejections are returned in `failures`, and a bounded-deadline
+     *  expiry is returned as `timedOut` (#4743). */
+    drainDurableReconciliation: () => Promise<{
+        timedOut: boolean;
+        failures: unknown[];
+    }>;
     trackGateResolution: <T>(resolution: Promise<T>) => Promise<T>;
     workflowGate?: WorkflowGateEmitter;
     gatePresentations?: PresentationArbiter;