@gajae-code/coding-agent 0.5.1 → 0.5.3

package/CHANGELOG.md

@@ -2,6 +2,37 @@
 
 ## [Unreleased]
 
+## [0.5.3] - 2026-06-16
+
+### Added
+
+- Added `GJC_CREDENTIAL_RANKING_MODE` env var (`balanced` (default) | `earliest-reset`), wired through `discoverAuthStorage` into `AuthStorage.credentialRankingMode`. `earliest-reset` selects multi-account OAuth credentials earliest-expiry-first so soon-to-reset tumbling-window quota (e.g. Claude 5h/7d) is drained before it is lost at reset; unset/unknown leaves the default `balanced` behavior unchanged.
+- The `/model` selector and `/fast` status now show a per-model fast-mode indicator (`⚡`) resolved with the provider-aware predicate, including subagent (role) models evaluated against the effective `task.serviceTier` (falling back to the session tier when `inherit`), so it is visible at a glance which models will run with Anthropic `speed:"fast"` / OpenAI `service_tier=priority`. Display-only: no `serviceTier`/`modelRoles`/`agentModelOverrides` writes (#691).
+- Added an opt-in `GJC_BRIDGE_ENDPOINTS` env var (`all`, or a comma list of matrix keys: `events`, `commands`, `control`, `uiResponses`, `hostToolResults`, `hostUriResults`) to enable bridge-mode session-control endpoints, which were previously permanently fail-closed (`403 endpoint_disabled`) with no supported way to turn them on. Unset stays fail-closed and backward compatible (#663).
+
+### Fixed
+
+- Auto-compaction no longer silently requires OpenAI when the active route is a custom Anthropic-capable provider. The compaction model-candidate selection already prefers the active session model, but its last-resort "largest-context model" fallback scanned the entire bundled catalog across all providers, so a stray OpenAI credential (e.g. an out-of-credit key left in the environment) could be picked when the active provider's compaction credential was unusable — turning OpenAI into an implicit hard dependency. The implicit fallback is now scoped to the active model's provider; cross-provider compaction still works but only when explicitly configured via `modelRoles`. When the active provider cannot compact and no role is configured, compaction now fails with the existing clear, provider-specific credential error instead of reaching for OpenAI (#697).
+- Long-running-session freeze/leak remediation across the TUI, agent, and tool runtime: the TUI render loop, component-dispose lifecycle, and markdown highlighting are hardened against huge frames and reuse leaks (#716); agent context append, an emergency-compaction floor that cannot be disabled, token accounting, and session resource teardown (own-session browser tabs, LSP clients, Cursor conversation cache) are bounded (#717); oversized tool inputs/outputs are capped (8 MiB edit/read guard ahead of the notebook fast-path, 1000-row SQLite raw-query cap, 16 MiB artifact / 256 MiB archive read caps, budget-bounded browser return serialization) (#721); native synchronous entrypoints add defense-in-depth caps for tokenization, highlighting, and fuzzy edit matching (#744); and the session blob store is LRU-bounded (64 MiB / 4096 entries) with bounded-concurrency blob resume (limit 8) (#719).
+- Process & resource lifecycle hardening so child processes and external resources are reliably reaped on disconnect, abort, and shutdown, built on a new owned-process foundation — process-group ownership with escalating SIGTERM→SIGKILL tree termination, idempotent dispose, and a postmortem reap hook (F1). Owned-process handles are terminalized on clean drain so a retained handle can never signal a recycled PID/process group (B1); the native blocking-task boundary, PTY lifecycle, and pi-shell timeout/abort reaping are hardened (U1–U3); the Python eval kernel (U4) and JS eval worker/VM (U5) coalesce concurrent first cells, settle queued/pending runs on teardown, and return worker/kernel counts to baseline; bash shell sessions are owner-scoped with one-shot async/monitor jobs and a hard artifact byte cap (U6); DAP adapters and LSP servers are spawned as owned processes and killed on terminate/timeout/reload (U7); MCP stdio/HTTP/SSE transports and the manager close idempotently with stale-publication identity guards (U8); the async job-manager bounds dispose, the delivery queue/retry (with dead-lettering), and terminal purge (U9); and tmux GC never prunes live/attached sessions and reaps only durably-owned orphans (U10).
+
+## [0.5.2] - 2026-06-15
+
+### Fixed
+
+- Prevented `gjc --tmux` partial-launch diagnostics from throwing when stderr is already closed during shutdown.
+- Fixed v0.5.1-style macOS/Linux standalone binaries crashing before the first model request with `Cannot find module '@gajae-code/natives' from '/$bunfs/root/gjc-*'` when pre-prompt context maintenance invokes the native tokenizer.
+- Mapped the retired `codex-standard` model profile name to `codex-medium` during profile activation, **as a fallback only** so a user-defined profile literally named `codex-standard` is never shadowed, letting stale `modelProfile.default: codex-standard` configs reach activation instead of blocking startup after the rebuilt profile catalog.
+- Fixed interactive goal-mode auto-continuation looping `Error: Agent is already processing…` (`AgentBusyError`) while the session is busy. A wedged/orphaned subagent turn — or an in-progress compaction — can leave the session non-idle while the interactive loop is back at `getUserInput()`; the 800 ms continuation timer then fired `prompt()`, threw `AgentBusyError`, surfaced it via `showError`, and re-armed — spamming the error roughly every 800 ms. The continuation now skips and re-arms while `isStreaming`/`isCompacting`, firing only once the session returns to idle.
+- Fixed the built-in `minimax-eco`/`minimax-medium`/`minimax-pro` model profiles 400ing on activation because every role pinned the non-existent `minimax-code/minimax-v3`. All three profiles now pin `minimax-code/minimax-m3`, the canonical `minimax-code` default already present in the bundled models catalog (#656).
+- Fixed the native Stop hook letting a deep-interview run terminalize through the ordinary stop path without crystallizing its distilled interview state. A deep-interview mode-state that would release the Stop block (e.g. `active:true` with a `complete`/`completed`/`inactive` phase) is now held until it has actually persisted a final spec — a `spec_path` that still resolves to a real `.gjc/specs/` artifact — and the public-safe diagnostic points the agent at `gjc deep-interview --write --stage final` (optionally `--handoff ralplan`). The guard is scoped to deep-interview only: explicit abort/cancel phases (`failed`/`cancelled`/`canceled`) and the `active:false` demotion/clear outcome remain legitimate terminals, and no other workflow's stop behavior changes (#674).
+
+### Added
+
+- Added three bundled dark TUI migration themes — `claude-code`, `codex`, and `opencode` — whose palettes mirror the Claude Code, OpenAI Codex CLI, and opencode TUIs for easy eye-migration. They join the crustacean defaults (`red-claw` dark, `blue-crab` light) as selectable built-ins via Settings or `/theme`; defaults are unchanged and the new themes keep GJC's default symbol identity. A built-in inventory test now validates every bundled theme against the required `THEME_COLOR_KEYS` token set, name/key equality, var resolution, dark classification, and brand-vs-semantic token separation.
+- Documented and regression-guarded the `gjc --tmux` scroll/mouse profile so WSL/Linux launches are not left guessing about mouse-wheel scrolling. The GJC-managed tmux session already applies `mouse on` (plus `set-clipboard on` and a readable copy-mode `mode-style`) scoped to the GJC session only, on macOS/Linux/WSL alike (only native `win32` skips the tmux launch); a new launch-path test asserts a WSL/Linux `--tmux` launch issues session-scoped `set-option ... mouse on` (never global `set -g`) and that `GJC_MOUSE=off` opts out without dropping the ownership tags. `docs/environment-variables.md` now documents the `--tmux` startup env vars (`GJC_LAUNCH_POLICY`, `GJC_TMUX_SESSION`, `GJC_TMUX_COMMAND`, `GJC_TMUX_PROFILE`, `GJC_MOUSE`) and the WSL/Windows Terminal scroll behavior (tmux copy-mode wheel scroll vs. native scrollback, copy-mode keyboard fallback, and that GJC never modifies tmux sessions you started yourself), and `gjc --help` surfaces `GJC_TMUX_PROFILE`/`GJC_MOUSE` (#650).
+- Added a subagent-scoped `task.serviceTier` setting (default `"inherit"`) so the service tier / fast mode applied to task-tool subagents can be controlled independently of the main session. `"inherit"` keeps the current behavior (the main session tier is copied into each subagent's isolated settings snapshot), while any explicit value (`none`, `priority`, `openai-only`, `claude-only`, …) overrides only the subagent sessions, which already read `serviceTier` from their own settings. Implemented in `createSubagentSettings` with a focused test covering inherit and explicit-override behavior (#664).
+
 ## [0.5.1] - 2026-06-14
 
 ### Added

package/README.md

@@ -34,4 +34,4 @@ Switching backends mid-session is honoured on the next system-prompt rebuild and
 
 ## Red-claw TUI theme
 
-The interactive TUI defaults to the bundled `red-claw` crustacean theme for dark terminals and the bundled `blue-crab` theme for light-appearance terminals, with matching welcome/icon assets. Explicit user theme settings still win; set `theme.dark: red-claw` and `theme.light: blue-crab` in `~/.gjc/agent/config.yml` to pin them.
+The interactive TUI defaults to the bundled `red-claw` crustacean theme for dark terminals and the bundled `blue-crab` theme for light-appearance terminals, with matching welcome/icon assets. Three additional bundled migration themes — `claude-code`, `codex`, and `opencode` — mirror the look of those tools for easy eye-migration and are selectable from Settings or `/theme`. Explicit user theme settings still win; set `theme.dark: red-claw` and `theme.light: blue-crab` in `~/.gjc/agent/config.yml` to pin them.

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

@@ -109,11 +109,16 @@ export interface AsyncJobManagerOptions {
     maxRunningJobs?: number;
     retentionMs?: number;
 }
+export interface AsyncJobDisposeDiagnostics {
+    stuckJobIds: string[];
+    deliveriesDrained: boolean;
+}
 export interface AsyncJobDeliveryState {
     queued: number;
     delivering: boolean;
     nextRetryAt?: number;
     pendingJobIds: string[];
+    deadLettered: number;
 }
 export interface AsyncJobLifecycleCleanup {
     onCancel?: (job: AsyncJob) => void;
@@ -308,6 +313,7 @@ export declare class AsyncJobManager {
      * (used by `dispose()` to nuke the manager's state).
      */
     cancelAll(filter?: AsyncJobFilter): void;
+    getLastDisposeDiagnostics(): AsyncJobDisposeDiagnostics;
     waitForAll(): Promise<void>;
     drainDeliveries(options?: {
         timeoutMs?: number;

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

@@ -1,4 +1,9 @@
-export type SetupComponent = "defaults" | "hermes" | "hooks" | "provider" | "python" | "stt";
+/**
+ * Setup CLI command handler.
+ *
+ * Handles `gjc setup [component]` to install the normal defaults or optional feature dependencies.
+ */
+export type SetupComponent = "credentials" | "defaults" | "hermes" | "hooks" | "provider" | "python" | "stt";
 export interface SetupCommandArgs {
     component: SetupComponent;
     flags: {
@@ -27,6 +32,8 @@ export interface SetupCommandArgs {
         gjcCommand?: string;
         target?: string;
         profileDir?: string;
+        yes?: boolean;
+        dryRun?: boolean;
     };
 }
 /**

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

@@ -93,6 +93,13 @@ export default class Setup extends Command {
         "models-path": import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
             description: string;
         };
+        yes: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            char: string;
+            description: string;
+        };
+        "dry-run": import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+        };
     };
     run(): Promise<void>;
 }

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

@@ -8,6 +8,28 @@ export declare function readFileLockInfoForGc(lockDir: string): Promise<{
     pid: number;
     timestamp: number;
 } | null>;
-/** @internal */
-export declare function removeFileLockDirForGc(lockDir: string): Promise<void>;
+/** Owner identity stamped into a `<file>.lock/info` record. */
+export interface FileLockOwnerToken {
+    pid: number;
+    timestamp: number;
+}
+/** Outcome of a guarded GC removal attempt (`removeFileLockDirForGc`). */
+export type FileLockGcRemoval = "removed" | "owner_changed" | "missing";
+/**
+ * @internal
+ * Fail-closed removal of a dead lock dir for GC. Re-reads the on-disk owner
+ * token as close to the unlink as possible and only deletes the dir when it
+ * STILL holds the exact `{pid, timestamp}` identity the caller observed dead.
+ *
+ * Closes the prune-time TOCTOU window (#606): between GC's dead re-read/probe
+ * and the unlink, a live process can reclaim a stale lock at the same path
+ * (`acquireLock` rms the stale dir, then re-`mkdir`s and rewrites `info` with a
+ * fresh pid+timestamp). Deleting by path alone would reap that LIVE lock. Any
+ * mismatch (`owner_changed`) or absent/unreadable info (`missing` — e.g. a
+ * fresh acquirer between `mkdir` and `writeLockInfo`) refuses the delete and
+ * leaves the dir intact. POSIX has no atomic compare-and-delete for a
+ * directory, so the residual read->unlink window cannot be fully eliminated,
+ * but the reclaim-after-stale scenario the issue describes is now guarded.
+ */
+export declare function removeFileLockDirForGc(lockDir: string, expected: FileLockOwnerToken): Promise<FileLockGcRemoval>;
 export declare function withFileLock<T>(filePath: string, fn: () => Promise<T>, options?: FileLockOptions): Promise<T>;

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

@@ -2,6 +2,7 @@ import { type Api, type AssistantMessageEventStream, type CacheRetention, type C
 import type { OAuthCredentials, OAuthLoginCallbacks } from "@gajae-code/ai/utils/oauth/types";
 import { type ThemeColor } from "../modes/theme/theme";
 import type { AuthStorage } from "../session/auth-storage";
+import type { ActiveSearchModelContext, WebSearchMode } from "../web/search/types";
 import { type ConfigError, ConfigFile } from "./config-file";
 import { type CanonicalModelIndex, type CanonicalModelRecord, type CanonicalModelVariant, type ModelEquivalenceConfig } from "./model-equivalence";
 import { type ModelProfileDefinition } from "./model-profiles";
@@ -87,6 +88,7 @@ export declare const ModelsConfigFile: ConfigFile<{
             supportsStrictMode?: boolean | undefined;
             toolStrictMode?: "all_strict" | "none" | undefined;
         } | undefined;
+        webSearch?: "auto" | "off" | "on" | undefined;
         authHeader?: boolean | undefined;
         auth?: "apiKey" | "none" | "oauth" | undefined;
         discovery?: {
@@ -364,6 +366,8 @@ export declare class ModelRegistry {
      * Get the base URL associated with a provider, if any model defines one.
      */
     getProviderBaseUrl(provider: string): string | undefined;
+    getProviderWebSearchMode(provider: string): WebSearchMode | undefined;
+    getActiveSearchModelContext(model: Model<Api>): ActiveSearchModelContext;
     /**
      * Get API key for a model.
      */

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

@@ -333,6 +333,11 @@ export declare const ModelsConfigSchema: z.ZodObject<{
                 none: "none";
             }>>;
         }, z.core.$strip>>;
+        webSearch: z.ZodOptional<z.ZodEnum<{
+            auto: "auto";
+            off: "off";
+            on: "on";
+        }>>;
         authHeader: z.ZodOptional<z.ZodBoolean>;
         auth: z.ZodOptional<z.ZodEnum<{
             apiKey: "apiKey";

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

@@ -86,6 +86,9 @@ interface EnumDef<T extends readonly string[]> {
 interface ArrayDef<T> {
     type: "array";
     default: T[];
+    items?: {
+        enum: readonly string[];
+    };
     ui?: UiBase;
 }
 interface RecordDef<T> {
@@ -956,6 +959,53 @@ export declare const SETTINGS_SCHEMA: {
             }];
         };
     };
+    readonly "task.serviceTier": {
+        readonly type: "enum";
+        readonly values: readonly ["inherit", "none", "auto", "default", "flex", "scale", "priority", "openai-only", "claude-only"];
+        readonly default: "inherit";
+        readonly ui: {
+            readonly tab: "tasks";
+            readonly label: "Subagent Service Tier";
+            readonly description: 'Service tier applied to task-tool subagents only. "inherit" copies the main session tier; any explicit value overrides it for subagents without touching the main session.';
+            readonly options: readonly [{
+                readonly value: "inherit";
+                readonly label: "Inherit";
+                readonly description: "Use the main session's service tier (default)";
+            }, {
+                readonly value: "none";
+                readonly label: "None";
+                readonly description: "Omit service_tier for subagents";
+            }, {
+                readonly value: "auto";
+                readonly label: "Auto";
+                readonly description: "Use provider default tier selection (OpenAI)";
+            }, {
+                readonly value: "default";
+                readonly label: "Default";
+                readonly description: "Standard priority processing (OpenAI)";
+            }, {
+                readonly value: "flex";
+                readonly label: "Flex";
+                readonly description: "Flexible capacity tier when available (OpenAI)";
+            }, {
+                readonly value: "scale";
+                readonly label: "Scale";
+                readonly description: "Scale Tier credits when available (OpenAI)";
+            }, {
+                readonly value: "priority";
+                readonly label: "Priority";
+                readonly description: "Priority on every supported provider (OpenAI `service_tier`, Anthropic fast mode)";
+            }, {
+                readonly value: "openai-only";
+                readonly label: "Priority (OpenAI only)";
+                readonly description: "Priority on OpenAI/OpenAI-Codex requests; ignored elsewhere";
+            }, {
+                readonly value: "claude-only";
+                readonly label: "Priority (Claude only)";
+                readonly description: "Anthropic fast mode on direct Claude requests; ignored elsewhere (incl. Bedrock/Vertex)";
+            }];
+        };
+    };
     readonly "retry.enabled": {
         readonly type: "boolean";
         readonly default: true;
@@ -2411,6 +2461,18 @@ export declare const SETTINGS_SCHEMA: {
             readonly description: "Enable the web_search tool for web searching";
         };
     };
+    readonly "web_search.fallback": {
+        readonly type: "array";
+        readonly default: string[];
+        readonly items: {
+            readonly enum: readonly ["duckduckgo", "exa", "brave", "jina", "kimi", "zai", "anthropic", "perplexity", "gemini", "codex", "tavily", "parallel", "kagi", "synthetic", "searxng"];
+        };
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "Web Search Fallback";
+            readonly description: "Ordered fallback web search providers after the active model native provider";
+        };
+    };
     readonly "browser.enabled": {
         readonly type: "boolean";
         readonly default: true;

package/dist/types/dap/client.d.ts

@@ -1,3 +1,4 @@
+import { type OwnedProcess } from "../runtime/process-lifecycle";
 import type { DapCapabilities, DapClientState, DapEventMessage, DapInitializeArguments, DapRequestMessage, DapResolvedAdapter } from "./types";
 interface DapSpawnOptions {
     adapter: DapResolvedAdapter;
@@ -15,7 +16,7 @@ export declare class DapClient {
     readonly adapter: DapResolvedAdapter;
     readonly cwd: string;
     readonly proc: DapClientState["proc"];
-    constructor(adapter: DapResolvedAdapter, cwd: string, proc: DapClientState["proc"], options?: {
+    constructor(adapter: DapResolvedAdapter, cwd: string, owner: OwnedProcess, options?: {
         readable?: ReadableStream<Uint8Array>;
         writeSink?: DapWriteSink;
         socket?: {

package/dist/types/edit/read-file.d.ts

@@ -1,2 +1,8 @@
+/**
+ * Max byte size of a file the edit modes will load whole. Editing loads + normalizes +
+ * fuzzy-matches + diffs the entire file on the main thread, so a multi-MB/generated file
+ * would block the event loop (F19). Above this, fail fast with an actionable error.
+ */
+export declare const MAX_EDIT_FILE_BYTES: number;
 export declare function readEditFileText(absolutePath: string, path: string): Promise<string>;
 export declare function serializeEditFileText(absolutePath: string, path: string, content: string): Promise<string>;

package/dist/types/eval/js/context-manager.d.ts

@@ -12,6 +12,7 @@ export declare function executeInVmContext(options: {
     sessionId: string;
     cwd: string;
     session: ToolSession;
+    ownerId?: string;
     reset?: boolean;
     code: string;
     filename: string;
@@ -21,4 +22,6 @@ export declare function executeInVmContext(options: {
     value: unknown;
 }>;
 export declare function resetVmContext(sessionKey: string): Promise<void>;
+export declare function disposeVmContextsByOwner(ownerId: string): Promise<void>;
 export declare function disposeAllVmContexts(): Promise<void>;
+export declare function liveVmContextCount(): number;

package/dist/types/eval/js/executor.d.ts

@@ -7,6 +7,7 @@ export interface JsExecutorOptions {
     onChunk?: (chunk: string) => Promise<void> | void;
     signal?: AbortSignal;
     sessionId: string;
+    ownerId?: string;
     reset?: boolean;
     sessionFile?: string;
     artifactPath?: string;

package/dist/types/exec/bash-executor.d.ts

@@ -19,6 +19,8 @@ export interface BashExecutorOptions {
     /** Artifact path/id for full output storage */
     artifactPath?: string;
     artifactId?: string;
+    /** Execute without retaining a native Shell in the persistent session registry. */
+    oneShot?: boolean;
     /**
      * Invoked when the native minimizer rewrote the command's output, giving
      * the caller a chance to persist the lossless original capture (typically

package/dist/types/gjc-runtime/state-writer.d.ts

@@ -1,4 +1,5 @@
-import * as fs from "node:fs/promises";
+import type { Stats } from "node:fs";
+import { type FileLockOptions } from "../config/file-lock";
 import type { SkillActiveEntry } from "../skill-state/active-state";
 import { type AuditEntry, type CanonicalGjcWorkflowSkill, type WorkflowStateMutationOwner } from "../skill-state/workflow-state-contract";
 /**
@@ -55,6 +56,12 @@ export interface StateWriterOptions {
     cwd?: string;
     receipt?: StateWriterReceiptContext;
     audit?: StateWriterAuditContext;
+    /**
+     * Cross-process lock tuning for read-modify-write paths that route through
+     * `withWorkflowStateLock` / `updateJsonAtomic`. Omit for the hardened
+     * `withFileLock` defaults.
+     */
+    lock?: FileLockOptions;
 }
 export interface DeleteIfOwnedOptions extends StateWriterOptions {
     predicate?: (current: unknown) => boolean | Promise<boolean>;
@@ -81,7 +88,7 @@ export interface GenericHardPruneTarget {
 export interface GenericHardPruneSelectorContext {
     path: string;
     category: WriterCategory | string;
-    stat: Awaited<ReturnType<typeof fs.stat>>;
+    stat: Stats;
     readJson: () => Promise<unknown>;
 }
 export type GenericHardPruneSelector = (context: GenericHardPruneSelectorContext) => boolean | Promise<boolean>;
@@ -109,8 +116,63 @@ export declare function detectWorkflowEnvelopeIntegrityMismatch(filePath: string
 export declare function writeJsonAtomic(targetPath: string, value: unknown, options?: StateWriterOptions): Promise<string>;
 export declare function writeWorkflowEnvelopeAtomic(targetPath: string, value: unknown, options?: StateWriterOptions): Promise<string>;
 export declare function writeTextAtomic(targetPath: string, text: string, options?: StateWriterOptions): Promise<string>;
+/**
+ * Serialize a read-modify-write (or any multi-step mutation) against concurrent
+ * writers of the same `.gjc/**` target. Uses the cross-process directory lock
+ * from `withFileLock`, keyed on the resolved file path, so separate CLI/agent
+ * processes (e.g. team-mode workers) cannot interleave one writer's read with
+ * another writer's write and silently drop the first mutation (issue #646).
+ *
+ * The lock is advisory: it only protects callers that route through it, so every
+ * read-modify-write of a given file MUST acquire this lock for the same resolved
+ * path. `atomicWrite`'s temp-file + rename crash-atomicity is preserved; this
+ * layers concurrency-atomicity on top without weakening it.
+ */
+export declare function withWorkflowStateLock<T>(targetPath: string, fn: () => Promise<T>, options?: StateWriterOptions): Promise<T>;
 export declare function updateJsonAtomic<T = unknown>(targetPath: string, mutator: (current: T | undefined) => T | Promise<T>, options?: StateWriterOptions): Promise<string>;
 export declare function appendJsonl(targetPath: string, entry: unknown, options?: StateWriterOptions): Promise<string>;
+export interface AppendJsonlIdempotentOptions extends StateWriterOptions {
+    /**
+     * Identity key for an entry. Two entries that produce the same non-`undefined`
+     * key are duplicates, so only the first is appended. Return `undefined` to opt a
+     * candidate out of dedup (it is always appended). Use `key` for the common case
+     * where identity reduces to a single string.
+     */
+    key?: (entry: unknown) => string | undefined;
+    /**
+     * Equivalence predicate: return `true` when `existing` already represents
+     * `candidate`, suppressing the append. Use when identity cannot be reduced to a
+     * single string key. When both `key` and `equals` are supplied, `equals` wins.
+     */
+    equals?: (candidate: unknown, existing: unknown) => boolean;
+}
+export interface AppendJsonlIdempotentResult {
+    path: string;
+    /** `true` when the entry was written; `false` when an equivalent entry already existed. */
+    appended: boolean;
+    /** The pre-existing entry that suppressed the append, when `appended` is `false`. */
+    duplicate?: unknown;
+}
+/**
+ * Append `entry` to a JSONL file only when no equivalent entry already exists —
+ * the shared idempotent append primitive (issue #660).
+ *
+ * `appendJsonl` is a pure append with no dedup, so every recurring "duplicate
+ * ledger row" bug (#638, #643, #645) had to be patched with bespoke per-call-site
+ * guards. This primitive centralizes the read-check-append cycle: a caller
+ * declares identity once via `key` or `equals` instead of re-deriving the lookup
+ * at each site.
+ *
+ * The read-then-append is serialized through the same cross-process workflow lock
+ * as `updateJsonAtomic`, so two concurrent idempotent appends cannot both observe
+ * "no duplicate" and both write (the #646 TOCTOU that a plain `appendJsonl`
+ * preceded by a manual existence check is still exposed to).
+ *
+ * Scope note: this dedups the *append* only. Call sites whose idempotency must
+ * also skip a coupled mutation — e.g. the plan/state rewrite in #643/#645 — still
+ * need a whole-operation guard; this primitive is the ledger-level half of that.
+ */
+export declare function appendJsonlIdempotent(targetPath: string, entry: unknown, options: AppendJsonlIdempotentOptions): Promise<AppendJsonlIdempotentResult>;
 export declare function appendText(targetPath: string, text: string, options?: StateWriterOptions): Promise<string>;
 export declare function createJsonNoClobber(targetPath: string, value: unknown, options?: StateWriterOptions): Promise<string>;
 export declare function deleteIfOwned(targetPath: string, predicateOrOptions?: ((current: unknown) => boolean | Promise<boolean>) | DeleteIfOwnedOptions): Promise<DeleteResult>;

package/dist/types/gjc-runtime/tmux-sessions.d.ts

@@ -8,15 +8,21 @@ export interface GjcTmuxSessionStatus {
     branch?: string;
     branchSlug?: string;
     project?: string;
+    panePids: number[];
+    profile?: string;
 }
 export interface GjcTmuxSessionTagsForGc {
     profile?: string;
     project?: string;
     branch?: string;
+    branchSlug?: string;
+    createdAt?: string;
+    attached?: boolean;
+    panePids?: number[];
 }
 export interface GjcTmuxSessionsForGc {
     tagged: GjcTmuxSessionStatus[];
-    untagged: string[];
+    untagged: GjcTmuxSessionStatus[];
 }
 export declare function listGjcTmuxSessions(env?: NodeJS.ProcessEnv): GjcTmuxSessionStatus[];
 /** @internal */

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

@@ -5,6 +5,15 @@ export interface UltragoalGuardDiagnostic {
     message: string;
     goalId?: string;
 }
+export interface UltragoalAskBlockDiagnostic {
+    active: boolean;
+    reason: string;
+    source: "absent" | "durable_state" | "durable_state_unreadable" | "ledger" | "goals_json";
+    goalsPath?: string;
+    ledgerPath?: string;
+    goalIds?: string[];
+    message: string;
+}
 export interface CurrentGoalLike {
     objective: string;
     status?: string;
@@ -19,6 +28,7 @@ export declare function readUltragoalVerificationState(input: {
     cwd: string;
     currentGoal?: CurrentGoalLike | null;
 }): Promise<UltragoalGuardDiagnostic>;
+export declare function isUltragoalAskBlocked(cwd: string): Promise<UltragoalAskBlockDiagnostic>;
 export declare function assertCanCompleteCurrentGoal(input: {
     cwd: string;
     currentGoal?: CurrentGoalLike | null;

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

@@ -68,6 +68,8 @@ export interface UltragoalStatusSummary {
     goals: UltragoalGoal[];
 }
 export interface UltragoalCommandResult {
+    reviewBlockerGoalIds?: string[];
+    createdReviewPlan?: boolean;
     status: number;
     stdout?: string;
     stderr?: string;
@@ -118,6 +120,17 @@ export declare function startNextUltragoalGoal(input: {
     goal?: UltragoalGoal;
     allComplete: boolean;
 }>;
+type SurfaceFamily = "web" | "cli" | "native" | "api-package" | "algorithm-math" | "unknown";
+export declare function normalizeSurfaceToken(value: string): string;
+export declare function surfaceFamily(value: string): SurfaceFamily;
+export interface ReplayProcessHandle {
+    readonly exited: Promise<number>;
+    kill(signal?: number | NodeJS.Signals): void;
+}
+export declare function waitForReplayProcessWithTimeout(process: ReplayProcessHandle, timeoutMs: number, graceMs?: number): Promise<number>;
+export declare function validateExecutorQaRedTeamEvidenceForReview(cwd: string, executorQa: Record<string, unknown>, options?: {
+    mode?: "review";
+}): Promise<void>;
 export declare function checkpointUltragoalGoal(input: {
     cwd: string;
     goalId: string;
@@ -159,5 +172,21 @@ export declare function recordUltragoalReviewBlockers(input: {
     evidence: string;
     gjcGoalJson?: string;
 }): Promise<UltragoalPlan>;
+type UltragoalReviewContractStrength = "strong" | "thin-derived";
+interface UltragoalReviewFinding extends JsonObject {
+    severity: "blocker";
+    message: string;
+}
+interface UltragoalReviewResult extends JsonObject {
+    verdict: "pass" | "fail" | "inconclusive: weak-contract";
+    contractStrength: UltragoalReviewContractStrength;
+    cleanPassEligible: boolean;
+    source: JsonObject;
+    findings: UltragoalReviewFinding[];
+    artifactValidationSummary: JsonObject;
+    weakContractCapApplied: boolean;
+    blockerGoalIds?: string[];
+}
+export declare function runUltragoalReview(cwd: string, args: readonly string[]): Promise<UltragoalReviewResult>;
 export declare function runNativeUltragoalCommand(args: string[], cwd?: string): Promise<UltragoalCommandResult>;
 export {};

package/dist/types/lsp/types.d.ts

@@ -1,5 +1,6 @@
 import type { ptree } from "@gajae-code/utils";
 import * as z from "zod/v4";
+import type { OwnedProcess } from "../runtime/process-lifecycle";
 export declare const lspSchema: z.ZodObject<{
     action: z.ZodEnum<{
         capabilities: "capabilities";
@@ -261,6 +262,7 @@ export interface LspClient {
     cwd: string;
     config: ServerConfig;
     proc: ptree.ChildProcess<"pipe">;
+    owner?: OwnedProcess;
     requestId: number;
     diagnostics: Map<string, PublishedDiagnostics>;
     diagnosticsVersion: number;

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

@@ -41,6 +41,7 @@ interface BridgeIdempotencyRecord {
     pending?: boolean;
 }
 type BridgeIdempotencyCache = Map<string, BridgeIdempotencyRecord>;
+export declare function parseBridgeEndpoints(value: string | undefined): Partial<BridgeEndpointMatrix> | undefined;
 export declare function createBridgeFetchHandler(options: BridgeFetchHandlerOptions): (request: Request) => Promise<Response>;
 export declare function runBridgeMode(session: AgentSession, setToolUIContext?: (uiContext: ExtensionUIContext, hasUI: boolean) => void): Promise<never>;
 export {};

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

@@ -30,6 +30,8 @@ export declare class ModelSelectorComponent extends Container {
         temporaryOnly?: boolean;
         initialSearchInput?: string;
         sessionId?: string;
+        isFastForProvider?: (provider?: string) => boolean;
+        isFastForSubagentProvider?: (provider?: string) => boolean;
     });
     handleInput(keyData: string): void;
     getSearchInput(): Input;

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

@@ -10,5 +10,6 @@ export declare class OAuthSelectorComponent extends Container {
         requestRender?: () => void;
     });
     stopValidation(): void;
+    dispose(): void;
     handleInput(keyData: string): void;
 }

package/dist/types/modes/components/provider-onboarding-selector.d.ts

@@ -1,5 +1,5 @@
 import { Container } from "@gajae-code/tui";
-export type ProviderOnboardingAction = "custom-provider-wizard" | "oauth-login" | "api-guide";
+export type ProviderOnboardingAction = "custom-provider-wizard" | "oauth-login" | "import-credentials" | "api-guide";
 export declare class ProviderOnboardingSelectorComponent extends Container {
     #private;
     constructor(onSelect: (action: ProviderOnboardingAction) => void, onCancel: () => void);

package/dist/types/modes/components/runtime-mcp-add-wizard.d.ts

@@ -20,6 +20,7 @@ export interface MCPAddWizardOAuthResult {
 export declare class MCPAddWizard extends Container {
     #private;
     constructor(onComplete: (name: string, config: MCPServerConfig, scope: Scope) => void, onCancel: () => void, onOAuth?: (authUrl: string, tokenUrl: string, clientId: string, clientSecret: string, scopes: string) => Promise<MCPAddWizardOAuthResult>, onTestConnection?: (config: MCPServerConfig) => Promise<void>, onRender?: () => void, initialName?: string);
+    dispose(): void;
     handleInput(keyData: string): void;
 }
 export {};

package/dist/types/modes/components/tool-execution.d.ts

@@ -47,6 +47,7 @@ export declare class ToolExecutionComponent extends Container {
      * Stop spinner animation and cleanup resources.
      */
     stopAnimation(): void;
+    dispose(): void;
     setExpanded(expanded: boolean): void;
     setShowImages(show: boolean): void;
     invalidate(): void;

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

@@ -86,7 +86,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     retryLoader: Loader | undefined;
     autoCompactionEscapeHandler?: () => void;
     retryEscapeHandler?: () => void;
-    retryCountdownTimer?: ReturnType<typeof setInterval>;
+    retryCountdownTimer?: NodeJS.Timeout;
     unsubscribe?: () => void;
     onInputCallback?: (input: SubmittedUserInput) => void;
     optimisticUserMessageSignature: string | undefined;