@gajae-code/coding-agent 0.11.0 → 0.11.2

package/CHANGELOG.md

@@ -2,15 +2,74 @@
 
 ## [Unreleased]
 
+## [0.11.2] - 2026-07-19
+
+### Changed
+- Simplified the release CI to a minimal, industry-standard workflow: a version tag builds the native addons and binaries, then publishes to npm and cuts the GitHub Release in one self-contained job graph. Removed the source-SHA re-verification gate, evidence-provenance handshake, and draft/finalize multi-job dance that made every version-bump commit fail CI. The lint/type-check job is now native-free (biome + tsc); runtime doc and SDK-canonicalization checks moved to the test job so they run with a built addon.
+
+### Fixed
+- The Python eval runtime now honors the documented `GJC_*` environment variables instead of silently reading only legacy `PI_*` names. `GJC_PY` (tokens `0`/`bash`, `1`/`py`, `js`, `mix`/`both`) overrides the eval backend allowance with precedence over legacy `PI_PY`/`PI_JS`; `GJC_PYTHON_SKIP_CHECK`, `GJC_PYTHON_IPC_TRACE`, and `GJC_PYTHON_INTEGRATION` are read first with `PI_*` fallback (OR semantics, so either truthy name wins). Operators following `docs/environment-variables.md` and `docs/python-repl.md` who set `GJC_PY=py` previously saw no effect — a silent docs/runtime contract break. Legacy `PI_*` names remain supported for backward compatibility.
+
+### Fixed
+- Team worker launches now receive the validated owning `GJC_SESSION_ID` for sanctioned session-scoped writes while preserving absent identity, fail-closed resolution, and separate spawn provenance (#2597).
+- Managed and explicit session directories now canonicalize benign ancestor symlinks (e.g. macOS `/var -> /private/var`, a symlinked `$HOME` or project directory) to a symlink-free trusted root before the strict owner-only and reparse guards run, so session creation, moves, resume, and writes no longer fail with `reparse_point` / `Unsafe reparse storage path` under a symlinked temp root or home. The native primitive stays strict and continues to reject symlinked components at or below the trusted root.
+- Skill invocation failures now list available skill names so agents can recover from typos without a blind retry loop.
+- Workflow state receipts now use canonical session-layout paths, require resolved session identity, and report a `state_path` that matches native write/clear output (#2393).
+- Coordinator MCP operational calls now canonically bootstrap or reuse the agent-global SDK broker when discovery is absent or stale, while coordinator/hermes JSON checks report catalog and broker-discovery readiness separately without mutating broker state (#2552).
+- Coordinator MCP question polling now requires a session, reconciles pending workflow gates into bounded public questions, diagnostics, and reconciliation state, and submits bound idempotent answers through `workflow.gate_answer` without exposing private gate payloads (#2550).
+- Runtime skill discovery now follows native user config-root precedence: nearest project, canonical `GJC_CONFIG_DIR`/`PI_CONFIG_DIR`/`.gjc` `agent/skills`, configured legacy `<config>/skills`, then historical legacy `~/.gjc/skills`, preserving exact fallback precedence (#2572).
+- Opt-in stalled team-worker continuation now remains default-off (`GJC_TEAM_AUTO_CONTINUE_STALLED_WORKERS=1`) and sends at most two fenced, journaled fixed prompts only to a verified stale worker pane with a matching live claim and sufficient lease; unknown restart state fails closed, with no provider replay, pane lifecycle action, or claim mutation (#2580).
+
+### Fixed
+- SDK host response delivery to a disconnected client no longer escalates a second structured-error send failure into a process-level unhandled rejection; failures stay local to that connection.
+
+### Fixed
+- Repository LSP configuration can no longer define process-affecting server behavior: project files may control declarative matching, activation, and capabilities, but cannot set launch fields, initialization options, or opaque server settings. Trusted canonical user configuration outside the project retains those overrides; project-controlled plugin roots and the quarantined `--plugin-dir` surface cannot inject them. Automatic discovery uses trusted external executables and rejects repository-owned lexical paths as well as symlink-resolved project binaries; status uses the session cwd as its lspmux trust root. `GJC_DISABLE_LSPMUX=1` is the canonical opt-out and `PI_DISABLE_LSPMUX=1` is a supported compatibility alias; either truthy value disables lspmux probing and wrapping.
+- Palette slash commands now run only from an empty composer; drafts are never touched.
+- Aborting a session without an enabled active goal no longer suppresses the first reminder when a goal is activated later; active-goal abort suppression is one-shot, goal-owned, and clears across inactive or replacement-goal transitions (#2436).
+- Palette slash submissions no longer clear or rewrite composer text, cursor state, history, or pending images created while an asynchronous input hook is awaiting; canonical keyboard submission cleanup remains unchanged (#2441).
+- Dead browser-tab recovery now expires descriptors without releasing replacement, revived, or differently owned tabs, while exactly-once teardown closes stale targets and releases browser holds without refcount underflow (#2437).
+- Local-memory Phase 1 no longer processes history from another working directory.
+
+### Added
+- Double-Esc now clears an idle draft after a confirmation hint, saving it to prompt history; from an empty editor it follows the configured tree, branch, or disabled action.
+- Added a searchable command palette with direct action dispatch; slash commands run only from an empty composer, and drafts are never touched.
+- Added deep-interview intent manifests that preserve user-locked artifacts, surfaces, and integrations through Round 0.
+- Added Telegram `/btw <question>` support through the `ephemeral_turn_v1` SDK capability in authorized known private-session topics. It uses current-session context in an isolated side turn without injecting or persisting user or assistant messages in main history, remains available while the main turn is busy, permits two concurrent questions per logical session, and cancels provider work at the 120-second host deadline; `notifications.telegram.btw.enabled` defaults to `true` as the local kill switch.
+- Telegram `/btw` replies now use eligible complete Bot API 10.1 structured Markdown once as `{rich_message:{markdown,skip_entity_detection:true}}`, correlated in the source topic. Tables and math use Telegram Markdown support rather than outgoing native blocks or media; ineligible content and definite rich rejection use correlated HTML, while ambiguous outcomes never retry or fall back and `/rich off` remains HTML-only.
+
+### Fixed
+
+- Sessions running a managed model fallback chain no longer wedge with repeated `Retry failed after N attempts: The object can not be cloned.` after a provider HTTP error whose response carried headers. The live `Headers` instance attached to the provider error was not structured-cloneable, so the managed attempt snapshot replaced the real provider failure with a local `DataCloneError` on every model in the chain — misreporting `Model fallback chain exhausted` and permanently failing every subsequent prompt while the provider kept erroring. Transport facts now retain only plain-record retry signals, and the attempt snapshot degrades gracefully instead of failing the attempt.
+
+### Fixed
+- Active deep-interview sessions now resume automatically after a normal assistant stop while ordinary active interviewing remains eligible, using bounded workflow-state continuation; recovery, leak, stale-state, handoff, and crystallization blocks remain Stop-gate handled.
+
+### Changed
+- Removed deprecated `DiscoverableMCPTool`, `DiscoverableMCPSearchIndex`, and related MCP-only discovery helper exports. Use the unified `DiscoverableTool` discovery APIs; the `mcp.discoveryMode` settings alias remains supported.
+
+### Fixed
+- Connected MCP server instructions now remain untrusted user-role data instead of entering the cached system prompt; hostile file paths, working directories, and workspace-tree metadata are structurally encoded, and volatile project context is removed from durable session history between requests.
+- Restored the strict G002 public-surface quarantine by removing the default README advertisement for the private coordinator MCP runtime.
+
+## [0.11.1] - 2026-07-16
+
+### Fixed
+- Published the Windows Bun workflow-gate durability fix that tolerates unsupported `EPERM` directory `fsync` failures after an already-committed atomic rename; the 0.11.0 package changelog described the fix, but the released artifact did not contain it (#2316).
+
 ## [0.11.0] - 2026-07-15
 
 ### Fixed
+- Discord inbound lease recovery now exposes a deterministic scheduler seam, preserves exponential retry wakeups after transient endpoint lookup failures, and cancels pending recovery exactly on daemon stop instead of relying on wall-clock sleeps in regression coverage.
 - Input-free interactive TTY startup now keeps the TUI reachable when configured model profiles are missing required provider credentials, skips only the blocked profiles, and preserves later `--mpreset` and explicit model/thinking precedence; redirected terminals, input-bearing, resume-continuation, image-only, print/text, and unrelated activation failures remain fail-closed (#2277).
+- Windows Bun runtimes no longer crash while committing the durable workflow-gate store when directory `fsync` reports the unsupported-operation code `EPERM`; unexpected directory-sync failures remain fail-closed.
 - Browser geo settings now propagate coherently across request `Accept-Language`, navigator languages, and `Intl` locale/timezone surfaces; configured managed browsers are isolated by geo/profile posture, concurrent acquisition is serialized, and unset geo preserves Chromium's native locale/timezone instead of injecting a fixed New York profile.
+- Windows startup no longer fails when the platform rejects the workflow-gate store's parent-directory durability sync with `EPERM`; file fsync and atomic replacement remain enforced.
 
 - Cooperative mid-run context maintenance now waits at a cancellation-aware FIFO consumer-drain checkpoint before flushing or rewriting session history. Materialized tool results and steering messages are synchronously canonicalized first; aborted barriers and hook/signal-cancelled compactions settle without rewriting or scheduling a continuation. Promotion, pruning, and compaction each start a clean provider/prompt-cache epoch. Script-aware #2067 unsent-delta accounting remains cache-free and distinct from the lifecycle checkpoint.
 - Classified the cooperative mid-run maintenance driver and token estimator test seams as locked non-public SDK exclusions, restoring deterministic operation-inventory generation and post-merge dev CI coverage.
 - Accepted SDK prompts now deliver correlated `agent_start` and exactly one terminal lifecycle frame directly to the requesting authenticated WebSocket connection while retaining replayable host events. Harness owner observation also waits for every previously accepted frame to finish serial persistence, so message-update storms and polling gaps cannot hide sticky completion evidence (#2169).
+- `/new` now fails closed while owned subagent shutdown is unproven: it preserves the current session identity and shows an actionable cleanup notice. Successful replacement waits for cooperative child cancellation, cancels owner jobs before switching identity, and `/drop` creates the replacement before attempting old-session deletion (#2261).
 
 ### Added
 
@@ -19,15 +78,17 @@
 - Added the standalone `@gajae-code/bridge-client` transport-only v3 SDK package. It exports `SdkClient` and its associated types; `@gajae-code/coding-agent/sdk` remains a compatibility re-export with the exact same class identity. Historical BridgeClient backend protocol, handshake, commands, SSE, and host-control bypass surfaces remain unavailable.
 - Added explicit `--mcp-config <absolute-path>` support for one trusted, tools-only MCP config in top-level standalone sessions without enabling automatic user or project MCP discovery; exact reads reject links and identity changes, and MCP tool-name collisions fail closed.
 - Added additive v3 workflow-gate correlation compatibility surfaces (#2171): explicit Rust workflow-frame readers/registration preserve `workflowGateId` without changing legacy `ActionNeeded`, `ServerMessage`, or `register_ask`; N-API retains `registerAsk` and adds correlated/arbitrated registration and exact unclaimed-retirement APIs. Private presentation leases, routes, claims, receipts, epochs, and endpoint generations remain non-public.
+- Added the versioned, readonly managed session-directory SDK: `SESSION_DIRECTORY_API_VERSION`, `resolveManagedSessionScope`, and `listManagedSessionCandidates` are exported from `@gajae-code/coding-agent/sdk`. The package boundary continues to reject private `session/internal/*` imports. Managed writes use v2 workspace scopes with validated opt-in legacy copy-retain migration (#2177).
 
 ### Changed
+- Explicit fold choices from the user shortcut or extension `setToolsExpanded` now pin a block for its component lifetime, so automatic stamping no longer overwrites them; sessions that never toggle are unchanged.
 
 - Renamed the notifications SDK to the Gajae-Code SDK: `docs/notifications-sdk.md` is now `docs/sdk.md`, `src/notifications/` is now `src/sdk/bus/`, and `src/sdk.ts` is now the `src/sdk/` module directory. Old deep-import specifiers no longer resolve.
 - Moved SDK discovery from `.gjc/state/notifications/` to `.gjc/state/sdk/`. Restart sessions and daemons together when upgrading; the runtime does not dual-scan the old and new directories.
 - Removed the `--mode rpc`, `--mode rpc-ui`, and `--mode bridge` external ingress modes. Machine clients must use the SDK WebSocket interfaces documented in `docs/sdk.md`; no RPC or Bridge compatibility path remains.
 - Documented the current GPT-5.6 Codex and combo profile mappings as product judgments, including the durable `opus-codex` `anthropic/claude-sonnet-5` planner override and `fable-opus-codex` `anthropic/claude-opus-4-8:medium` planner.
 - Resolved the SDK v3 workflow-gate shipping classification (#2171): `workflowGateId` and Q12 diagnostics are additive SDK v3 surfaces, while `action_needed.id` remains the transient, generic `reply.id` authority. `expectedSessionId` omission remains accepted and audited for the entire SDK v3 line; new clients must send it, and mandatory enforcement or removal can occur no earlier than SDK v4 only after at least one full published deprecation release/window with deployed-client notice. Explicit session mismatches fail closed before resolution; mismatched sessions, stale/reissued actions, and unsafe ambiguity never regain authority.
-- Documented release pairing: the `@gajae-code/coding-agent` runtime and `@gajae-code/natives` native addon ship from the same source release at exact matching package versions (currently `0.10.2`), with the native loader version sentinel enforcing the pair. Mixed native/runtime versions are unsupported and cannot claim SDK compatibility.
+- Documented release pairing: the `@gajae-code/coding-agent` runtime and `@gajae-code/natives` native addon ship from the same source release at exact matching package versions, with the native loader version sentinel enforcing the pair. Mixed native/runtime versions are unsupported and cannot claim SDK compatibility.
 ### Fixed
 - Startup continuation now participates in the existing managed fallback and in-flight recovery envelope, preventing a retryable resumed turn from publishing `agent_end`/idle before retry success, exhaustion, cancellation, or startup failure has settled (#2092).
 
@@ -105,6 +166,7 @@
 - Cache-miss diagnostics now separate actionable, diagnostic-only, and provider-side-suspected causes instead of asserting a user-side fix for every miss (#2020). A large, costly miss with no cache reads or writes is reported as a neutral `Cache notice` marked "provider-side suspected / not user-actionable" (with what GJC cannot determine) rather than telling the user to keep a stable prefix; a miss with reads but no writes is reported as diagnostic-only without asserting a single cause; and the "cache write without enough matching reads" warning now only fires when reads actually fail to cover the writes. The existing miss cost summary and the #1929/#1936 pricing/provenance safeguards are unchanged.
 
 ### Fixed
+- `/btw` side questions now start independently while the main answer is still streaming, read only committed conversation state, avoid main-session callbacks/history/IRC-roster mutation, disable silent provider retries, and fail the side request visibly if no provider event arrives within 15 seconds.
 
 - Fixed native-Windows coordinator/runtime compatibility by treating psmux's successful empty `list-sessions` response as an absent server while keeping malformed rows fail-closed, reading process incarnations through a validated PowerShell start-time query, sharing the existing BOM-free encoded PowerShell pane command, preserving multiline SDK prompts behind semantic readiness, and retaining runtime command/turn acknowledgement identity across Windows-equivalent workspace paths (#2145).
 - The coordinator MCP owner-server probe now recognizes tmux ≥3.7's missing-server diagnostic (`error connecting to <socket> (No such file or directory)`) as an absent server. tmux 3.7 changed the wording from the older `no server running on <socket>`, which the coordinator probe did not match — so a brand-new coordinator socket (which never has a server yet) was misclassified `unverifiable` instead of `absent`, and **every** `gjc_delegate_*` / session create failed closed with `coordinator_tmux_owner_server_unverifiable` on tmux ≥3.7. The coordinator and `gjc` harness probes now match the same no-server wordings the other owner-isolation probes already did.

package/dist/types/async/job-manager.d.ts

@@ -59,6 +59,31 @@ export type SubagentRunOutcome = {
 };
 /** Canonical lifecycle of a subagent across pause/resume cycles. */
 export type SubagentLifecycle = "running" | "paused" | "queued" | "completed" | "failed" | "cancelled";
+/** Maximum time allowed to prove owned subagents have stopped before replacement. */
+export declare const OWNER_SUBAGENT_SHUTDOWN_TIMEOUT_MS = 5000;
+export declare class OwnerSubagentShutdownError extends Error {
+    readonly code = "owner_shutdown_in_progress";
+    constructor();
+}
+export interface OwnerSubagentShutdownTarget {
+    subagentId: string;
+    jobId: string | null;
+    source: "record" | "metadata_job";
+}
+export interface OwnerSubagentShutdownLease {
+    ownerId: string;
+    id: string;
+    targets: readonly OwnerSubagentShutdownTarget[];
+}
+export interface OwnerSubagentShutdownProof {
+    ownerId: string;
+    leaseId: string;
+    confirmed: boolean;
+    reason: "confirmed" | "deadline_exceeded" | "missing_terminal_evidence" | "lease_lost";
+    targets: readonly OwnerSubagentShutdownTarget[];
+    terminalIds: readonly string[];
+    unresolvedIds: readonly string[];
+}
 /**
  * Live, executor-owned control handle for a RUNNING subagent. Registered when a
  * subagent run starts and removed on pause/terminal so a paused subagent retains
@@ -106,6 +131,11 @@ export interface ResumeDescriptor {
     ownerId?: string;
     data: unknown;
 }
+/**
+ * In-memory resume runner bound to the session that originally launched a
+ * subagent. Never serialized: process restart drops it so resume fails closed.
+ */
+export type ResumeRunner = (subagentId: string, message?: string, descriptor?: ResumeDescriptor) => string | undefined;
 export interface AsyncJobManagerOptions {
     onJobComplete: (jobId: string, text: string, job?: AsyncJob) => void | Promise<void>;
     maxRunningJobs?: number;
@@ -241,9 +271,16 @@ export declare class AsyncJobManager {
      */
     hasLiveSubagent(subagentId: string, filter?: AsyncJobFilter): boolean;
     /** Install the TaskTool-owned resume runner. Returns the new job id, or undefined on failure. */
-    setResumeRunner(runner: (subagentId: string, message?: string, descriptor?: ResumeDescriptor) => string | undefined): void;
-    registerResumeDescriptor(descriptor: ResumeDescriptor): void;
+    setResumeRunner(runner: ResumeRunner): void;
+    registerResumeDescriptor(descriptor: ResumeDescriptor, runner?: ResumeRunner): void;
     getResumeDescriptor(subagentId: string, filter?: AsyncJobFilter): ResumeDescriptor | undefined;
+    beginOwnerSubagentShutdown(ownerId: string): OwnerSubagentShutdownLease | undefined;
+    runOwnerProducerCleanups(filter?: AsyncJobFilter): void;
+    runOwnerProducerCleanupsStrict(filter?: AsyncJobFilter): void;
+    cancelAndProveOwnerSubagents(lease: OwnerSubagentShutdownLease, options?: {
+        timeoutMs?: number;
+    }): Promise<OwnerSubagentShutdownProof>;
+    finishOwnerSubagentShutdown(lease: OwnerSubagentShutdownLease, outcome: "commit" | "release"): void;
     /** Request a graceful safe-boundary pause of a running subagent. */
     pauseSubagent(subagentId: string, filter?: AsyncJobFilter): {
         ok: boolean;
@@ -298,11 +335,7 @@ export declare class AsyncJobManager {
      * teardown.
      */
     registerOwnerCleanup(ownerId: string, cleanup: () => void): () => void;
-    /**
-     * Run and clear every registered cleanup for the given filter. Idempotent
-     * and error-isolated: a throwing cleanup does not prevent siblings from
-     * running and never escalates to the caller.
-     */
+    /** Run producer cleanups, then perform the legacy destructive subagent purge. */
     runOwnerCleanups(filter?: AsyncJobFilter): void;
     getDeliveryState(filter?: AsyncJobFilter): AsyncJobDeliveryState;
     hasPendingDeliveries(filter?: AsyncJobFilter): boolean;
@@ -315,6 +348,12 @@ export declare class AsyncJobManager {
      * (used by `dispose()` to nuke the manager's state).
      */
     cancelAll(filter?: AsyncJobFilter): void;
+    waitForOwnerInFlightDeliveries(ownerId: string, options?: {
+        timeoutMs?: number;
+    }): Promise<boolean>;
+    cancelAndSettleOwnerJobs(ownerId: string, options?: {
+        timeoutMs?: number;
+    }): Promise<boolean>;
     getLastDisposeDiagnostics(): AsyncJobDisposeDiagnostics;
     waitForAll(): Promise<void>;
     drainDeliveries(options?: {

package/dist/types/cli/config-cli.d.ts

@@ -4,7 +4,7 @@
  * Handles `gjc config <command>` subcommands for managing settings.
  * Uses the settings schema as the source of truth for available settings.
  */
-export type ConfigAction = "list" | "get" | "set" | "reset" | "path" | "init-xdg";
+export type ConfigAction = "list" | "get" | "set" | "reset" | "path" | "doctor" | "init-xdg";
 export interface ConfigCommandArgs {
     action: ConfigAction;
     key?: string;
@@ -20,4 +20,14 @@ export interface ConfigCommandArgs {
  */
 export declare function parseConfigArgs(args: string[]): ConfigCommandArgs | undefined;
 export declare function runConfigCommand(cmd: ConfigCommandArgs): Promise<void>;
+type ConfigDoctorReport = {
+    unknownKeys: string[];
+    invalidValues: Array<{
+        path: string;
+        value: unknown;
+    }>;
+    legacyShapes: string[];
+};
+export declare function inspectConfigFile(configPath: string): Promise<ConfigDoctorReport>;
 export declare function printConfigHelp(): void;
+export {};

package/dist/types/cli/notify-cli.d.ts

@@ -37,6 +37,7 @@ export interface NotifyCommandDeps {
     tokenPrompt?: () => Promise<string>;
     setExitCode?: (code: number) => void;
     exitProcess?: (code: number) => void;
+    valuePrompt?: (label: string, masked: boolean) => Promise<string>;
     /** Optional daemon ownership facts collected by an embedding host. */
     setupPreflight?: TelegramSetupPreflight;
     /** Injectable timers and cancellation for setup pairing. */

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

@@ -1,4 +1,5 @@
 import { type SessionSelectionResult } from "../modes/components/session-selector";
 import { type SessionInfo } from "../session/session-manager";
+export declare function deleteSessionPickerCandidate(sessionPath: string, explicitSessionDir?: string): Promise<void>;
 /** Show the read-only TUI session picker and return the user's consent intent. */
-export declare function selectSession(sessions: SessionInfo[]): Promise<SessionSelectionResult>;
+export declare function selectSession(sessions: SessionInfo[], explicitSessionDir?: string): Promise<SessionSelectionResult>;

package/dist/types/cli/setup-cli.d.ts

@@ -58,7 +58,7 @@ export declare function runSetupCommand(cmd: SetupCommandArgs): Promise<void>;
  */
 export interface CredentialsSetupDependencies {
     openStore?: typeof SqliteAuthCredentialStore.open;
-    createAuthStorage?: (store: Awaited<ReturnType<typeof SqliteAuthCredentialStore.open>>) => AuthStorage;
+    createAuthStorage?: (store: SqliteAuthCredentialStore) => AuthStorage;
     discover?: Parameters<typeof runExternalCredentialAutoImport>[0]["discover"];
 }
 export declare function handleCredentialsSetup(flags: {

package/dist/types/commands/mcp-serve.d.ts

@@ -1,4 +1,37 @@
 import { Command } from "@gajae-code/utils/cli";
+import { COORDINATOR_MCP_PROTOCOL_VERSION, COORDINATOR_MCP_SERVER_NAME } from "../coordinator/contract";
+import { type BrokerDiscovery } from "../sdk/broker/discovery";
+export type CoordinatorBrokerDiscoveryStatus = "ready" | "unavailable" | "error";
+export type CoordinatorBrokerDiscoveryReason = null | "absent_or_invalid" | "unsupported_state_version" | "discovery_access_denied" | "discovery_read_failed";
+export interface CoordinatorBrokerObservation {
+    discovery_status: CoordinatorBrokerDiscoveryStatus;
+    reason: CoordinatorBrokerDiscoveryReason;
+}
+export interface CoordinatorCheckProbe {
+    agentDir?: string;
+    readBrokerDiscovery?: (agentDir: string) => Promise<BrokerDiscovery | null>;
+}
+export interface CoordinatorCheckPayload {
+    ok: true;
+    server: {
+        name: typeof COORDINATOR_MCP_SERVER_NAME;
+        protocolVersion: typeof COORDINATOR_MCP_PROTOCOL_VERSION;
+    };
+    readOnly: true;
+    tools: readonly string[];
+    catalog: {
+        ready: true;
+        reason: null;
+    };
+    broker: CoordinatorBrokerObservation & {
+        operational_ready: null;
+        bootstrap_supported: true;
+        bootstrap_attempted: false;
+    };
+}
+export declare function probeCoordinatorBrokerCheck(probe?: CoordinatorCheckProbe): Promise<CoordinatorBrokerObservation>;
+export declare function formatCoordinatorCheckPayload(observation: CoordinatorBrokerObservation): CoordinatorCheckPayload;
+export declare function buildCoordinatorCheckPayload(probe?: CoordinatorCheckProbe): Promise<CoordinatorCheckPayload>;
 export declare function validateMcpServeSubcommandForTest(server: string | undefined): void;
 export default class McpServe extends Command {
     static description: string;

package/dist/types/commands/mcp.d.ts

@@ -4,6 +4,7 @@
 import { Command } from "@gajae-code/utils/cli";
 import { type MCPAction } from "../cli/mcp-cli";
 export default class MCP extends Command {
+    #private;
     static description: string;
     static delegateHelp: boolean;
     static examples: string[];
@@ -66,5 +67,4 @@ export default class MCP extends Command {
         };
     };
     run(): Promise<void>;
-    private printHelp;
 }

package/dist/types/commands/notify.d.ts

@@ -2,14 +2,12 @@
  * Configure Telegram, Discord, or Slack notifications.
  */
 import { Command } from "@gajae-code/utils/cli";
-import { type NotifyAction } from "../cli/notify-cli";
 export default class Notify extends Command {
     static description: string;
     static args: {
         action: import("@gajae-code/utils/cli").ArgDescriptor & {
             description: string;
             required: false;
-            options: NotifyAction[];
         };
         extra: import("@gajae-code/utils/cli").ArgDescriptor & {
             description: string;

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

@@ -2,7 +2,7 @@ import { Command } from "@gajae-code/utils/cli";
 import type { Args as ParsedArgs } from "../cli/args";
 import { type SessionLifecycleLaunchRequest } from "../sdk/broker/lifecycle";
 import { SessionManager } from "../session/session-manager";
-export declare function lifecycleArgs(request: SessionLifecycleLaunchRequest, cwd: string, agentDir: string): ParsedArgs;
+export declare function lifecycleArgs(request: SessionLifecycleLaunchRequest, cwd: string, agentDir: string): Promise<ParsedArgs>;
 /** Opens lifecycle-authorized history without letting replacement content reach readiness. */
 export declare function openLifecycleSessionManager(request: SessionLifecycleLaunchRequest, cwd: string, agentDir: string): Promise<{
     parsed: ParsedArgs;

package/dist/types/config/atomic-yaml-patch.d.ts

@@ -1,13 +1,27 @@
+export interface AtomicYamlExpectedPrecondition {
+    path: string;
+    hash: string;
+}
 export interface AtomicYamlSetPatch {
     path: string;
     op: "set";
     value: unknown;
+    expected?: AtomicYamlExpectedPrecondition;
 }
 export interface AtomicYamlUnsetPatch {
     path: string;
     op: "unset";
+    expected?: AtomicYamlExpectedPrecondition;
 }
 export type AtomicYamlPatch = AtomicYamlSetPatch | AtomicYamlUnsetPatch;
+/** Raised when a compare-and-swap precondition no longer matches durable YAML. */
+export declare class AtomicYamlConflictError extends Error {
+    readonly path: string;
+    readonly expectedHash: string;
+    readonly actualHash: string;
+    readonly code = "ATOMIC_YAML_CONFLICT";
+    constructor(path: string, expectedHash: string, actualHash: string);
+}
 export interface AtomicYamlPatchRevision {
     path: string;
     beforeHash: string;
@@ -45,6 +59,8 @@ export interface AtomicYamlPatchOptions {
     sleep?: (ms: number) => Promise<void>;
     /** Test seam for Windows rename retry behavior. */
     platform?: NodeJS.Platform;
+    /** Called under the config lock before patches are applied. */
+    validateRoot?: (root: unknown, patches: readonly AtomicYamlPatch[]) => void | Promise<void>;
     /** Called under the config lock after a successful CAS restore. */
     onRestored?: (patches: readonly AtomicYamlPatch[]) => void | Promise<void>;
 }
@@ -60,6 +76,8 @@ export declare class AtomicYamlReplaceError extends Error {
 export declare function setByPath(value: Record<string, unknown>, segments: readonly string[], nextValue: unknown): void;
 /** Delete a dotted YAML path without disturbing sibling keys or parent objects. */
 export declare function deleteByPath(value: Record<string, unknown>, segments: readonly string[]): void;
+/** Hash a dotted YAML path state for an expected-hash patch precondition. */
+export declare function atomicYamlPathHash(value: Record<string, unknown>, path: string): string;
 /** Build patches from current durable YAML while holding the shared queue and file lock. */
 export declare function applyAtomicYamlPatchesWithCurrent(configPath: string, buildPatches: (current: Readonly<Record<string, unknown>>) => Promise<readonly AtomicYamlPatch[]> | readonly AtomicYamlPatch[], options?: AtomicYamlPatchOptions): Promise<CasReceipt>;
 /**

package/dist/types/config/file-lock.d.ts

@@ -3,14 +3,18 @@ export interface FileLockOptions {
     retries?: number;
     retryDelayMs?: number;
 }
+/**
+ * Returns the OS-provided process start timestamp for PID-reuse detection.
+ * `ps` is available on the supported Unix hosts (macOS and Linux), unlike
+ * Linux's `/proc/<pid>/stat` pseudo-file.
+ */
+export declare function processStartTime(pid: number): string | null;
 /** @internal */
-export declare function readFileLockInfoForGc(lockDir: string): Promise<{
-    pid: number;
-    timestamp: number;
-} | null>;
+export declare function readFileLockInfoForGc(lockDir: string): Promise<FileLockOwnerToken | null>;
 /** Owner identity stamped into a `<file>.lock/info` record. */
 export interface FileLockOwnerToken {
     pid: number;
+    start_time?: string;
     timestamp: number;
 }
 /** Outcome of a guarded lock-dir removal attempt (`removeFileLockDirForGc`). */
@@ -33,4 +37,10 @@ export type FileLockGcRemoval = "removed" | "owner_changed" | "missing";
  * but the reclaim-after-stale scenario the issue describes is now guarded.
  */
 export declare function removeFileLockDirForGc(lockDir: string, expected: FileLockOwnerToken): Promise<FileLockGcRemoval>;
+/**
+ * Serializes all contenders, including callers in the same process. Because this
+ * API exposes no ownership token, recursive acquisition is indistinguishable
+ * from independent async contention; code that already holds the lock must pass
+ * that fact through its own `lockHeld` path instead of acquiring it again.
+ */
 export declare function withFileLock<T>(filePath: string, fn: () => Promise<T>, options?: FileLockOptions): Promise<T>;

package/dist/types/config/keybindings.d.ts

@@ -29,6 +29,7 @@ interface AppKeybindings {
     "app.session.fork": true;
     "app.session.resume": true;
     "app.session.observe": true;
+    "app.session.dashboard": true;
     "app.jobs.open": true;
     "app.session.togglePath": true;
     "app.session.toggleSort": true;
@@ -41,6 +42,13 @@ interface AppKeybindings {
     "app.history.search": true;
     "app.stt.toggle": true;
     "app.irc.sidebar.toggle": true;
+    "app.transcript.browse": true;
+    "app.transcript.prevTurn": true;
+    "app.transcript.nextTurn": true;
+    "app.mode.cycle": true;
+    "app.tasks.toggle": true;
+    "app.queue.togglePane": true;
+    "app.message.sendNow": true;
 }
 export type AppKeybinding = keyof AppKeybindings;
 declare module "@gajae-code/tui" {
@@ -48,6 +56,7 @@ declare module "@gajae-code/tui" {
     }
 }
 export declare function defaultMessageQueueKeysForPlatform(platform?: NodeJS.Platform): KeyId;
+export declare function defaultClipboardPasteImageKeysForPlatform(platform?: NodeJS.Platform): KeyId;
 /**
  * All keybindings definitions: TUI + app-specific.
  */
@@ -249,7 +258,7 @@ export declare const KEYBINDINGS: {
         readonly description: "Select queued message to edit";
     };
     readonly "app.clipboard.pasteImage": {
-        readonly defaultKeys: "alt+v" | "ctrl+v";
+        readonly defaultKeys: KeyId;
         readonly description: "Paste image from clipboard";
     };
     readonly "app.clipboard.copyLine": {
@@ -280,6 +289,10 @@ export declare const KEYBINDINGS: {
         readonly defaultKeys: "ctrl+s";
         readonly description: "Observe subagent sessions";
     };
+    readonly "app.session.dashboard": {
+        readonly defaultKeys: [];
+        readonly description: "Show all persisted sessions dashboard";
+    };
     readonly "app.jobs.open": {
         readonly defaultKeys: "alt+j";
         readonly description: "Open monitor/cron jobs overlay";
@@ -328,6 +341,34 @@ export declare const KEYBINDINGS: {
         readonly defaultKeys: "alt+i";
         readonly description: "Toggle IRC sidebar";
     };
+    readonly "app.transcript.browse": {
+        readonly defaultKeys: [];
+        readonly description: "Browse the transcript";
+    };
+    readonly "app.transcript.prevTurn": {
+        readonly defaultKeys: [];
+        readonly description: "Jump to previous user turn";
+    };
+    readonly "app.transcript.nextTurn": {
+        readonly defaultKeys: [];
+        readonly description: "Jump to next user turn";
+    };
+    readonly "app.mode.cycle": {
+        readonly defaultKeys: [];
+        readonly description: "Cycle interaction mode";
+    };
+    readonly "app.tasks.toggle": {
+        readonly defaultKeys: "alt+t";
+        readonly description: "Toggle tasks pane";
+    };
+    readonly "app.queue.togglePane": {
+        readonly defaultKeys: [];
+        readonly description: "Toggle message queue pane";
+    };
+    readonly "app.message.sendNow": {
+        readonly defaultKeys: [];
+        readonly description: "Send message immediately";
+    };
 };
 declare function migrateKeybindingsConfigFile(agentDir: string): void;
 /**

package/dist/types/config/model-auth.d.ts

@@ -0,0 +1,3 @@
+export declare const kNoAuth = "N/A";
+export declare function isAuthenticated(apiKey: string | undefined | null): apiKey is string;
+export declare function isAuthenticatedOrKeyless(apiKey: string | undefined | null): boolean;

package/dist/types/config/model-bindings-applier.d.ts

@@ -0,0 +1,13 @@
+import { type ModelSelectorValue } from "./model-selector-value";
+import type { Settings } from "./settings";
+export interface ConfiguredModelBindings {
+    modelRoles?: Record<string, ModelSelectorValue>;
+    agentModelOverrides?: Record<string, ModelSelectorValue>;
+}
+/** Synchronizes config-owned model bindings while preserving user edits. */
+export declare class ModelBindingsApplier {
+    #private;
+    setBindings(bindings: ConfiguredModelBindings | undefined): void;
+    applyTo(targetSettings: Settings): void;
+    apply(): void;
+}

package/dist/types/config/model-discovery-manager.d.ts

@@ -0,0 +1,49 @@
+import { type Api, type Model, type ModelRefreshStrategy } from "@gajae-code/ai";
+export interface DiscoveryProvider {
+    provider: string;
+    optional?: boolean;
+}
+export type ProviderDiscoveryStatus = "idle" | "ok" | "empty" | "cached" | "unavailable" | "unauthenticated";
+export interface ProviderDiscoveryState {
+    provider: string;
+    status: ProviderDiscoveryStatus;
+    optional: boolean;
+    stale: boolean;
+    fetchedAt?: number;
+    models: string[];
+    error?: string;
+}
+export interface DiscoveryRefreshToken {
+    provider: string;
+    generation: number;
+}
+/** A generation-guarded, immutable result for the registry to merge into its catalog. */
+export interface DiscoveryMergeInput {
+    provider: string;
+    token: DiscoveryRefreshToken;
+    current: boolean;
+    models: readonly Model<Api>[];
+    state: ProviderDiscoveryState;
+    warning?: string;
+}
+export interface ProviderDiscoveryCallbacks<TProvider extends DiscoveryProvider> {
+    cacheDbPath?: string;
+    requiresAuth: (provider: TProvider) => boolean;
+    peekApiKey: (provider: TProvider) => Promise<string | undefined>;
+    isAuthenticated: (apiKey: string | undefined) => boolean;
+    fetchModels: (provider: TProvider) => Promise<Model<Api>[]>;
+}
+/** Owns configured discovery inputs, status, cache lifecycle, and refresh generations. */
+export declare class ModelDiscoveryManager<TProvider extends DiscoveryProvider> {
+    #private;
+    reset(): void;
+    setProviders(providers: readonly TProvider[]): void;
+    addProvider(provider: TProvider): void;
+    get providers(): readonly TProvider[];
+    providerIds(): Set<string>;
+    getState(provider: string): ProviderDiscoveryState | undefined;
+    loadCached(provider: TProvider, cacheDbPath?: string): readonly Model<Api>[];
+    beginRefresh(provider: string): DiscoveryRefreshToken;
+    isCurrent(token: DiscoveryRefreshToken): boolean;
+    discover(provider: TProvider, strategy: ModelRefreshStrategy, callbacks: ProviderDiscoveryCallbacks<TProvider>): Promise<DiscoveryMergeInput>;
+}

package/dist/types/config/model-equivalence.d.ts

@@ -21,4 +21,24 @@ export interface CanonicalModelIndex {
     bySelector: Map<string, string>;
 }
 export declare function formatCanonicalVariantSelector(model: Model<Api>): string;
+/**
+ * Compare equivalent provider variants using the caller's ranking policy.
+ *
+ * The ordered criteria intentionally mirror the historical canonical resolver:
+ * vision support, configured provider rank, canonical exactness, canonical
+ * source, input plus cache-read cost, and original catalog order. Callers that
+ * do not have a canonical index can omit those axes while retaining a stable,
+ * total comparison.
+ */
+export declare function compareEquivalentModelVariants(left: Model<Api>, right: Model<Api>, options?: {
+    providerRank?: ReadonlyMap<string, number>;
+    canonicalId?: string;
+    leftSourceRank?: number;
+    rightSourceRank?: number;
+    modelOrder?: ReadonlyMap<string, number>;
+    includeCost?: boolean;
+    finalize?: boolean;
+}): number;
+/** @deprecated Use compareEquivalentModelVariants for total variant ranking. */
+export declare function compareModelVariantRank(left: Model<Api>, right: Model<Api>): number;
 export declare function buildCanonicalModelIndex(models: readonly Model<Api>[], equivalence?: ModelEquivalenceConfig): CanonicalModelIndex;