@gajae-code/coding-agent 0.16.7 → 0.17.1

package/dist/types/extensibility/plugins/marketplace/source-resolver.d.ts

@@ -8,7 +8,7 @@
  *   - { source: "git-subdir", url: "...", path: "sub/dir" } → git clone + subdir
  *   - { source: "npm", ... } → not yet supported
  */
-import type { MarketplaceCatalogMetadata, MarketplacePluginEntry } from "./types";
+import type { MarketplaceCatalogMetadata, MarketplacePluginEntry, PluginSource } from "./types";
 export interface ResolveContext {
     /** Absolute path to the cloned/local marketplace directory. Required for relative sources. */
     marketplaceClonePath?: string;
@@ -17,6 +17,21 @@ export interface ResolveContext {
     /** Scratch directory for sources that require cloning or extraction. */
     tmpDir: string;
 }
+export declare function sourcePin(source: PluginSource): {
+    ref?: string;
+    sha?: string;
+    immutable: boolean;
+};
+export declare function assertPinnedSource(source: PluginSource): void;
+/**
+ * Independently verify that a resolved git checkout's HEAD matches the pinned
+ * SHA the plan/token claims to restore. `git.clone` already checks out the
+ * exact SHA, but this re-derives the fact from the checkout itself (a fresh
+ * `rev-parse HEAD` in the resolved directory) rather than trusting whatever
+ * the resolver returned, so a resolver bug or a swapped working tree cannot
+ * silently mismatch source and to-be-published bytes.
+ */
+export declare function verifyResolvedProvenance(resolvedDir: string, expectedSha: string): Promise<boolean>;
 /**
  * Resolve a plugin source to an absolute local directory path.
  *

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

@@ -1,6 +1,8 @@
 import type { SkillsSettings } from "../config/settings-schema";
 import { type Skill } from "./skills";
-export type RuntimeSkillDiscoverySource = "project" | "user";
+export type RuntimeSkillDiscoverySource = "project" | "user" | "bundled";
+/** Search requests cover filesystem scopes; bundled is only a candidate source. */
+type RuntimeSkillDiscoveryScope = Exclude<RuntimeSkillDiscoverySource, "bundled">;
 export interface RuntimeSkillDiscoveryCandidate {
     name: string;
     description: string;
@@ -19,6 +21,8 @@ export interface RuntimeSkillDiscoveryDiagnostics {
 }
 export interface RuntimeSkillDiscoveryResult {
     candidates: RuntimeSkillDiscoveryCandidate[];
+    /** Deduped skill metadata the query filter ran against, including bundled entries; candidates.length <= scanned. */
+    scanned: number;
     diagnostics: RuntimeSkillDiscoveryDiagnostics;
 }
 export interface DiscoverRuntimeSkillsOptions {
@@ -29,7 +33,7 @@ export interface DiscoverRuntimeSkillsOptions {
     profileAuthority?: "default" | "custom";
     query?: string;
     limit?: number;
-    source?: RuntimeSkillDiscoverySource | "all";
+    source?: RuntimeSkillDiscoveryScope | "all";
     policy?: SkillsSettings;
 }
 /**
@@ -39,6 +43,15 @@ export interface DiscoverRuntimeSkillsOptions {
  * aliases map onto the same effective values. Shared by the skill_discovery
  * tool and `gjc skills discover`.
  */
-export declare function describeDisabledSkillScopes(source: RuntimeSkillDiscoverySource | "all", policy: SkillsSettings | undefined): string | undefined;
+export declare function describeDisabledSkillScopes(source: RuntimeSkillDiscoveryScope | "all", policy: SkillsSettings | undefined): string | undefined;
+/**
+ * Explain a zero-candidate result caused by the conjunctive query filter rather
+ * than by an empty catalog or disabled scopes: every whitespace-separated term
+ * must appear in a candidate's name, description, source, or use conditions (or
+ * one term must equal the exact skill name), so a single keyword that appears
+ * nowhere drops every skill. Shared by the skill_discovery tool.
+ */
+export declare function describeNoSkillMatch(query: string | undefined, scanned: number): string | undefined;
 export declare function discoverRuntimeSkills(options: DiscoverRuntimeSkillsOptions): Promise<RuntimeSkillDiscoveryResult>;
 export declare function findRuntimeSkillByName(cwd: string, name: string, policy?: SkillsSettings, home?: string, agentDir?: string, profileAuthority?: "default" | "custom"): Promise<Skill | undefined>;
+export {};

package/dist/types/gjc-runtime/autoresearch-runtime.d.ts

@@ -169,6 +169,12 @@ export declare function autoresearchIssueVerdict(input: {
     slug?: string;
     sessionId?: string | null;
 }): Promise<AutoresearchVerdictReceipt>;
+/**
+ * A help request is `--help`/`-h` anywhere in the argv, or a leading `help`
+ * verb. Exported so the CLI command class routes help back through this
+ * runtime instead of a generic command-level fallback.
+ */
+export declare function isAutoresearchHelpInvocation(args: readonly string[]): boolean;
 export declare function runNativeAutoresearchCommand(args: string[], cwd?: string): Promise<AutoresearchCommandResult>;
 /**
  * Rebuilt autoresearch capability surface. Each capability is reachable from

package/dist/types/gjc-runtime/launch-worktree.d.ts

@@ -52,6 +52,59 @@ export declare function parseLaunchWorktreeMode(args: string[]): ParsedLaunchWor
 export declare function planLaunchWorktree(cwd: string, mode: GjcLaunchWorktreeMode): GjcLaunchWorktreePlan | {
     enabled: false;
 };
+/**
+ * Whether an existing worktree target can be materialized in place. An empty directory,
+ * or one holding nothing but a pre-seeded {@link PRE_WORKTREE_GJC_DIR}, is safe to replace;
+ * anything else is a genuine `worktree_path_conflict`. A missing path is trivially usable.
+ *
+ * A symlinked target is never replaceable: evacuation and overlay writes would follow the
+ * link out of the worktree bucket, so it is reported as a conflict instead.
+ */
+export declare function isReplaceableWorktreeTarget(worktreePath: string): boolean;
+/**
+ * Restore a stashed pre-seeded `.gjc/` into `worktreePath`.
+ *
+ * `git worktree add` materializes any tracked `.gjc/**` content (e.g. `.gjc/qa/**`) into the
+ * fresh worktree before this runs, so a bare rename would collide with EEXIST. When the target
+ * already exists, the stashed launcher config is overlaid onto it — stash entries win on name
+ * collision, tracked-only entries survive — and the stash is removed. When it does not exist
+ * (the untracked case, or a rolled-back add that never checked out), the stash is renamed in.
+ */
+export declare function restorePreWorktreeGjc(gjcStash: string, worktreePath: string): void;
+/**
+ * Handle returned by {@link evacuatePreWorktreeTarget}: a hook that restores the pre-seeded
+ * `.gjc/` into the freshly created worktree, plus the sibling stash path it was moved to
+ * (`null` when there was nothing to preserve). The stash path lets a failed restore report
+ * where the pre-seeded config can be recovered by hand.
+ */
+export interface EvacuationHandle {
+    restore: () => void;
+    stashPath: string | null;
+}
+/**
+ * Clear a {@link isReplaceableWorktreeTarget replaceable} target so `git worktree add` can
+ * create it, moving any pre-seeded `.gjc/` to a sibling stash. Returns a hook that restores
+ * `.gjc/` into the freshly created worktree; a no-op when there was nothing to preserve.
+ */
+export declare function evacuatePreWorktreeTarget(worktreePath: string): EvacuationHandle;
+/**
+ * Finalize the pre-seeded `.gjc/` overlay after a successful `git worktree add`, transactionally.
+ *
+ * `git worktree add` has already registered and materialized the worktree by the time this runs,
+ * so a restore/overlay failure cannot simply propagate: the half-prepared worktree would be
+ * reused verbatim on the next launch (never restored, stash stranded). On failure this rolls the
+ * newly created worktree back so a retry starts clean, preserves the stash for manual recovery,
+ * and throws — success is never reported when restoration did not complete.
+ */
+export declare function commitPreWorktreeRestore(handle: EvacuationHandle, plan: GjcLaunchWorktreePlan): void;
+/**
+ * Acquire a per-target filesystem lock so the replaceability check, evacuation, `git worktree
+ * add`, and restore run as one critical section. Without it a second launcher racing on the same
+ * target could add files between the scan and the evacuation, or move `.gjc` first and strand the
+ * partially modified target. The lock is an atomic `O_EXCL` lockfile beside the target (inside the
+ * git-ignored bucket); a concurrent holder fails fast with `worktree_target_locked`.
+ */
+export declare function acquireTargetLock(worktreePath: string): () => void;
 export declare function ensureLaunchWorktree(plan: GjcLaunchWorktreePlan | {
     enabled: false;
 }, options?: LaunchWorktreeAbortOptions): GjcLaunchWorktreeResult | {

package/dist/types/gjc-runtime/session-layout.d.ts

@@ -44,6 +44,14 @@ export declare function sessionAuditDir(cwd: string, gjcSessionId: string): stri
 export declare function sessionReportsDir(cwd: string, gjcSessionId: string): string;
 export declare function sessionLogsDir(cwd: string, gjcSessionId: string): string;
 export declare function sessionRuntimeDir(cwd: string, gjcSessionId: string): string;
+/**
+ * The session-derived runtime-state marker owned by `gjcSessionId` — the marker a session
+ * writes when the process carries no coordinator pin for it, and the one a committed cwd move
+ * relocates. The coordinator pin is a separate path resolved from
+ * `GJC_COORDINATOR_SESSION_STATE_FILE`, so only the sidecar may decide which of the two a
+ * session owns; callers use this for the derived half of that decision.
+ */
+export declare function sessionRuntimeStatePath(cwd: string, gjcSessionId: string): string;
 export declare function sessionIpykernelsDir(cwd: string, gjcSessionId: string): string;
 export declare function sessionIpykernelsArtifactsDir(cwd: string, gjcSessionId: string): string;
 export declare function pythonKernelTranscriptPath(cwd: string, gjcSessionId: string, dirName: string): string;

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

@@ -115,6 +115,16 @@ export declare function sessionStateLockFailureFields(error: unknown): {
     reason?: SessionStateLockUnavailableReason;
     lockPath?: string;
 };
+/**
+ * Whether a failed persist lost only a race and is worth attempting again.
+ *
+ * A coordinator runtime-state update that is dropped on contention is not recoverable by
+ * any later write: the coordinator keeps reporting a stale lifecycle/activity snapshot for
+ * that session until some unrelated event happens to win the lock. Retrying a contention
+ * refusal is therefore repairing a dropped update, not masking a fault — and it is
+ * deliberately limited to the reasons that carry no information about the document.
+ */
+export declare function isRetryableSessionStateLockContention(error: unknown): boolean;
 export declare const PERSIST_FAILURE_WARN_WINDOW_MS = 30000;
 /**
  * Whether a persist failure should be logged at warn level. The first failure for each
@@ -168,6 +178,11 @@ export declare function reclaimStaleSessionStateLock(lockFile: string, quarantin
  * Taking the path, cleaning up a failed write, and releasing are all pathname transitions,
  * so each runs under the transition claim — never the caller's operation, which holds the
  * lock file itself and may run for as long as it needs.
+ *
+ * The acquisition deadline measures LACK OF PROGRESS, not total waiting: see
+ * {@link creditLockHandoffProgress}. A contender behind a queue of peers that are each
+ * taking and releasing the lock normally keeps waiting; one behind a lock that never moves
+ * still refuses promptly.
  */
 export declare function withSessionStateFileLock<T>(stateFile: string, operation: () => Promise<T>): Promise<T>;
 /**

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

@@ -168,6 +168,17 @@ export interface RuntimeStateContext {
     sessionId: string;
     cwd: string;
     sessionFile?: string | null;
+    /**
+     * The marker file THIS context owns.
+     *
+     * `undefined` keeps the process-wide coordinator pin authoritative (falling back to the
+     * session-derived path when this process carries no pin), which is what a top-level
+     * session wants. Naming a path is how a session that is NOT the pinned one — an
+     * in-process role-agent/subagent session sharing the parent's environment — takes
+     * ownership of its own marker instead of reading and writing the parent's (#5473).
+     * `null` means this context has no marker at all and every write is skipped.
+     */
+    stateFile?: string | null;
     /** Optional platform seam for deterministic cross-platform path identity checks. */
     platform?: NodeJS.Platform;
     branch?: string | null;
@@ -229,6 +240,8 @@ export declare function prepareCoordinatorRuntimeStateRescope(input: {
     };
     previousSessionFile?: string | null;
     newSessionFile?: string | null;
+    /** The marker this session owns; `undefined` lets the process pin answer for it. */
+    stateFile?: string | null;
 }): Promise<string>;
 export declare function markCoordinatorRuntimeStateRescopePublishing(context: RuntimeStateContext, previousCwd: string, moveId: string): Promise<void>;
 export declare function clearCoordinatorRuntimeStateRescope(context: RuntimeStateContext, expectedMoveId?: string, previousCwd?: string): Promise<void>;

package/dist/types/gjc-runtime/ultragoal-runtime.d.ts

@@ -458,6 +458,12 @@ export declare class UltragoalReviewBlockerRecursionCapError extends Error {
     constructor(blockedGoalId: string, unresolvedDescents: number, cap?: number);
 }
 export declare function runUltragoalReview(cwd: string, args: readonly string[]): Promise<UltragoalReviewResult>;
+/**
+ * A help request is `--help`/`-h` anywhere in the argv, or a leading `help`
+ * verb. Exported so the CLI command class routes help back through the
+ * verb-aware renderer instead of a generic command-level fallback.
+ */
+export declare function isUltragoalHelpInvocation(args: readonly string[]): boolean;
 export declare function runNativeUltragoalCommand(args: string[], cwd?: string, options?: {
     agentDir?: string;
 }): Promise<UltragoalCommandResult>;

package/dist/types/main.d.ts

@@ -19,6 +19,7 @@ import type { MCPManager } from "./runtime-mcp";
 import { type CreateAgentSessionOptions, type CreateAgentSessionResult, createAgentSession, discoverAuthStorage } from "./sdk";
 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";
 import { runStartupCredentialAutoImportIfNeeded } from "./setup/credential-auto-import";
 import type { LspStartupServerInfo } from "./tools";
 import type { EventBus } from "./utils/event-bus";
@@ -102,7 +103,23 @@ export declare const BARE_RESUME_INTERACTIVE_ERROR = "--resume requires an inter
 /** Resolves only the managed agent root needed for pre-consent picker inventory. */
 export declare function resolveManagedAgentDirForScope(_cwd: string): string;
 export declare const BARE_RESUME_OPEN_ERROR = "Could not open the selected session. Use --resume <id>.";
-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 class SessionForkDeclinedError extends Error {
+    #private;
+    readonly code: "session_fork_declined";
+    constructor(sessionId: string, projectDirectory: string);
+    get sessionId(): string;
+    get projectDirectory(): string;
+}
+export declare class SessionNotFoundError extends Error {
+    #private;
+    readonly code: "session_not_found";
+    constructor(sessionId: string);
+    get sessionId(): string;
+}
+export declare function operatorFacingSessionOpenMessage(value: unknown): string | undefined;
+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>;
 export declare function getChangelogForDisplay(parsed: Args): Promise<string | undefined>;
 export declare function createSessionManager(parsed: Args, cwd: string, activeSettings?: Settings): Promise<SessionManager | undefined>;
 type RunPrintMode = (session: AgentSession, options: PrintModeOptions) => Promise<void>;
@@ -110,6 +127,7 @@ export interface RunRootCommandDependencies {
     createAgentSession?: typeof createAgentSession;
     createSessionManager?: typeof createSessionManager;
     discoverAuthStorage?: typeof discoverAuthStorage;
+    resolveStartupAuthConfig?: typeof resolveStartupAuthConfig;
     runAcpMode?: (options?: {
         agentDir?: string;
     }) => Promise<void>;

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

@@ -2,6 +2,39 @@ import { type Agent, type AgentSideConnection, type AuthenticateRequest, type Au
 import { type AcpProviderRegistration, type AcpReverseConnection, AcpSdkAdapter } from "../../sdk/acp";
 import { type PromptWatchdogClock } from "../../sdk/prompt-watchdog";
 import type { AcpStartupOptions } from "./startup-options";
+/**
+ * Wall-clock ceiling an external ACP client grants a `session/new` before it
+ * abandons the connection (paseo's daemon uses 60s). gjc must return a
+ * `session.create` response — a launched session or a terminal launch error —
+ * inside this window, or the client reports a dead provider while gjc is still
+ * healthily spawning the host. See issue #5565.
+ */
+export declare const ACP_EXTERNAL_CONNECT_TIMEOUT_MS = 60000;
+/**
+ * Readiness budget every ACP session launch requests, independent of MCP.
+ *
+ * Two constraints bound this value:
+ *
+ * 1. Floor — host cold start costs the same whether or not the client declared
+ *    MCP servers, so leaving the MCP-less path on the broker's 10s default made
+ *    it the only ACP launch that failed under ordinary concurrency: a second
+ *    host starting beside the first measurably crosses that deadline, the broker
+ *    reports the launch as `terminal_uncertain`, and an external client surfaces
+ *    a dead provider.
+ * 2. Ceiling — the broker may park a startup in its admission queue for a whole
+ *    readiness budget before the readiness clock even starts, so the ACP adapter
+ *    sizes its client-side wait at `lifecycleStartupBudgetMs(R)` = queue wait +
+ *    readiness = `2·R`, plus caller slack. With R = 30.5s that wait reached ~62s
+ *    — past paseo's 60s connect timeout — so a queued or slow-cold-start launch
+ *    let paseo abandon the connection before gjc could answer `session/new` at
+ *    all (#5565). R must keep `2·R + slack` safely under
+ *    {@link ACP_EXTERNAL_CONNECT_TIMEOUT_MS}.
+ *
+ * 22s satisfies both: comfortably above the ~16s cold starts observed on slow
+ * hosts (and the 10s concurrency floor) while holding the client-side lifecycle
+ * budget near 45s — a ~15s margin under the 60s ceiling.
+ */
+export declare const ACP_SESSION_READINESS_TIMEOUT_MS = 22000;
 type JsonObject = Record<string, unknown>;
 /** Applies ACP's offset cursor after narrowing the broker listing to the requested cwd. */
 export declare function paginateAcpSessions(listed: unknown[], cwd: string | undefined, offset: number, sessionMetadata?: ReadonlyMap<string, {
@@ -62,6 +95,13 @@ export interface TranscriptContinuation {
     field: string;
 }
 export declare function transcriptContinuations(entry: unknown): TranscriptContinuation[];
+/**
+ * Recover a session-scoped preset only when the host's current model carries
+ * the synthetic profile namespace. A plain `modelPreset` value may be the
+ * persisted default and is therefore insufficient to identify an active
+ * profile, especially when attaching through the base ACP provider.
+ */
+export declare function activeModelPresetFromConfig(query: unknown): string | undefined;
 /**
  * Collect every page of `providers.list/active` (Q29, GJC >= 0.12.8) and
  * return the providers with usable stored credentials or credentialless

package/dist/types/modes/components/agent-dashboard.d.ts

@@ -6,6 +6,7 @@ interface AgentDashboardModelContext {
     modelRegistry?: ModelRegistry;
     activeModelPattern?: string;
     defaultModelPattern?: string;
+    credentialSessionId?: string;
 }
 export declare function resolveAgentCreationModel(modelPatterns: string[], modelRegistry: ModelRegistry, settings: Settings | undefined): import("@gajae-code/ai").Model<import("@gajae-code/ai").Api>;
 export declare function updateAgentModelOverride(overrides: Record<string, ModelSelectorValue>, agentName: string, rawValue: string): Record<string, ModelSelectorValue>;

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

@@ -46,6 +46,8 @@ type ModelSelectorViewMode = "presets" | "models" | "smart-routing";
 export declare class ModelSelectorComponent extends Container {
     #private;
     constructor(tui: TUI, _currentModel: Model | undefined, settings: Settings, modelRegistry: ModelRegistry, scopedModels: ReadonlyArray<ScopedModelItem>, onSelect: RoleSelectCallback, onCancel: () => void, options?: {
+        /** Use layout only when mounted outside the viewport-anchor transcript subtree. */
+        renderScope?: "full" | "layout";
         temporaryOnly?: boolean;
         initialSearchInput?: string;
         sessionId?: string;

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

@@ -9,7 +9,7 @@ import type { ExtensionUIContext, ExtensionUIDialogOptions, ExtensionWidgetConte
 import type { CompactOptions } from "../extensibility/extensions/types";
 import { type Skill } from "../extensibility/skills";
 import type { NotificationSessionReconcileResult, NotificationSessionStatus } from "../sdk/bus/session-control";
-import type { AgentSession, AgentSessionEvent, AsyncJobSnapshotItem } from "../session/agent-session";
+import { type AgentSession, type AgentSessionEvent, type AsyncJobSnapshotItem } from "../session/agent-session";
 import type { HistoryStorage } from "../session/history-storage";
 import type { SessionContext, SessionManager } from "../session/session-manager";
 import type { LspStartupServerInfo } from "../tools";

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

@@ -1,3 +1,9 @@
+/**
+ * MCP Configuration File Writer
+ *
+ * Utilities for reading/writing .gjc/mcp.json files at user or project level.
+ */
+import { type NativeExactFileIdentity } from "@gajae-code/natives";
 import { type MCPConfigFile, type MCPServerConfig } from "./types";
 /**
  * Read an MCP config file.
@@ -87,3 +93,44 @@ export declare function readDisabledServers(filePath: string): Promise<string[]>
  * Add or remove a server name from the disabled servers list.
  */
 export declare function setServerDisabled(filePath: string, name: string, disabled: boolean): Promise<void>;
+export interface ExactMcpBooleanUpdate {
+    readonly beforeRaw?: string;
+    readonly beforeIdentity?: NativeExactFileIdentity;
+    readonly beforeValue?: unknown;
+    readonly afterValue: boolean;
+}
+/** Exact-field JSON CAS used by doctor; server names are object keys and may contain dots. */
+export declare function updateMCPBooleanExact(filePath: string, name: string, field: "autoload" | "enabled", value: boolean, expected: {
+    readonly raw: string;
+    readonly identity: NativeExactFileIdentity;
+}): Promise<{
+    beforeValue: unknown;
+    afterValue: boolean;
+    changed: boolean;
+    afterIdentity?: NativeExactFileIdentity;
+}>;
+export type RestoreMCPBooleanResult = {
+    readonly status: "restored";
+} | {
+    readonly status: "conflict";
+} | {
+    readonly status: "failed";
+    readonly reason: string;
+};
+/**
+ * Roll back exactly one `mcpServers.<name>.<field>` token to its captured
+ * `value` (which may be `undefined` to restore an originally-absent field, or
+ * an originally-invalid non-boolean scalar). Binds to the PUBLISHED file's
+ * dev/ino/parent identity captured right after the mutating replace — not the
+ * pre-mutation identity — and to the field's known current (post-mutation)
+ * value, so an unrelated in-place sibling edit made after publication is
+ * preserved rather than reverted by a stale whole-file snapshot. A CAS
+ * precondition mismatch (identity or field drifted) is a `conflict`; any
+ * other unexpected error is reported as `failed` and must never be silently
+ * folded into `conflict`, since only `conflict` means "an independent editor
+ * already resolved this and no action is required".
+ */
+export declare function restoreMCPBooleanExact(filePath: string, name: string, field: "autoload" | "enabled", originalRaw: string, expected: {
+    readonly identity: NativeExactFileIdentity;
+    readonly currentValue: boolean;
+}): Promise<RestoreMCPBooleanResult>;

package/dist/types/runtime-mcp/policy-json-edit.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Lossless JSON policy-field editing for `.gjc/mcp.json`.
+ *
+ * Uses `jsonc-parser`'s AST/edit API instead of `JSON.parse`/`JSON.stringify`
+ * so only the selected `mcpServers.<name>.<field>` token is rewritten. Every
+ * other token in the document (unrelated fields, large
+ * integer literals, `-0`, secrets) survives untouched. `JSON.parse` would
+ * silently normalize those values and collapse duplicate keys to "last one
+ * wins", hiding a real authoring bug — so duplicate keys along the selected
+ * path are rejected instead of being silently resolved.
+ */
+import { type Node } from "jsonc-parser";
+export type McpBooleanField = "autoload" | "enabled";
+export type McpFieldReadResult = {
+    readonly status: "ok";
+    readonly exists: boolean;
+    readonly value: unknown;
+} | {
+    readonly status: "duplicate_key";
+    readonly path: string;
+} | {
+    readonly status: "malformed";
+} | {
+    readonly status: "not_found";
+};
+export type McpFieldWriteResult = {
+    readonly status: "ok";
+    readonly text: string;
+    readonly beforeValue: unknown;
+} | {
+    readonly status: "duplicate_key";
+    readonly path: string;
+} | {
+    readonly status: "malformed";
+} | {
+    readonly status: "not_found";
+};
+/**
+ * Detect a duplicate property name at each level while descending the given
+ * path. Scoped to the selected policy path only — this is not a whole-document
+ * scan; it visits only the objects on the selected path.
+ */
+export declare function findDuplicateKeyAlongPath(root: Node, path: readonly string[]): string | undefined;
+/** Read one selected `mcpServers.<name>.<field>` boolean without collapsing duplicate keys. */
+export declare function readMcpBooleanField(raw: string, serverName: string, field: McpBooleanField): McpFieldReadResult;
+/**
+ * Compute the lossless text after setting `mcpServers.<name>.<field>` to
+ * `value`, or removing it when `value` is `undefined` (used to restore an
+ * originally-absent field). Only the selected token's edit range changes.
+ */
+export declare function writeMcpBooleanField(raw: string, serverName: string, field: McpBooleanField, 
+/**
+ * The new field value. `undefined` removes the key, restoring an
+ * originally-absent field on rollback. A rollback may also need to restore
+ * an originally-invalid non-boolean scalar, so this intentionally accepts
+ * any JSON value rather than only `boolean`.
+ */
+value: unknown): McpFieldWriteResult;
+/** Restore the original token, rather than reserializing its possibly-invalid value. */
+export declare function restoreMcpBooleanField(raw: string, original: string, serverName: string, field: McpBooleanField): McpFieldWriteResult;

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

@@ -0,0 +1,4 @@
+import type { MCPServerConfig } from "./types";
+export type AutoloadStatus = "autoload" | "autoload-off" | "disabled";
+/** 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/types.d.ts

@@ -51,8 +51,8 @@ export interface MCPServerConfigBase {
      * Whether an explicit runtime MCP consumer should connect this server
      * automatically when that consumer starts (default: true). Ordinary
      * standalone `gjc`, `gjc --tmux`, and print-mode sessions honor autoload for
-     * conventional registrations; `autoload: false` keeps a server configured
-     * for on-demand `/mcp` connection. `--no-mcp` opts a session out entirely.
+     * conventional registrations; `autoload: false` keeps a server stored but
+     * unloaded at startup. `--no-mcp` opts a session out entirely.
      */
     autoload?: boolean;
     /** Connection timeout in milliseconds (default: 30000) */

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

@@ -44,6 +44,8 @@ export declare class AcpSdkAdapter {
     #private;
     constructor(options: AcpSdkAdapterOptions);
     static connect(options: AcpSdkAdapterOptions): Promise<AcpSdkAdapter>;
+    /** Authorize provider registration after the host startup origin is known. */
+    authorizeProviderActivation(): void;
     acceptAttachment(attachment: SessionAttachment): void;
     revokeAttachment(attachment: SessionAttachment): void;
     attachmentReady(attachment: SessionAttachment): Promise<void>;
@@ -59,7 +61,9 @@ export declare class AcpSdkAdapter {
     get connectionId(): string | undefined;
     onReconnectFailed(handler: AcpReconnectFailedHandler): () => void;
     onFrame(handler: AcpFrameHandler): () => void;
-    start(): Promise<void>;
+    start(options?: {
+        activateProviders?: boolean;
+    }): Promise<void>;
     close(): Promise<void>;
     prompt(params: JsonObject | string): Promise<unknown>;
     /**

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

@@ -9,6 +9,8 @@ import { type MasterCapabilityVerifier, type SpawnSubstrateFailure, type SpawnSu
 export interface BrokerSettings {
     agentDir: string;
     packageGeneration?: string;
+    /** Published runtime image; tests inject one to model a vanished executable. */
+    runtime?: string;
     port?: number;
     heartbeatTtlMs?: number;
     /** Broker-owned migration policy. Client lifecycle frames cannot select it. */
@@ -23,10 +25,19 @@ export interface BrokerSettings {
     masterOrphanGraceMs?: number;
     /** Host model resolver override for lifecycle tests and embedders. */
     resolveModelPin?: SdkHostModelResolver;
+    /**
+     * Exact restart request this process instance is the authorized successor
+     * for. Set only by the real `broker-internal` entry point from its own
+     * `GJC_BROKER_RESTART_REQUEST` environment read — never inferred here from
+     * `process.env` directly, so the value this broker publishes is exactly the
+     * value its launcher decided, with no cast/assumed tag in between.
+     */
+    restartRequestId?: string;
 }
 type ResolvedBrokerSettings = {
     agentDir: string;
     packageGeneration: string;
+    runtime?: string;
     port: number;
     heartbeatTtlMs: number;
     resolveDirectoryMigration: (_cwd: string) => Promise<DirectoryMigrationPolicy>;
@@ -34,6 +45,7 @@ type ResolvedBrokerSettings = {
     spawnSubstrateProvider?: SpawnSubstrateProvider;
     spawnPromptLayer?: SpawnPromptLayer;
     masterOrphanGraceMs: number;
+    restartRequestId?: string;
 };
 export declare function resolveBrokerPackageGeneration(): 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" | "worktree_preparation_timeout" | "dependency_preparation_timeout" | "worktree_in_use" | "incarnation_unavailable" | "close_refused" | "not_found" | "live_session" | "cleanup_pending" | (string & {});
@@ -235,6 +247,42 @@ export interface StartupAdmissionTiming {
     now(): number;
     sleep(ms: number, signal?: AbortSignal): Promise<void>;
 }
+export interface BrokerRestartOwnerIdentity {
+    ownerId: string;
+    generation: string;
+    pid: number;
+    incarnation: string;
+}
+export interface BrokerRestartPrepareOptions extends BrokerRestartOwnerIdentity {
+    requestId: string;
+    deadlineAt: number;
+    drain?: boolean;
+}
+export interface BrokerRestartPrepareResult {
+    lease: string;
+    occupancyEpoch: number;
+    expiresAt: number;
+    requestId: string;
+    owner: BrokerRestartOwnerIdentity;
+}
+export interface BrokerRestartCommitOptions extends BrokerRestartPrepareOptions {
+    lease: string;
+    occupancyEpoch: number;
+}
+export type BrokerRestartResult = {
+    ok: true;
+    result: BrokerRestartPrepareResult | {
+        committed: true;
+    } | {
+        cancelled: true;
+    };
+} | {
+    ok: false;
+    error: {
+        code: string;
+        message: string;
+    };
+};
 export type StartupAdmissionResult<T> = {
     status: "completed";
     admittedAt: number;
@@ -284,6 +332,9 @@ export declare class Broker {
     start(): Promise<BrokerDiscovery>;
     get ownsDiscovery(): boolean;
     get completion(): Promise<void>;
+    prepareRestart(options: BrokerRestartPrepareOptions): Promise<BrokerRestartResult>;
+    commitRestart(options: BrokerRestartCommitOptions): Promise<BrokerRestartResult>;
+    cancelRestart(requestId: string): Promise<BrokerRestartResult>;
     status(): RedactedBrokerDiscovery | null;
     heartbeat(): Promise<void>;
     /** Re-observes provably live session hosts and checkpoints their liveness. */

package/dist/types/sdk/broker/daemon-entry.d.ts

@@ -0,0 +1,39 @@
+import { type BrokerDiscovery } from "./discovery";
+export interface AuthorizedBrokerSuccessorOptions {
+    agentDir: string;
+    requestId: string;
+    deadlineAt: number;
+    packageGeneration: string;
+}
+/** Typed outcome of a successor-launch attempt; never an opaque thrown message. */
+export type AuthorizedBrokerSuccessorResult = {
+    kind: "adopted";
+    discovery: BrokerDiscovery;
+} | {
+    kind: "spawned";
+    discovery: BrokerDiscovery;
+} | {
+    kind: "refused";
+    reason: "deadline_elapsed" | "intent_not_committed" | "spawn_failed" | "spawn_exited_before_publication" | "publication_timeout";
+    detail?: string;
+};
+/**
+ * Launches (or adopts) exactly one authorized successor for `requestId`.
+ *
+ * Holds `withBrokerStartupLock` only around the decision to spawn and the
+ * detached `spawn()` call itself -- never across the successor's own
+ * publication wait. The successor process (`commands/sdk.ts`'s
+ * `broker-internal` branch) acquires that SAME lock during its own startup to
+ * serialize against ordinary concurrent starts; holding it here while
+ * blocking on that child's publication would deadlock the parent against its
+ * own child. The unguarded polling loop below runs strictly after the lock
+ * has been released.
+ */
+export declare function launchAuthorizedBrokerSuccessor(options: AuthorizedBrokerSuccessorOptions): Promise<AuthorizedBrokerSuccessorResult>;
+/**
+ * Positive OS-confirmed absence of the exact prior owner, distinguished from
+ * every merely-inconclusive outcome (permission denial, PID reuse ambiguity,
+ * missing native addon). Never treats a null/changed incarnation read alone as
+ * death proof; only `observeProcessIncarnation`'s `"absent"` status counts.
+ */
+export declare function oldOwnerConfirmedExited(pid: number): boolean;