@gajae-code/coding-agent 0.16.3 → 0.16.4

package/CHANGELOG.md

@@ -2,6 +2,65 @@
 
 ## [Unreleased]
 
+## [0.16.4] - 2026-09-05
+### Added
+
+- Added selectable `astra-lite`, `astra-default`, and `astra-heavy` CODEX presets with `ASTRA-` labels, plus `astra-fable` and `astra-fable-opus` cross-family review combinations. Existing presets and automatic provider recommendations remain unchanged.
+- An interactive `gjc` now shows up inside [Paseo](https://paseo.sh) by itself, controllable from the desktop and mobile apps, instead of only being reachable when Paseo started it. Every terminal session already registered its SDK endpoint with the broker, and GJC's ACP surface already resolves a `live` index entry straight to the running host — a `session/load` attaches to it rather than resuming a second copy — so the only thing missing was telling the Paseo daemon the session exists. That is now done at interactive startup with `paseo import --provider <key> --cwd <cwd> <session-id>`, which makes the terminal session and the Paseo agent the same live session rather than two transcripts. The announcement is gated so it costs nothing when it cannot apply: an absent `$PASEO_HOME/config.json` (default `~/.paseo/config.json`), no enabled GJC ACP provider entry, no `paseo` on PATH, a daemon that is not listening, or a session the broker does not yet report as live each stop it before anything is spawned. The daemon check is a plain socket probe rather than a CLI invocation because the Paseo CLI blocks indefinitely when its daemon is down (measured: no output and no exit after two minutes), and the liveness check exists because importing a not-yet-registered id would make `session/load` fork a second host for a session that is already running. While the daemon is merely not up yet, the probe retries every 30 seconds for approximately ten minutes on unref'd timers, so launching Paseo after the terminal still works; the loaded opt-in can cancel its own pending or active announcement, changes made by another process apply on the next launch, and Paseo's own duplicate-import refusal is read as success. Interactive-only by construction — a `gjc acp` provider process never builds the interactive mode, so an imported session cannot announce itself back. Create-only by construction too: GJC adds an entry and never deletes, archives, or rewrites one, so it can never remove an agent you still wanted. The consequence is yours to manage — every interactive start gets a fresh session id (including `gjc -c`), so each launch adds one row, and ending a session leaves its row listed as `idle` until a send fails with `SDK session attachment is stale` and Paseo marks it `error`; prune with `paseo delete <agent-id>`. Opt-in: the new operator-owned `paseo.autoImport` setting is **off by default**, so a repository cannot enable it and an installation that never asks for it never reads a Paseo file, probes a socket, or spawns the CLI; enable it with `gjc config set paseo.autoImport true` (Settings → Interaction → "Announce Sessions to Paseo"). See [`docs/terminal-app-integrations.md`](../../docs/terminal-app-integrations.md#announcing-interactive-sessions).
+- Corrected a stale claim in [`docs/external-control-readiness.md`](../../docs/external-control-readiness.md): interactive `gjc` sessions *are* broker-registered and *are* listed by ACP clients, and an ACP `session/load` against a live entry attaches to the running host instead of resuming a copy.
+- An externally submitted prompt against a session on the SDK-only host runtime no longer hangs forever after its turn has already finished. That runtime published the lifecycle boundary as a bare `{ type, sessionId }` frame: it computed each ended invocation's `commandId`/`turnId` for durable reconciliation and then discarded them at publication, and it never carried a normalized outcome at all — only the `agent_failed` diagnostic was published per invocation with its correlation. An ACP client matches a terminal against the correlation it was acknowledged under and requires the outcome, so a real `agent_end` was rejected as `acp_prompt_terminal_dropped` / `incomplete_correlation`, `session/prompt` never settled, and the client sat in `working` until the 30-minute prompt deadline (reproduced against Paseo 0.6.1 attached to a live interactive session: the terminal rendered the full answer while Paseo showed the agent `running` indefinitely). An owned `agent_end` is now published once per ended invocation carrying that invocation's correlation and a normalized `stopped` outcome, mirroring the existing `agent_failed` shape. Frames that terminalize nothing are unchanged and stay uncorrelated: `agent_start`, a host-originated run with no owning invocation (autonomous continuation, cron, monitor), and a continuing maintenance checkpoint (`pruned`/`compacted`/`promoted`) — which is published but is deliberately not a terminal boundary, so stamping it would settle a client's prompt mid-turn. The ACP ownership gate is untouched.
+- An ACP client attached to a *live interactive* session now receives the turn it submitted: assistant text, thinking, and tool calls stream as they happen instead of arriving as an empty completed turn. The SDK-only host runtime subscribed to lifecycle and watchdog events only — its two `tool_execution_*` handlers just renewed a deadline watchdog and it never subscribed to `message_update`/`message_end` at all — so it published no agent wire events and an attached client could drive the session and watch the turn settle without receiving a single word of the answer (measured against Paseo 0.6.1: `paseo logs` showed the prompt and nothing else, with `--filter tools` and `--filter text` both reporting no activity). It now streams the same five events the notifications runtime does (`message_update`, `message_end`, `tool_execution_start`/`update`/`end`), built with the same shared `toAgentWireEventPayload` producer so the wire shape cannot drift from what ACP maps. Delivery matches the notifications runtime too: one frame per owning invocation, sent directly to the connection that submitted the turn and carrying that invocation's correlation. It deliberately does **not** go through the session event ring — that ring is bounded by frame count with no byte ceiling, so streaming high-frequency chunks through it would evict the lifecycle events clients depend on (including the `agent_end` that settles their prompt) and would broadcast a turn's content to every authenticated subscriber rather than the one that asked for it. A turn nobody submitted over the SDK (an ordinary terminal prompt, an autonomous continuation, cron, monitor) has no owning connection and streams nothing.
+- `gjc` no longer reports an error at every interactive launch when the Paseo daemon requires a password. `paseo import` refuses with `Cannot connect to daemon ...: Password required`, which the socket probe cannot anticipate because the TCP connect succeeds; that refusal is now read as a quiet skip instead of a failed announcement. GJC has no credential setting and reads no Paseo credential file: `paseo import` runs with the session's own environment, so an exported `PASEO_PASSWORD` is used and an absent one simply skips.
+
+- Status-line settings now include a draft-local spatial custom editor with exact-slot keyboard reordering, hidden-segment palette management, command text configuration, persisted Confirm/Exit semantics, live multi-row preview compatibility, narrow/Unicode rendering, and deterministic visual evidence.
+- Added opt-in `reasoningLanguage: english` guidance for technical work while preserving the user's requested response language; the default remains off.
+
+### Changed
+
+- Interactive assistant `text_delta` presentation now coalesces eligible updates into the latest message projection before the existing TUI frame while preserving ordered event processing, immediate non-text updates, and authoritative final output. Session/transcript replacement and disposal cancel stale presentation; temporary TUI stop/start rearms current live text before the first restarted frame without invalidating live historical image callbacks.
+
+### Fixed
+
+- Credential replacement lookups now propagate the owning request's cancellation through scoped and allowed unscoped retries, preventing aborted turns from continuing OAuth preparation or selecting another key.
+- Removing the committed status-line command segment or clearing its trusted command now cancels the running process and clears stale output; draft-only previews remain side-effect-free.
+- Slack inbound acknowledgment reactions now use bounded, abortable, tracked provider work that drains on shutdown or attachment retirement without delaying accepted turns; rejected or timed-out reactions emit sanitized diagnostics.
+- Task repository bindings now accept explicit `relativeSubdir: "."` as the already-bound worktree root, avoiding unnecessary launch retries while retaining traversal, absolute-path, symlink-escape, and sibling-repository rejection.
+- Blank optional task output schemas now inherit the configured agent/session schema instead of failing successful subagents at completion; malformed nonempty schemas and required-field validation remain fail-closed.
+- The read-URL cache is now bounded (FIFO, 64 keys), so long-lived TUI and SDK-host processes no longer retain every fetched page's full output and image payload for the process lifetime; an evicted entry simply refetches on the next read, and unpersisted sessions sharing a working directory remain isolated by session identity.
+- The insane-search web bridge now kills the engine's whole process group instead of only the `python3` process. `killChild` promised a group kill but the engine was not spawned detached, so when the bridge timeout fired mid-flight (25s default vs the engine's internal 90s playwright budget), `node` and headless `chromium` children survived as orphans. The engine now leads its own POSIX process group and receives group-wide SIGTERM→SIGKILL escalation even when the group leader exits during the grace period, with a direct child-kill fallback on Windows.
+- Contribution-prep outbound artifacts now redact complete AWS credentials, including AKIA/ASIA access-key IDs and SecretAccessKey/SessionToken values in shell-style and escaped JSON forms, while preserving structured output and existing GitHub, Slack, authorization-header, and cookie redaction.
+- Model preset registry URL and disable overrides now resolve only from explicitly inherited or user-owned environment sources, so a checkout `.env` cannot suppress updates or redirect signed-registry polling while dependency injection, HTTPS validation, signatures, ETags, cache, and offline behavior remain unchanged (#5300).
+- OpenCode Go's provider conversation identity now remains distinct from generic cache affinity across normal turns and maintenance calls, so the required session header reuses the session manager's opaque lifecycle without accepting auth-gateway prompt-derived cache keys (#5295).
+- Perplexity web search now clamps upstream search breadth to the API's 3–100 contract, retries one structurally empty completion, rejects malformed or ungrounded success payloads through the provider fallback path, and preserves valid grounded responses.
+- Architect/task subagents now retry API-key lookup without the parent session id after a scoped miss, so broker OAuth that works for `gjc -p --no-session` is not thrown away as `Agent run failed` / 0 tokens (#5081 follow-up). Failures still throw `provider_unavailable` without leaking the token.
+- Python work that completes after strict session disposal now returns its result without attempting to append to the closed session transcript.
+- SDK-hosted workflow tools now retain the logical session id for ask, skill, deep-interview, and ultragoal state paths while job, monitor, bash, cron, task, and subagent ownership routes through a separate opaque async endpoint key. Explicit provider session identities no longer create encoded duplicate workflow trees or redirect endpoint-owned work to another live session.
+- Explicit root startup `--thinking off` and `--thinking=off` now override a configured higher startup default while leaving the provider `Effort` catalog unchanged.
+- Skills installed from marketplace plugins are now enumerated into sessions instead of only resolving by exact name. `loadSkills` asked the `native` provider alone, so every installed plugin skill was absent from `/` autocomplete and from the `skill` tool's `Available:` list while `gjc skill list` reported it and the discovery fallback still loaded it — 46 installed skills presented as 5. The already-registered marketplace provider is now loaded alongside `native`, keeping `<plugin>:<skill>` namespacing and per-item scope trust.
+- File-content search now has a call-wide timeout (`timeout`, default 5 seconds, range 0.5–60) that is forwarded through internal-URL resolution and native grep together with cancellation. Native scans poll cancellation around each bounded file, and the tool joins cancellation cleanup before returning instead of leaving scope resolution, archive scratch, or grep workers running after a timeout. Timeout failures tell callers to narrow the scope or explicitly increase the budget, while user cancellation remains a distinct tool abort.
+- `restart:sdk-broker -- --close-session-hosts` now continues replacing the broker when its pre-restart session-host listing fails, reports the partial teardown with exit code 1, tolerates another authenticated restart caller retiring the same exact broker identity, and catches other top-level failures instead of emitting an unhandled-rejection crash record.
+- `install:dev` now builds the workspace native addon before linking the source CLI, preventing fresh or cleaned development checkouts from failing startup with a missing or stale addon. The installer also supports the local `--dev` binary shortcut.
+- Plain and explicit-model launches now refresh a missing provider's cached dynamic catalog before resolving a qualified startup selector, so configured models such as `glm-zcode/glm-5.3` no longer open in `no-model` state while preserving cache-only startup for already available models.
+- The explicit thinking-choice gate for xAI models now derives from the parsed grok generation (4.5+) shared with `@gajae-code/ai`, instead of the exact ids `grok-4.5`/`grok-4.6`. A future grok release failed the id list, so `supportsReasoningEffort` stayed `false` and the user's thinking level was silently dropped from requests; reseller-hosted grok routes (OpenRouter & co.) keep their existing audited-transport behavior.
+
+- The status-line usage segment now paints only the active model's provider, so switching to Grok no longer keeps a stale Claude 5h/7d pair. Canonical Grok Build reports render only their authoritative weekly window, while monthly credits are omitted instead of being mislabeled as `7d`.
+
+- Bundled plugin MCP launchers now execute Node `.mjs` entrypoints on Linux from startup-authenticated interpreter bytes and a complete copied-file snapshot. Runtime options cannot precede the entrypoint, path-qualified/shebang commands fail closed, unexpected post-install files quarantine the bundle, and canonical registry identity plus the complete copied-file manifest are rebound before every spawn. Runtime captures the interpreter and authenticated bundle files through bounded stable handles into a unique owner-only launch capsule; the Node loader returns authenticated captured module bytes while preserving file-URL relative imports and blocking package/CommonJS/native escapes. Concurrent connections use separate authority. Capsule cleanup failures retain ownership and fence reconnect until cleanup succeeds. Bun, macOS, and Windows bundled stdio launch fail closed pending equivalent loader and owner/process-tree authority; capsules do not provide hostile-same-UID process isolation.
+
+- Moving the `/model` preset cursor now reuses the authentication snapshot produced by catalog and credential refreshes instead of resolving every profile against the full model catalog on each Up/Down keypress; auth-dependent preset actions remain blocked until the initial static refresh and the availability snapshot are complete.
+- Bundled Grok Build models now explicitly declare `reasoning_effort` support only for catalog-supported models, so `grok-build/grok-4.6:xhigh` reaches the Responses request while unsupported Grok models remain fail-closed. (#5264)
+- Mid-run OpenAI remote-compaction fallback failures now stop before another provider request, surface the local summarization error through ACP/SDK terminal handling, and leave the uncompacted context unsubmitted. Successful local fallback still commits the compaction and resumes normally.
+- Opening `/model` now renders the preset landing before constructing the full model browser catalog. Canonical search indexing, sorting, and the redundant offline registry refresh are deferred until the user searches or chooses a browse action, while the lightweight preset-availability check remains immediate and scoped or direct-search selectors still load immediately.
+- Slack lean notifications now publish only finalized assistant answers and actionable states instead of the internal lifecycle, identity, and activity frame stream. Final answer delivery uses the message reference as a durable publication identity, so repeated unpositioned SDK frames no longer post duplicate replies; accepted inbound Slack messages receive a 👀 reaction while GJC awaits the agent's answer.
+- `/model` provider-tab refreshes now reuse the already loaded static catalog and update only the selected provider's discovery state, avoiding repeated signed preset registry work while retaining full-catalog refresh behavior for static configuration changes.
+- Added the `command` status-line segment for user-produced HUD content. It runs
+  configured user/global shell commands in the background with scheduled cached
+  refreshes, bounded timeout/output, ANSI sanitization, placeholder degradation,
+  disposal cancellation, and custom-editor configuration while preserving
+  synchronous TUI rendering; project-scoped settings cannot trigger execution.
+
+- Business/Enterprise/Team ChatGPT accounts can bind GPT-5.6 Sol again. The Codex entitlement preflight treated only `plan_type` values containing `"pro"` as eligible, so an `openai-codex` OAuth account on a Business/Enterprise/Team plan was rejected at model-binding/subagent setup time with a spurious entitlement error even though the backend accepts the request. Exact Pro/Business/Enterprise/Team tiers are now recognized as entitled, Plus/Free remain rejected, and unfamiliar plan names are deferred to the provider rather than guessed locally.
+
 ## [0.16.3] - 2026-09-04
 
 ## [0.16.2] - 2026-09-04

package/dist/types/cli/args.d.ts

@@ -1,4 +1,4 @@
-import { type Effort } from "@gajae-code/ai/core";
+import { type RootThinkingLevel } from "./root-flags";
 export type Mode = "text" | "json" | "acp";
 export type ParseArgsAuthority = "local" | "acp" | "deferred";
 export interface Args {
@@ -21,7 +21,7 @@ export interface Args {
     mcpConfig?: string;
     /** Opt a standalone session out of conventional MCP autoload (mutually exclusive with --mcp-config). */
     noMcp?: boolean;
-    thinking?: Effort;
+    thinking?: RootThinkingLevel;
     continue?: boolean;
     resume?: string | true;
     help?: boolean;

package/dist/types/cli/root-flags.d.ts

@@ -1,4 +1,6 @@
 import { type FlagDescriptor } from "@gajae-code/utils/cli";
+export declare const ROOT_THINKING_LEVELS: readonly ["off", ...import("@gajae-code/ai").Effort[]];
+export type RootThinkingLevel = (typeof ROOT_THINKING_LEVELS)[number];
 /** Public launch flags shared by root help, completion, and the launch command. */
 export declare const ROOT_LAUNCH_FLAGS: {
     model: FlagDescriptor<"string"> & {
@@ -104,7 +106,7 @@ export declare const ROOT_LAUNCH_FLAGS: {
     };
     thinking: FlagDescriptor<"string"> & {
         description: string;
-        options: readonly ["minimal", "low", "medium", "high", "xhigh", "max"];
+        options: readonly ["off", ...import("@gajae-code/ai").Effort[]];
     };
     "no-rules": FlagDescriptor<"boolean"> & {
         description: string;
@@ -239,7 +241,7 @@ export declare const LAUNCH_PARSE_FLAGS: {
     };
     thinking: FlagDescriptor<"string"> & {
         description: string;
-        options: readonly ["minimal", "low", "medium", "high", "xhigh", "max"];
+        options: readonly ["off", ...import("@gajae-code/ai").Effort[]];
     };
     "no-rules": FlagDescriptor<"boolean"> & {
         description: string;

package/dist/types/cli.d.ts

@@ -127,7 +127,7 @@ export declare class RootHelpCommand extends Command {
         };
         thinking: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
             description: string;
-            options: readonly ["minimal", "low", "medium", "high", "xhigh", "max"];
+            options: readonly ["off", ...import("@gajae-code/ai").Effort[]];
         };
         "no-rules": import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
             description: string;

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

@@ -120,7 +120,7 @@ export default class Index extends Command {
         };
         thinking: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
             description: string;
-            options: readonly ["minimal", "low", "medium", "high", "xhigh", "max"];
+            options: readonly ["off", ...import("@gajae-code/ai").Effort[]];
         };
         "no-rules": import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
             description: string;

package/dist/types/config/autorouting-tier-map.d.ts

@@ -781,6 +781,9 @@ export declare const TIER_MAP_SKIP_LIST: {
     readonly "nvidia/upstage/solar-10.7b-instruct": {
         readonly rationale: "post-rebase catalog addition from dev; not yet curated";
     };
+    readonly "openai-codex/gpt-6-astra": {
+        readonly rationale: "GPT-6 Astra catalog addition (2026-09-03 release); not yet curated";
+    };
     readonly "openai-codex/gpt-daybreak-blue-latest": {
         readonly rationale: "post-rebase catalog addition from dev; not yet curated";
     };

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

@@ -368,6 +368,10 @@ export declare class ModelRegistry {
     /**
      * Reload models from disk (embedded + accepted registry + custom from models.yml).
      */
+    refreshStatic(): Promise<void>;
+    /**
+     * Reload models from disk and refresh runtime provider discovery state.
+     */
     refresh(strategy?: ModelRefreshStrategy): Promise<void>;
     refreshInBackground(strategy?: ModelRefreshStrategy): void;
     refreshProvider(providerId: string, strategy?: ModelRefreshStrategy): Promise<void>;

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

@@ -33,6 +33,15 @@ export declare function parseModelString(modelStr: string): {
     id: string;
     thinkingLevel?: ThinkingLevel;
 } | undefined;
+export declare function resolveStartupModelRefreshSelectors(options: {
+    model?: string;
+    provider?: string;
+    credential?: string;
+    continue?: boolean;
+    resume?: string | boolean;
+    hasStartupProfile: boolean;
+}, settings: ModelRoleSettings): ModelSelectorValue | undefined;
+export declare function refreshMissingQualifiedModelProviders(selectors: ModelSelectorValue | undefined, modelRegistry: Pick<ModelRegistry, "getAvailable" | "getDiscoverableProviders" | "refreshProvider">): Promise<boolean>;
 /**
  * Format a model as "provider/modelId" string.
  */

package/dist/types/config/settings-schema.d.ts

@@ -27,7 +27,7 @@ export declare const TAB_METADATA: Record<SettingTab, {
     icon: `tab.${string}`;
 }>;
 /** Status line segment identifiers */
-export type StatusLineSegmentId = "gajae" | "pi" | "model" | "mode" | "path" | "git" | "pr" | "subagents" | "jobs" | "token_in" | "token_out" | "token_total" | "token_rate" | "cost" | "context_pct" | "context_total" | "time_spent" | "time" | "session" | "hostname" | "cache_read" | "cache_write" | "session_name" | "usage";
+export type StatusLineSegmentId = "gajae" | "pi" | "model" | "mode" | "path" | "git" | "pr" | "subagents" | "jobs" | "token_in" | "token_out" | "token_total" | "token_rate" | "cost" | "context_pct" | "context_total" | "time_spent" | "time" | "session" | "hostname" | "cache_read" | "cache_write" | "session_name" | "usage" | "command";
 /** Submenu choice metadata. */
 export type SubmenuOption<V extends string = string> = {
     value: V;
@@ -1306,6 +1306,25 @@ export declare const SETTINGS_SCHEMA: {
             readonly options: readonly import("../thinking-metadata").ThinkingLevelMetadata[];
         };
     };
+    readonly reasoningLanguage: {
+        readonly type: "enum";
+        readonly values: readonly ["off", "english"];
+        readonly default: "off";
+        readonly ui: {
+            readonly tab: "model";
+            readonly label: "Reasoning Language";
+            readonly description: "Optionally reason through development work in English while preserving the user's response language";
+            readonly options: readonly [{
+                readonly value: "off";
+                readonly label: "Off";
+                readonly description: "Do not add reasoning-language guidance";
+            }, {
+                readonly value: "english";
+                readonly label: "English";
+                readonly description: "Reason through technical work in English and answer in the user's language";
+            }];
+        };
+    };
     readonly hideThinkingBlock: {
         readonly type: "boolean";
         readonly default: false;
@@ -1915,6 +1934,15 @@ export declare const SETTINGS_SCHEMA: {
             readonly description: "Show the interactive GitHub star reminder when gh is authenticated";
         };
     };
+    readonly "paseo.autoImport": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "interaction";
+            readonly label: "Announce Sessions to Paseo";
+            readonly description: "Global-only operator opt-in. When enabled, and only when a GJC ACP provider is already registered in Paseo and its daemon is already running, import each interactive session into Paseo so it can be driven from there. Project settings cannot enable it. Never starts the Paseo daemon or removes imported entries; stale entries must be pruned in Paseo. Never runs when Paseo is absent.";
+        };
+    };
     readonly "crashReport.nudge": {
         readonly type: "boolean";
         readonly default: true;

package/dist/types/discovery/claude-plugins.d.ts

@@ -1 +1,3 @@
-export {};
+import { type Skill } from "../capability/skill";
+import type { LoadContext, LoadResult } from "../capability/types";
+export declare function loadMarketplaceSkills(ctx: LoadContext, allowedLevels?: ReadonlySet<"user" | "project">): Promise<LoadResult<Skill>>;

package/dist/types/discovery/helpers.d.ts

@@ -236,6 +236,8 @@ export declare function resolveActiveProjectRegistryPath(cwd: string): Promise<s
  * never alias as the project registry.
  */
 export declare function resolveOrDefaultProjectRegistryPath(cwd: string): Promise<string | undefined>;
+/** Invalidate the exact user/project registry pair and their resolved-root cache entry. */
+export declare function invalidateClaudePluginRoots(home: string, cwd?: string): Promise<void>;
 /**
  * List installed GJC plugin roots from the GJC plugin registry and, when present,
  * the nearest project-scoped registry resolved from `cwd`.

package/dist/types/extensibility/gjc-plugins/mcp-policy.d.ts

@@ -16,6 +16,22 @@ export declare function assertDnsResolvesPublic(hostname: string, label?: string
 export interface StdioPolicyContext {
     pluginRoot: string;
 }
+export interface StdioInvocationTarget {
+    kind: "launcher";
+    launcher: "node" | "bun";
+    entrypoint: string;
+    executablePath: string;
+    ownedRelativePath: string;
+    ownedRelativePaths: string[];
+    cwd: string;
+}
+/**
+ * Resolve the exact executable file selected by the supported stdio grammar.
+ * Bare Node/Bun launchers accept a direct bundled entrypoint as argv[0]; no
+ * manifest-controlled runtime options or subcommands precede it. Path-qualified
+ * commands are unsupported because they bypass the verified module wrapper.
+ */
+export declare function classifyStdioInvocation(entry: GjcPluginMcpManifestEntry, ctx: StdioPolicyContext): StdioInvocationTarget;
 /** stdio launcher/path confinement policy. */
 export declare function assertStdioAllowed(entry: GjcPluginMcpManifestEntry, ctx: StdioPolicyContext): void;
 /**

package/dist/types/extensibility/gjc-plugins/paths.d.ts

@@ -1,5 +1,7 @@
 export declare function gjcPluginUserRoot(): string;
 export declare function gjcPluginProjectRoot(cwd: string): string;
+export declare function gjcPluginSafeDirectoryName(name: string): string;
+export declare function gjcPluginInstallRoot(scope: "user" | "project", cwd: string, name: string): string;
 export declare function rootContainsGjcManifest(dir: string): Promise<boolean>;
 export declare function discoverGjcPluginRoots({ cwd }: {
     cwd: string;

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

@@ -1,5 +1,5 @@
 import type { SkillsSettings } from "../config/settings-schema";
-import type { Skill } from "./skills";
+import { type Skill } from "./skills";
 export type RuntimeSkillDiscoverySource = "project" | "user";
 export interface RuntimeSkillDiscoveryCandidate {
     name: string;

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

@@ -152,7 +152,7 @@ export interface AgentEndEvent {
     sdkRunToken?: string;
     /** Indicates whether the loop ended normally, suspended, cancelled, or entered maintenance. */
     stopReason?: "completed" | "paused" | "cancelled" | "maintenance";
-    /** Present for maintenance checkpoints; non-aborted checkpoints are not terminal. */
+    /** Present for maintenance checkpoints; only committed maintenance outcomes are non-terminal. */
     maintenanceOutcome?: MidRunMaintenanceOutcome;
 }
 /** Fired at the start of each turn */

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

@@ -83,6 +83,8 @@ export declare const SessionStateLockTestHooks: {
     forcedQuarantineName?: string;
     /** @internal Observes bounded acquisition retries without changing their timing. */
     afterAcquireContention?: (lockFile: string, attempt: number, elapsedMs: number) => void;
+    /** @internal Observes process-local admission without altering on-disk ownership. */
+    afterLocalTransitionQueued?: (transitionDir: string) => void;
     /** @internal Runs after transition mkdir contention and before stale-claim inspection. */
     afterTransitionClaimContention?: (transitionDir: string) => void | Promise<void>;
 };

package/dist/types/modes/components/assistant-message.d.ts

@@ -10,10 +10,9 @@ interface AssistantMessageUpdateOptions {
 export declare class AssistantMessageComponent extends Container {
     #private;
     private hideThinkingBlock;
-    private readonly onImageUpdate?;
     private readonly onVisibleMutation?;
     private readonly hintSession?;
-    constructor(message?: AssistantMessage, hideThinkingBlock?: boolean, onImageUpdate?: (() => void) | undefined, viewportAnchorId?: string, onVisibleMutation?: (() => void) | undefined, hintSession?: ProviderSafetyStopHintSession | undefined);
+    constructor(message?: AssistantMessage, hideThinkingBlock?: boolean, onImageUpdate?: () => void, viewportAnchorId?: string, onVisibleMutation?: (() => void) | undefined, hintSession?: ProviderSafetyStopHintSession | undefined);
     invalidate(): void;
     setHideThinkingBlock(hide: boolean): void;
     setToolResultImages(toolCallId: string, images: ImageContent[]): void;

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

@@ -5,7 +5,7 @@ import { type SettingPath } from "../../config/settings";
 import type { StatusLinePreset, StatusLineSegmentId, StatusLineSeparatorStyle } from "../../config/settings-schema";
 import type { GjcRuntimeSnapshotProvider } from "../../extensibility/gjc-plugins/runtime-quarantine";
 import { type NotificationsEditorOperations } from "./notifications-settings-editor";
-import type { StatusLineSegmentOptions } from "./tool-status-header";
+import type { StatusLinePreviewParts, StatusLineSegmentOptions } from "./tool-status-header";
 /**
  * Dynamic context for settings that need runtime data.
  * Some settings (like thinking level) are managed by the session, not Settings.
@@ -42,6 +42,7 @@ export interface StatusLinePreviewSettings {
     separator?: StatusLineSeparatorStyle;
     segmentOptions?: StatusLineSegmentOptions;
     previewHighlightSegment?: StatusLineSegmentId;
+    previewHighlightStyle?: "focus" | "selected";
     sessionAccent?: boolean;
     maxRows?: number;
 }
@@ -70,6 +71,10 @@ export interface SettingsCallbacks {
     onStatusLinePreview?: (settings: StatusLinePreviewSettings) => void;
     /** Get current rendered status line for inline preview */
     getStatusLinePreview?: (width?: number) => string;
+    /** Render a status-line preview for supplied draft settings without mutating the live status line. */
+    getStatusLinePreviewForSettings?: (settings: StatusLinePreviewSettings, width?: number) => string;
+    /** Render status-line segment groups for supplied draft settings without mutating the live status line. */
+    getStatusLinePreviewPartsForSettings?: (settings: StatusLinePreviewSettings, width?: number) => StatusLinePreviewParts;
     /** Called when plugins change */
     onPluginsChanged?: () => void;
     /** Called when asynchronously rebuilt settings content needs a repaint. */

package/dist/types/modes/components/status-line/command.d.ts

@@ -0,0 +1,35 @@
+export declare const STATUS_LINE_COMMAND_DEFAULT_MAX_LENGTH = 80;
+export declare const STATUS_LINE_COMMAND_MAX_LENGTH = 256;
+export interface StatusLineCommandOptions {
+    command?: string;
+    timeoutMs?: number;
+    refreshMs?: number;
+    maxLength?: number;
+}
+export interface ResolvedStatusLineCommandOptions {
+    command: string;
+    timeoutMs: number;
+    refreshMs: number;
+    maxLength: number;
+}
+export interface StatusLineCommandResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    timedOut: boolean;
+    outputTruncated: boolean;
+}
+export declare function normalizeStatusLineCommandOptions(value: unknown): ResolvedStatusLineCommandOptions;
+/**
+ * Run a configured status-line command without making the synchronous render
+ * path wait on it. The streams are drained with a hard byte cap and the whole
+ * process group is killed when the timeout expires.
+ */
+export declare function runStatusLineCommand(command: string, options: {
+    cwd: string;
+    shell: string;
+    shellArgs: readonly string[];
+    env: Record<string, string>;
+    timeoutMs: number;
+    signal?: AbortSignal;
+}): Promise<StatusLineCommandResult>;

package/dist/types/modes/components/status-line/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./command";
 export * from "./presets";
 export * from "./segments";
 export * from "./separators";

package/dist/types/modes/components/status-line/types.d.ts

@@ -57,6 +57,11 @@ export interface SegmentContext {
             resetUnit?: "m" | "h";
         }>;
     } | null;
+    command?: {
+        output: string | null;
+        failed: boolean;
+        pending: boolean;
+    };
 }
 export interface RenderedSegment {
     content: string;

package/dist/types/modes/components/tool-status-header.d.ts

@@ -5,6 +5,8 @@ import type { AgentSession } from "../../session/agent-session";
 import { type SkillActiveEntry } from "../../skill-state/active-state";
 import type { ActionRegistry, FocusDomain } from "../action-registry";
 import { type JobsSnapshot } from "../jobs-observer";
+import { type StatusLineCommandOptions } from "./status-line/command";
+import type { SeparatorDef } from "./status-line/types";
 export interface StatusLineSegmentOptions {
     model?: {
         showThinkingLevel?: boolean;
@@ -28,6 +30,7 @@ export interface StatusLineSegmentOptions {
     usage?: {
         mode?: "used" | "remaining";
     };
+    command?: StatusLineCommandOptions;
 }
 export interface StatusLineSettings {
     preset?: StatusLinePreset;
@@ -36,6 +39,7 @@ export interface StatusLineSettings {
     separator?: StatusLineSeparatorStyle;
     segmentOptions?: StatusLineSegmentOptions;
     previewHighlightSegment?: StatusLineSegmentId;
+    previewHighlightStyle?: "focus" | "selected";
     showHookStatus?: boolean;
     showSkillHud?: boolean;
     showActionHints?: boolean;
@@ -48,11 +52,19 @@ export interface StatusLineComponentOptions {
     getKeybindings?: () => KeybindingsManager;
     focusDomain?: FocusDomain;
     keyDisplayContext?: KeyDisplayContext;
+    onUpdate?: () => void;
 }
 export interface StatusLineActionHint {
     id: AppKeybinding;
     content: string;
 }
+export interface StatusLinePreviewParts {
+    left: string[];
+    leftIds: StatusLineSegmentId[];
+    right: string[];
+    rightIds: (StatusLineSegmentId | null)[];
+    separator: SeparatorDef;
+}
 /**
  * Produces whole, bound action hints for the current focus domain. The registry
  * remains the authority for availability; KEYBINDINGS remains the authority for
@@ -100,6 +112,8 @@ export declare class StatusLineComponent implements Component {
      * everything fits on one row.
      */
     getPreviewContent(width: number): string;
+    getPreviewContentForSettings(width: number, previewSettings: StatusLineSettings): string;
+    getPreviewPartsForSettings(width: number, previewSettings: StatusLineSettings): StatusLinePreviewParts;
     getCacheStatsForTest(): {
         rowHits: number;
         rowMisses: number;

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

@@ -14,6 +14,12 @@ export declare class EventController {
     private ctx;
     constructor(ctx: InteractiveModeContext);
     dispose(): void;
+    /** Temporary TUI stop discards scheduling, not historical assistant callback lifetimes. */
+    suspendAssistantTextPresentation(): void;
+    /** Rearm before the first restarted frame, even without a new provider event. */
+    resumeAssistantTextPresentation(): void;
+    /** Session/transcript replacement invalidates callbacks before removing old children. */
+    resetAssistantTextPresentation(): void;
     subscribeToAgent(): void;
     handleEvent(event: AgentSessionEvent): Promise<void>;
     clearIrcExpiryTimers(): void;

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

@@ -213,6 +213,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     }): Promise<void>;
     flushPendingBashComponents(): void;
     isKnownSlashCommand(text: string): boolean;
+    resetAssistantTextPresentation(): void;
     /** Advances the sticky-viewport source only for semantic transcript output. */
     recordVisibleTranscriptMutation(): void;
     addMessageToChat(message: AgentMessage, options?: {

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

@@ -259,6 +259,7 @@ export interface InteractiveModeContext {
     extractAssistantText(message: AssistantMessage): string;
     /** Records one semantic visible-transcript mutation for the sticky viewport. */
     recordVisibleTranscriptMutation?(): void;
+    resetAssistantTextPresentation(): void;
     updateEditorTopBorder(): void;
     updateEditorBorderColor(): void;
     rebuildChatFromMessages(policy: TranscriptRebuildPolicy): void;

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

@@ -1,4 +1,12 @@
-import type { MCPGetPromptResult, MCPPrompt, MCPRequestOptions, MCPResource, MCPResourceReadResult, MCPResourceTemplate, MCPServerCapabilities, MCPServerConfig, MCPServerConnection, MCPToolCallResult, MCPToolDefinition } from "./types";
+import type { MCPGetPromptResult, MCPPrompt, MCPRequestOptions, MCPResource, MCPResourceReadResult, MCPResourceTemplate, MCPServerCapabilities, MCPServerConfig, MCPServerConnection, MCPToolCallResult, MCPToolDefinition, MCPTransport } from "./types";
+import { MCPExpectedFailure } from "./types";
+/** Failed connection whose still-owned transport cleanup can be retried explicitly. */
+export declare class MCPConnectionCleanupFailure extends MCPExpectedFailure {
+    #private;
+    constructor(cause: unknown, transport: MCPTransport);
+    /** Retry the same retained transport cleanup; failures preserve all prior causes. */
+    close(): Promise<void>;
+}
 /**
  * Connect to an MCP server.
  * Has a 30 second timeout to prevent blocking startup.

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

@@ -8,6 +8,7 @@ import { type TSchema } from "@gajae-code/ai/core";
 import type { SourceMeta } from "../capability/types";
 import type { CustomTool } from "../extensibility/custom-tools/types";
 import type { AuthStorage } from "../session/auth-storage";
+import { MCPConnectionCleanupFailure } from "./client";
 import { MCPConnectionPool, type MCPPoolLease } from "./pool";
 import type { MCPProtocolObservation } from "./protocol";
 import type { MCPToolDetails } from "./tool-bridge";
@@ -200,6 +201,10 @@ export declare class MCPManager {
     }): Promise<T>;
     /** Read-only test seam for pending retired lease-release records. */
     get retiredLeaseReleaseCountForTests(): number;
+    /** Read-only test seam for retained failed-connection cleanup owners. */
+    get pendingConnectionCleanupCountForTests(): number;
+    /** Read-only test seam for retained failed-connection cleanup causes. */
+    getPendingConnectionCleanupFailureForTests(name: string): MCPConnectionCleanupFailure | undefined;
     /**
      * Get all connected server names.
      */
@@ -223,7 +228,8 @@ export declare class MCPManager {
      * Tears down the stale connection, re-resolves auth, establishes a new
      * connection, reloads tools, and notifies consumers.
      * Concurrent calls for the same server share one reconnection attempt.
-     * Returns the new connection, or null if reconnection failed.
+     * Returns the new connection, or null if reconnection fails after cleanup.
+     * Throws a retryable cleanup failure while the previous transport owner remains incomplete.
      */
     reconnectServer(name: string): Promise<MCPServerConnection | null>;
     /**

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

@@ -1,3 +1,4 @@
+import { MCPConnectionCleanupFailure } from "./client";
 import { type MCPPoolKeyIdentity, type MCPPoolKeyOptions, type MCPPoolSharingMode } from "./pool-key";
 import { type MCPRequestOptions, type MCPServerConfig, type MCPServerConnection } from "./types";
 export type { MCPPoolCapabilityProfile, MCPPoolKeyIdentity, MCPPoolKeyOptions, MCPPoolSharingMode } from "./pool-key";
@@ -18,8 +19,9 @@ export declare class MCPPoolAcquireAbortError extends Error {
     readonly code: "MCP_POOL_ACQUIRE_ABORTED";
     readonly serverName: string;
     readonly poolKey: string;
-    cleanup?: Promise<unknown>;
-    constructor(serverName: string, poolKey: string, cause: unknown, cleanup?: Promise<unknown>);
+    readonly cleanup?: Promise<void>;
+    readonly cleanupGeneration?: number;
+    constructor(serverName: string, poolKey: string, cause: unknown, cleanup?: Promise<void>, cleanupGeneration?: number);
 }
 export declare class MCPPoolLeaseInvalidatedError extends Error {
     readonly code: "MCP_POOL_LEASE_INVALIDATED";
@@ -60,6 +62,8 @@ export interface MCPPoolAcquireOptions extends MCPPoolKeyOptions {
     advertiseRoots?: boolean;
     onNotification?: (method: string, params: unknown) => void;
     onRequest?: (method: string, params: unknown) => Promise<unknown>;
+    /** @internal Synchronous handoff for a pool-owned abandoned-acquire cleanup flight. */
+    onCleanupPending?: (error: MCPPoolAcquireAbortError) => void;
 }
 export interface MCPConnectionPoolOptions {
     sharedPoolIdleMs?: number;
@@ -105,6 +109,7 @@ type PendingWaiter = {
     settled: boolean;
     claimed: boolean;
     removeAbortListener?: () => void;
+    onCleanupPending?: (error: MCPPoolAcquireAbortError) => void;
 };
 type PendingEntry = {
     claims: number;
@@ -118,7 +123,7 @@ type PendingEntry = {
     cancellationReason?: unknown;
     openAbortController: AbortController;
     openSignal?: AbortSignal;
-    settlement?: Promise<unknown>;
+    settlement?: Promise<void>;
 };
 /** A lease over one physical MCP connection. */
 export interface MCPPoolLease {
@@ -182,6 +187,20 @@ export declare class MCPConnectionPool {
     awaitRestart(key: string): Promise<boolean>;
     finishRestart(key: string, error?: unknown): void;
     releaseRestart(key: string): void;
+    private retainCancelledAcquireCleanup;
+    private notifyPendingAcquireCleanup;
+    /** @internal Whether this pool still owns the notified abandoned-acquire flight. */
+    hasPendingAcquireCleanup(error: MCPPoolAcquireAbortError): boolean;
+    /** @internal Current retained failure for one notified abandoned-acquire generation. */
+    getPendingAcquireCleanupFailure(error: MCPPoolAcquireAbortError): MCPConnectionCleanupFailure | undefined;
+    /** @internal Prevent manager-level duplication of the pool's retained cleanup owner. */
+    ownsPendingAcquireCleanupFailure(error: unknown): boolean;
+    /** Read-only test seam for abandoned-acquire cleanup owners. */
+    get pendingAcquireCleanupCountForTests(): number;
+    /** Read-only test seam for the current retained abandoned-acquire cleanup failure. */
+    getPendingAcquireCleanupFailureForTests(name: string): MCPConnectionCleanupFailure | undefined;
+    /** @internal Join and retry one generation of abandoned acquisition cleanup. */
+    closePendingAcquireCleanup(key: string, generation: number): Promise<void>;
     acquire(name: string, config: MCPServerConfig, options?: MCPPoolAcquireOptions): Promise<MCPPoolLease>;
     private waitForPendingEntry;
     private scheduleZeroClaimCleanup;

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

@@ -23,7 +23,3 @@ export declare class StdioTransport implements MCPTransport {
     notify(method: string, params?: Record<string, unknown>): Promise<void>;
     close(): Promise<void>;
 }
-/**
- * Create and connect a stdio transport.
- */
-export declare function createStdioTransport(config: MCPStdioServerConfig): Promise<StdioTransport>;