@gajae-code/coding-agent 0.15.6 → 0.16.0

package/CHANGELOG.md

@@ -2,6 +2,65 @@
 
 ## [Unreleased]
 
+## [0.16.0] - 2026-09-02
+
+- Added master mode (`gjc --master [--scope repo|pwd|global]`) with authenticated, broker-authoritative child orchestration: `gjc sdk spawn` creates task-seeded children, scoped `gjc sdk search` discovers broker-visible sessions with paginated results, and locator v2 session rows carry canonical cwd, worktree-root, and state-root identity.
+- SDK master-mode authority now selects the newest retained master epoch, binds worktree occupancy to canonical worktree roots with positive process-exit proof, keeps master capabilities out of ordinary Bash descendants, bounds authenticated nonce replay state, and preserves scoped search rows across pagination beyond the probe budget.
+- `move_session`, TUI `/move`, and SDK/ACP `session.cwd.move` no longer strand coordinator runtime-state persistence for the rest of the session. All three surfaces now cross one `SessionManager.moveTo` lifecycle: admitted old-cwd sidecar writes drain before commit, later queued writes are generation-fenced, and a durable rescope journal records the exact old/new cwd and session-file identities before publication so restart can finish an interrupted migration. Relocation holds both canonical state paths' process, namespace, and state-file locks in deterministic order across read/authenticate/write/remove; signed predecessors and destinations require the matching key id plus a valid Ed25519 signature, unsigned rows require complete exact cwd/workdir/session-file identity, and coordinator bootstrap or partial rows are never laundered into authoritative state. No-follow descriptor reads and native identity-bound orphan retirement reject symlink/path replacement, a valid self-healed destination is preserved while its authenticated old marker is removed, and rejected/tampered evidence stays intact with the journal retained for recovery. Rollback clears the prepared journal, committed metadata failures still run relocation, and postmortem finalizer rebinding is unconditional even when repair fails, so unexpected exit targets the live cwd/session file. (#4629)
+- `move_session` and `session.cwd.move` now report an unreadable target as `Directory identity or access unavailable` on macOS too. Darwin's `realpath(3)` fails with `EACCES` on a mode-0 directory where Linux resolves it and fails later at the access probe, so the same refusal was previously misreported as `Directory does not exist or is not a directory`.
+- The status rail no longer collapses to a bare `…+N` overflow marker on very small terminals. Context %, the goal indicator and the model name are now the last segments evicted (in that order), and once ordinary telemetry is gone they degrade through shortened and single-glyph forms before being dropped — context % is never dropped, keeps `18.3%/200K` while it fits, falls back to an integer `18%`, and retains its usage-level color. The overflow marker is suppressed at those widths so its cells go to the priority items instead. Rails with no context window and no active goal evict exactly as before.
+- Model names now render in their shortest recognizable id-derived form (`anthropic/claude-sonnet-4-5-20250929` → `sonnet-4.5`) in both the status rail and the footer telemetry line, replacing the raw id in the footer and the previous Anthropic-only `"Claude "` prefix strip in the rail. The rule is a pure heuristic — provider prefix, vendor family word and trailing date/build stamp removed — with no curated override table, and never yields an empty label. Model pickers and selectors keep full ids.
+- The `claude-fable` and `fable-opus-codex` built-in presets now use `anthropic/claude-fable-5-1` instead of `anthropic/claude-fable-5`, with effort suffixes preserved (`claude-fable` default/architect `xhigh`, critic `high`, planner `low`; `fable-opus-codex` default `high`). Fable 5.1 exposes the identical effort ladder, so no role mapping changed shape, and the non-fable roles (`anthropic/claude-sonnet-5` executor, `anthropic/claude-opus-5` planner/critic, the Codex executor/architect) are untouched. The extragoal reviewer template moves to `anthropic/claude-fable-5-1:xhigh` for the same reason. `claude-fable-5` remains in the catalog for pinned selectors and for gateways that do not serve 5.1.
+- Fresh interactive onboarding now asks for an interface language before showing guidance, supports English, Korean, Simplified Chinese, and Japanese, persists the choice through `ui.language`, and uses a documented English fallback for noninteractive, invalid, cancelled, or unwritable startup.
+- Coordinator projection consumers now retry a bounded number of fresh authoritative scans when concurrent session churn races a candidate. Cap exhaustion, owner disappearance, unsupported authority, and parse failures remain fail-closed, while settled concurrent SDK sessions no longer permanently starve the session reaper or coordinator mutations. (#5168)
+
+- Coordinator session-state locks now reclaim an empty, identity-qualified released transition tombstone on POSIX after a short release grace period. Live, foreign, malformed, non-empty, or identity-changed claims remain fail-closed, while persistent macOS/File Provider debris no longer burns the full transition timeout on every state write. (#5159)
+
+- A runtime-state marker recorded against a different workspace path now reports that mismatch instead of claiming the file is unreadable, and a terminal, not-live marker that travelled into the current workspace with its session directory is adopted rather than refused. Live, non-terminal, and out-of-workspace markers are still refused untouched.
+- An unavailable provider-qualified `modelRoles.default` selection now reports the requested model instead of silently starting on another provider's baseline. This keeps signed-registry omissions and failed catalog admission actionable rather than routing requests to an unrelated retired model. (#5144)
+
+- Headless SDK substrate close now reports success when exact teardown observes the recorded process gone even if cleanup unlinks the durable proof first; live or identity-ambiguous substrates still report `substrate_mismatch`. (#5130)
+
+- Windows session-state locks now drain late terminal reconciliation writes before disposal returns and safely reclaim valid dead transition claims during resume. (#5102)
+
+- Deferred MCP startup now releases queued idle yields as soon as readiness settles without bypassing prompt admission. Barrier extensions remain gated, rejected startup drops the wake without prompting, settled sessions retain the normal idle merge window, and readiness stays session-local. (#5085)
+- ACP deep-interview's real subprocess fixture now retires its owned lifecycle sessions before broker/root cleanup, preventing detached session hosts from recreating the fixture root after teardown. (#5086)
+- The ACP fixture tracks broker startup through its full producer deadline and tracks session creation before awaiting responses, keeps its independent broker fallback client available when runtime shutdown fails, and retires sessions first seen in either broker inventory phase directly through that fallback across cleanup retries. Verified broker-startup rejection no longer strands the root, while an unverified child-reap failure retains cleanup authority. Reconciliation recognizes the real ACP `terminal_uncertain` after-send wire envelope as transport uncertainty while preserving semantic close diagnostics, then accepts terminal races only after strict inventory proves unambiguous and certain retirement. A stalled broker-client transport close no longer blocks authoritative lease/root cleanup, and the child environment confines Windows profile and temporary paths to the fixture root. (#5086)
+- Telemetry install IDs are now staged in private temporary files and published atomically, so concurrent startup readers cannot observe a partial UUID payload; stale temporary files are never adopted and malformed persisted IDs still fail closed. Publication also falls back through native no-replace links and an exclusive claim protocol when rename-no-replace is unavailable, Windows reads and claim mutations use identity-bracketed opens, transient claimed payloads are retried, and every winner is tightened to mode 0600. (#5048)
+
+- An install with no configured model no longer starts on a model its provider has already withdrawn. The startup fallback now applies the configured provider-priority policy, skips bundled defaults disproved by fresh provider discovery, and only then preserves catalog order for remaining candidates. Explicit model and profile selections, enabled-model allowlists, credential selectors, disabled providers, and provider/id collision-safe candidate membership remain unchanged.
+
+### Fixed
+
+- File locks now use a descriptor-relative exclusive directory-publication fallback
+	when a filesystem returns `EINVAL` for `renameat2(RENAME_NOREPLACE)` (for example
+	WSL2 DrvFs), so `edit` and terminal persistence no longer surface `Failed to publish
+	file lock: invalid_request` on valid paths. The native fallback preserves no-follow
+	path containment, owner identity, no-replace contention, and fail-closed stale-owner
+	checks. (#5164)
+
+- The first Esc on a streaming turn with a queued steering message again consumes that steer and auto-continues instead of aborting the turn and dumping the queue back into the composer. The busy-indicator recovery branch counted the same drainable queue as cancellable work and, because a streaming turn always has that indicator mounted, it short-circuited before the steer-on-interrupt branch could run. Stale busy-indicator recovery, pending-submission cancellation, and the loud second-Esc abort are unchanged.
+
+- Print and JSON turns now fail closed when the provider/agent produces no readable assistant text: JSON emits a bounded `agent_failed` disposition and failures exit nonzero, while tool-only terminal output can no longer masquerade as success. (#5153)
+- Interactive `/login`, `/logout`, and account inventory commands now keep the TUI alive when the credential database reports `SQLITE_CORRUPT` or `SQLITE_NOTADB`. They show a bounded, payload-free recovery message and never auto-repair or delete the database. (#5070)
+- `session.last_assistant` now reads the public transcript projection, skips trailing tool-only, thinking-only, empty, and whitespace-only assistant rows, and returns the most recent readable assistant text or an empty string when none exists. (#5078)
+- Chat-daemon same-generation successor attachments now wait for predecessor provider retirement before admitting frames. Retired attachment frames remain fenced, successor frames resume after retirement, queue waiters settle during takeover and shutdown, and cross-generation replacement remains isolated. (#5120)
+
+- SDK lifecycle readiness now uses the same descriptor-bound endpoint identity tolerance as broker endpoint reads and selects owners by scoped state root, process incarnation, and lifecycle marker instead of bare session ID. This restores default source-host startup, shipped SDK lifecycle topology, shared-agent saved-source isolation, cold resume/fork cleanup, local SDK-only broker recovery, and generated operation-matrix closure after the master-mode merge. (#5114)
+
+- Coordinator event watchers now advertise the exact supported event-kind enum, while outbox entity validation and durable WAL/active-turn cleanup reuse their existing authority helpers instead of leaving those checks disconnected. (#5115)
+- Post-install update verification now preserves a bounded, secret-redacted stderr/stdout cause when the newly installed `gjc --version` exits unsuccessfully, so runtime guards such as Bun version incompatibilities remain actionable instead of collapsing to a generic verification failure. (#5108)
+- Concurrent coordinator mutations sharing one idempotency key now join the same in-process flight before taking the durable key lock, so a slow accepted prompt cannot make its retry time out as unavailable. Conflicting in-flight requests still fail closed, completed responses remain durably replayable, and different keys remain isolated. (#5110)
+- Custom providers declaring `transport: pi-native` in `models.yml` now actually dispatch through the auth-gateway native endpoint. The provider-level transport was silently dropped for models.yml-declared models, so requests went to `<baseUrl>/chat/completions` and the gateway answered 404; and the pi-native client now serializes only wire-safe tool fields, so runtime tool state carrying fs-stat BigInts no longer aborts request serialization with `JSON.stringify cannot serialize BigInt`.
+- ACP prompts now settle immediately on correlated explicit failure outcomes without waiting for a later `agent_end`; generic error-only `agent_failed` events remain additive diagnostics until an authoritative terminal, while late duplicates and unrelated correlations stay isolated. (#5107)
+
+- Managed-session file identities now use one canonical unsigned 64-bit representation across stat/native boundaries and replacement cleanup receipts. Native Windows file IDs surfaced as signed negative bigints no longer create double-hyphen receipt names that block persistence or reopen; already-written signed receipt names and interrupted pending receipts are recovered only through the existing identity-bound, fail-closed reconciliation paths. (#5095)
+
+- `gh` PR diffs decode git's C-style quoted paths as UTF-8 bytes instead of Latin-1 code points, so non-ASCII file names (`docs/\355\225\234\352\270\200.md`) no longer surface as mojibake in the file list, and quoted `rename from`/`rename to` lines are unquoted the same way instead of keeping their literal quotes and escapes.
+- Confirmed operator `turn.abort` requests now travel through a dedicated local Broker route instead of trusting caller-supplied `operator:true` and `confirm:true` on ordinary SDK frames. The Broker revalidates the exact live endpoint identity, injects a process-bound private capability, preserves post-send uncertainty, and the host uses one capability-free canonical identity for dispatch idempotency, durable admission, and delivery receipts, so forged, stale, dropped, and replayed requests fail closed consistently across restart boundaries.
+
+- Blob references and filesystem-backed blob reads now accept only exact lowercase SHA-256 names before resolving a disk path; canonical references and valid missing-blob behavior are unchanged.
+
 ## [0.15.6] - 2026-08-30
 
 - Auth metadata remains session-only when a compatibility registry has auth storage but no owner accessor, preventing an unscoped OAuth account lookup from attributing a registry-scoped API-key request to the wrong account.

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

@@ -50,6 +50,8 @@ export interface Args {
     noRules?: boolean;
     listModels?: string | true;
     noTitle?: boolean;
+    master?: true;
+    masterScope?: "repo" | "pwd" | "global";
     messages: string[];
     fileArgs: string[];
     /** Flags unknown to every launch parser; their consumer supplies the diagnostic. */

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

@@ -119,6 +119,13 @@ export declare const ROOT_LAUNCH_FLAGS: {
     "no-title": FlagDescriptor<"boolean"> & {
         description: string;
     };
+    master: FlagDescriptor<"boolean"> & {
+        description: string;
+    };
+    scope: FlagDescriptor<"string"> & {
+        description: string;
+        options: string[];
+    };
 };
 export type ConsumerLaunchFlagName = "hook" | "extension" | "no-extensions" | "no-skills" | "skills";
 export type LaunchFlagConsumer = "acp" | "local";
@@ -247,6 +254,13 @@ export declare const LAUNCH_PARSE_FLAGS: {
     "no-title": FlagDescriptor<"boolean"> & {
         description: string;
     };
+    master: FlagDescriptor<"boolean"> & {
+        description: string;
+    };
+    scope: FlagDescriptor<"string"> & {
+        description: string;
+        options: string[];
+    };
     extension: FlagDescriptor<"boolean" | "integer" | "string">;
     hook: FlagDescriptor<"boolean" | "integer" | "string">;
     "no-extensions": FlagDescriptor<"boolean" | "integer" | "string">;

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

@@ -21,6 +21,7 @@ export interface InstalledVersionVerification {
     ok: boolean;
     actual?: string;
     path?: string;
+    versionOutput?: string;
     smokeTestFailed?: boolean;
     smokeTestOutput?: string;
     cleanupWarning?: string;
@@ -87,6 +88,18 @@ export declare function resolveGjcPathForTest(options: {
     whichPath: string | undefined;
 }): string | undefined;
 export declare function parseReportedVersionForTest(output: string): string | undefined;
+export declare function sanitizeVerificationOutputForTest(stderr: string | undefined, stdout: string | undefined): string | undefined;
+interface InstalledVersionCommandResult {
+    exitCode: number | null;
+    stdout: string;
+    stderr: string;
+}
+type InstalledVersionCommandRunner = (runtimePath: string) => Promise<InstalledVersionCommandResult>;
+export declare function verifyInstalledVersionForTest(options: {
+    expectedVersion: string;
+    runtimePath: string | undefined;
+    runVersion: InstalledVersionCommandRunner;
+}): Promise<InstalledVersionVerification>;
 interface MigrationTargetVerificationOptions {
     runtimePath: string;
     verifyChecksum: () => Promise<void>;

package/dist/types/cli.d.ts

@@ -142,6 +142,13 @@ export declare class RootHelpCommand extends Command {
         "no-title": import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
             description: string;
         };
+        master: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+        };
+        scope: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+            options: string[];
+        };
     };
     static examples: string[];
     static strict: boolean;

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

@@ -2,7 +2,10 @@
  * Root command for the coding agent CLI.
  */
 import { Command } from "@gajae-code/utils/cli";
+import { type LaunchWorktreeReservation } from "../gjc-runtime/launch-worktree-reservation";
 export declare function persistCoordinatorLaunchFailure(error: unknown, cwd: string, env?: NodeJS.ProcessEnv): Promise<void>;
+/** Test seam for the path-keyed atomic reservation. */
+export declare function reserveLaunchWorktreeForTest(agentDir: string, worktreePath: string): Promise<LaunchWorktreeReservation>;
 export default class Index extends Command {
     static description: string;
     static hidden: boolean;
@@ -132,6 +135,13 @@ export default class Index extends Command {
         "no-title": import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
             description: string;
         };
+        master: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+        };
+        scope: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+            options: string[];
+        };
     };
     static examples: string[];
     static strict: boolean;

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

@@ -784,12 +784,33 @@ export declare const TIER_MAP_SKIP_LIST: {
     readonly "openai-codex/gpt-daybreak-blue-latest": {
         readonly rationale: "post-rebase catalog addition from dev; not yet curated";
     };
+    readonly "opencode-go/deepseek-v4-flash-vision-exp": {
+        readonly rationale: "post-rebase catalog addition from dev; not yet curated";
+    };
+    readonly "opencode-go/glm-5.3-flash": {
+        readonly rationale: "post-rebase catalog addition from dev; not yet curated";
+    };
     readonly "opencode-go/gpt-5.6-luna": {
         readonly rationale: "post-rebase catalog addition from dev; not yet curated";
     };
+    readonly "opencode-go/grok-4.6": {
+        readonly rationale: "post-rebase catalog addition from dev; not yet curated";
+    };
     readonly "opencode-go/hy3": {
         readonly rationale: "post-rebase catalog addition from dev; not yet curated";
     };
+    readonly "opencode-go/hy4-preview": {
+        readonly rationale: "post-rebase catalog addition from dev; not yet curated";
+    };
+    readonly "opencode-go/longcat-2.0": {
+        readonly rationale: "post-rebase catalog addition from dev; not yet curated";
+    };
+    readonly "opencode-go/muse-spark-1.2-contributor": {
+        readonly rationale: "post-rebase catalog addition from dev; not yet curated";
+    };
+    readonly "opencode-go/qwen3.8-flash": {
+        readonly rationale: "post-rebase catalog addition from dev; not yet curated";
+    };
     readonly "opencode-go/qwen3.8-max": {
         readonly rationale: "post-rebase catalog addition from dev; not yet curated";
     };
@@ -1686,6 +1707,9 @@ export declare const TIER_MAP_SKIP_LIST: {
         readonly baseline: true;
         readonly rationale: "pre-feature baseline; not yet curated";
     };
+    readonly "anthropic/claude-fable-5-1": {
+        readonly rationale: "post-feature catalog addition; not yet curated";
+    };
     readonly "anthropic/claude-haiku-4-5-20251001": {
         readonly baseline: true;
         readonly rationale: "pre-feature baseline; not yet curated";

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

@@ -1,4 +1,5 @@
 import type { NativeDirectoryTreeResult, NativeExactUnlinkResult } from "@gajae-code/natives";
+import { renameDirectoryNoReplacePathAsync, renameNoReplacePathAsync } from "@gajae-code/natives";
 export interface FileLockOptions {
     staleMs?: number;
     retries?: number;
@@ -15,6 +16,10 @@ export declare const FILE_LOCK_RELEASE_RETRY_ATTEMPTS = 5;
 export declare const FILE_LOCK_RELEASE_RETRY_DELAY_MS = 10;
 export declare const FileLockTestHooks: {
     afterParentMkdir?: (lockPath: string) => void | Promise<void>;
+    nativePublicationBindings?: () => {
+        renameNoReplacePathAsync: typeof renameNoReplacePathAsync;
+        renameDirectoryNoReplacePathAsync: typeof renameDirectoryNoReplacePathAsync;
+    };
     nativeQuarantineBindings?: () => NativeFileLockBindings;
 };
 /**

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

@@ -409,6 +409,12 @@ export declare class ModelRegistry {
      * with case-sensitive exact strings.
      */
     autoroutingProviderOrder(): readonly string[];
+    /**
+     * Provider priority for automatic model selection. Explicit provider order
+     * wins first, followed by omitted OAuth providers, then other providers;
+     * catalog order breaks ties within each policy band.
+     */
+    automaticProviderOrder(sessionId?: string): readonly string[];
     getCanonicalModels(options?: CanonicalModelQueryOptions): CanonicalModelRecord[];
     /**
      * Batch form of {@link resolveCanonicalModel} over every canonical record:

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

@@ -219,6 +219,12 @@ export declare const SETTINGS_SCHEMA: {
         readonly description: "Hard maximum runtime for an SDK prompt from acceptance, bounding progress-aware renewals.";
         readonly validate: (value: number) => boolean;
     };
+    readonly "sdk.masterOrphanGraceMs": {
+        readonly type: "number";
+        readonly default: 120000;
+        readonly description: "Grace period before a master-spawned child orphaned by confirmed master loss is closed.";
+        readonly validate: (value: number) => boolean;
+    };
     readonly "notifications.enabled": {
         readonly type: "boolean";
         readonly default: false;
@@ -604,7 +610,7 @@ export declare const SETTINGS_SCHEMA: {
     };
     readonly "ui.language": {
         readonly type: "enum";
-        readonly values: readonly ["en", "ko", "ja"];
+        readonly values: readonly ["en", "ko", "zh", "ja"];
         readonly default: "en";
         readonly ui: {
             readonly tab: "appearance";
@@ -616,6 +622,9 @@ export declare const SETTINGS_SCHEMA: {
             }, {
                 readonly value: "ko";
                 readonly label: "Korean (한국어)";
+            }, {
+                readonly value: "zh";
+                readonly label: "Chinese (简体中文)";
             }, {
                 readonly value: "ja";
                 readonly label: "Japanese (日本語)";

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

@@ -145,6 +145,8 @@ export declare class Settings implements NotificationSettingsReader {
     onChanged(listener: (path: SettingPath) => void): () => void;
     /** Whether durable settings mutations are permitted for the loaded configuration. */
     canWriteDurableConfig(): boolean;
+    /** Whether this instance can publish a mutation to a durable config file. */
+    canPersistDurableConfig(): boolean;
     /**
      * Set a setting value (sync).
      * Updates global settings and reserves its background persistence slot before

package/dist/types/coordinator-mcp/projection-scan.d.ts

@@ -4,6 +4,8 @@ export declare const ProjectionScanTestHooks: {
 };
 /** Post-filter parse-candidate cap. Exhaustion returns an explicit incomplete result. */
 export declare const COORDINATOR_JSON_SCAN_CAP = 10000;
+/** Number of fresh authoritative attempts allowed for a scan that observed churn. */
+export declare const COORDINATOR_JSON_SCAN_RETRY_ATTEMPTS = 3;
 export interface ProjectionScanStat {
     size: number | bigint;
     dev?: number | bigint;
@@ -44,3 +46,9 @@ export interface ProjectionScanResult {
 }
 export declare function isCoordinatorScanDebrisName(name: string): boolean;
 export declare function listCoordinatorJsonFiles(dir: string, io?: ProjectionScanFs, cap?: number): Promise<ProjectionScanResult>;
+/**
+ * Retry only scans invalidated by observed directory/file churn. A candidate cap,
+ * unsupported authority, parse error, or any other failure remains fail-closed.
+ * Each attempt acquires a new authority, so no partial result crosses attempts.
+ */
+export declare function listCoordinatorJsonFilesWithRetry(dir: string, io?: ProjectionScanFs, cap?: number, maxAttempts?: number): Promise<ProjectionScanResult>;

package/dist/types/crash/record-loader.d.ts

@@ -1,3 +1,17 @@
+/**
+ * Crash-log record recovery.
+ *
+ * The crash log is an append-only text file written by concurrent processes; it
+ * is explicitly **not** a parseable database. The field corpus contains at least
+ * one interleaved record (two headers merged onto one line), and throwable text
+ * is arbitrary multiline content. Recovery therefore trusts only a complete
+ * v1 record whose terminal identity line matches a fingerprint recomputed from
+ * that record's own header and stack.
+ *
+ * Records written before that line existed are `unmatchable` and are never
+ * offered for reporting — no retroactive mining is attempted or claimed.
+ */
+import { type CrashProvenance } from "@gajae-code/utils";
 export interface LoadedCrashRecord {
     readonly fingerprint: string;
     readonly fpv: number;
@@ -9,6 +23,7 @@ export interface LoadedCrashRecord {
     readonly body: string;
     /** The `Name: message` part of the header line. */
     readonly headline: string;
+    readonly provenance?: CrashProvenance;
 }
 export declare function parseCrashRecords(contents: string): LoadedCrashRecord[];
 /** Complete v1 records whose marker fingerprint is recomputed from their diagnostic text. */

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

@@ -0,0 +1,21 @@
+/**
+ * Cross-process reservation for a deterministic launch-worktree path.
+ *
+ * The durable session index is the long-lived ownership record, but a newly
+ * planned worktree has no index row yet. This reservation closes that interval:
+ * it is acquired before preparation and removed after `host_registered` is
+ * durably appended to the index.
+ */
+export interface LaunchWorktreeReservation {
+    release(): Promise<void>;
+}
+/** Test seam for seeding a dead-owner reservation at the exact production path. */
+export declare function launchWorktreeReservationDirectoryForTest(agentDir: string, worktreePath: string): string;
+/**
+ * Atomically claim `worktreePath`, returning `null` only when another live or
+ * unverified launch already owns the same deterministic target. A dead or
+ * PID-reused owner is reclaimed before retrying the exclusive directory create.
+ */
+export declare function reserveLaunchWorktree(agentDir: string, worktreePath: string): Promise<LaunchWorktreeReservation | null>;
+/** Remove the transient reservation only after the matching worktree is indexed. */
+export declare function releaseLaunchWorktreeReservationAfterRegistration(agentDir: string, worktreePath: string): Promise<void>;

package/dist/types/gjc-runtime/managed-owner-supervisor.d.ts

@@ -6,6 +6,8 @@ export declare const MANAGED_OWNER_GENERATION_ENV = "GJC_TMUX_OWNER_GENERATION";
 export declare const MANAGED_OWNER_STATE_DIR_ENV = "GJC_TMUX_OWNER_STATE_DIR";
 export declare const MANAGED_OWNER_RUN_ID_ENV = "GJC_MANAGED_OWNER_RUN_ID";
 export declare const MANAGED_OWNER_INCARNATION_ENV = "GJC_MANAGED_OWNER_INCARNATION";
+/** Suppresses command-derived durable artifacts for Broker-owned opaque spawn children. */
+export declare const MANAGED_OWNER_REDACT_COMMAND_ENV = "GJC_MANAGED_OWNER_REDACT_COMMAND";
 export interface ManagedOwnerBinding {
     schema_version: 2;
     generation: string;

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

@@ -33,6 +33,13 @@ export declare const __sessionStateSidecarPerfCounters: {
     persistFromEventCalls: number;
     reset(): void;
 };
+/** Test-only barriers for deterministic rescope transaction race coverage. */
+export declare const __sessionStateSidecarTestHooks: {
+    afterRescopeLocksAcquired?: () => void | Promise<void>;
+    beforeRescopeJournalWrite?: (cwd: string) => void | Promise<void>;
+    beforePersistFromEvent?: (eventType: string, cwd: string) => void | Promise<void>;
+    beforeRescopePublish?: () => void | Promise<void>;
+};
 interface RuntimeStateEvent {
     type: string;
     messages?: unknown[];
@@ -168,6 +175,12 @@ export interface RuntimeStateContext {
     ownerTerminal?: OwnerTerminalContext | null;
     /** Internal fail-closed marker set only when managed owner metadata is malformed or missing. */
     ownerTerminalMetadataInvalid?: boolean;
+    /**
+     * The session file as it was BEFORE a committed rescope, used only by
+     * {@link relocateCoordinatorRuntimeStateForRescope} to authenticate the predecessor
+     * payload against its old identity. Absent outside a move.
+     */
+    previousSessionFile?: string | null;
 }
 export type TerminalRuntimeStateStatus = {
     terminal: true;
@@ -201,7 +214,59 @@ export declare function persistCoordinatorWorkerIntegrationOutcome(context: Runt
     correlationId?: string;
     error?: string;
 }): Promise<void>;
+export declare function prepareCoordinatorRuntimeStateRescope(input: {
+    moveId?: string;
+    sessionId: string;
+    previousCwd: string;
+    newCwd: string;
+    previousCwdIdentity?: {
+        dev: bigint;
+        ino: bigint;
+    };
+    newCwdIdentity?: {
+        dev: bigint;
+        ino: bigint;
+    };
+    previousSessionFile?: string | null;
+    newSessionFile?: string | null;
+}): Promise<string>;
+export declare function markCoordinatorRuntimeStateRescopePublishing(context: RuntimeStateContext, previousCwd: string, moveId: string): Promise<void>;
+export declare function clearCoordinatorRuntimeStateRescope(context: RuntimeStateContext, expectedMoveId?: string, previousCwd?: string): Promise<void>;
+/**
+ * Cheap synchronous probe for a pending rescope-recovery journal at this cwd. Sessions
+ * that never moved (the overwhelming majority) have none, so callers use this to avoid
+ * arming a startup-turn barrier for a no-op recovery \u2014 an armed barrier is not free even
+ * when it resolves immediately: it flips the session's startup gate from absent to present
+ * and reorders barrier-gated post-turn work.
+ */
+export declare function hasCoordinatorRuntimeStateRescopeJournal(context: RuntimeStateContext): boolean;
+export declare function recoverCoordinatorRuntimeStateRescope(context: RuntimeStateContext): Promise<void>;
+/**
+ * Repairs the coordinator-shared runtime state after a committed cwd rescope, for every
+ * move surface (`move_session`, TUI `/move`, SDK/ACP `session.cwd.move`) through the one
+ * shared {@link SessionManager.moveTo} seam.
+ *
+ * The identity fence in {@link assertPreviousRuntimeStateIdentity} rejects any write whose
+ * predecessor payload records a different cwd/workdir than the live session. A rescope
+ * changes the session cwd but leaves the predecessor payload pointing at the launch root,
+ * so every later persist for the session would be refused as a foreign marker.
+ *
+ * The predecessor is fully authenticated against its OLD identity before it is trusted:
+ * signed mode verifies the predecessor's key id and Ed25519 signature; unsigned mode
+ * requires an exact old cwd/workdir/session-file match (the same checks the fence applies).
+ * Only a predecessor that passes is rewritten to the new identity and re-signed. When the
+ * state file is cwd-derived rather than pinned by
+ * {@link GJC_COORDINATOR_SESSION_STATE_FILE_ENV}, the payload is migrated to the new path
+ * and the orphaned launch-root file is removed. A payload already self-healed at the new
+ * cwd is left untouched.
+ *
+ * Both the old and new cwd-derived paths are locked (new first, then old) so a concurrent
+ * writer at either path serializes behind this repair. Best-effort by contract: the move
+ * is already durable, so a failure here is logged by the caller and never resurfaced as a
+ * rescope rejection.
+ */
+export declare function relocateCoordinatorRuntimeStateForRescope(context: RuntimeStateContext, previousCwd: string): Promise<boolean>;
 export declare function ownerTerminalContextFromEnvironment(): OwnerTerminalContext | "invalid" | null;
 export declare function persistCoordinatorRuntimeStateFromPostmortem(reason: postmortem.Reason, context: RuntimeStateContext): Promise<void>;
-export declare function registerCoordinatorRuntimeStateFinalizer(context: RuntimeStateContext): () => void;
+export declare function registerCoordinatorRuntimeStateFinalizer(context: RuntimeStateContext, resolveContext?: () => RuntimeStateContext): () => void;
 export {};

package/dist/types/gjc-runtime/tmux-owner-isolation.d.ts

@@ -149,6 +149,7 @@ export interface TmuxOwnerIsolationExecutionDependencies {
     spawn(argv: string[], stdinLine?: string): {
         exitCode: number | null;
         stdout?: string;
+        stderr?: string;
     };
     probeServer(socketKey: string): TmuxServerProof;
     /** Reads the published owner generation immediately around direct execution. */

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

@@ -1,5 +1,23 @@
 import { type ProviderAuthority } from "./tmux-common";
 import { type OwnerIsolationProbeSync, type OwnerVerdict, type PlanResponse, type TmuxOwnerIsolationExecutionDependencies, type TmuxOwnerIsolationExecutionResult } from "./tmux-owner-isolation";
+export interface ManagedTmuxLaunchSpec {
+    childSessionId: string;
+    cwd: string;
+    argv: readonly string[];
+    env?: Readonly<Record<string, string>>;
+}
+export interface ManagedTmuxLaunchProof {
+    name: string;
+    nativeSessionId: string;
+    serverPid: number;
+    serverStartTime: string;
+    ownerGeneration: string;
+    sessionId: string;
+    sessionStateFile: string;
+    pid: number;
+    providerIdentity: string;
+    psmuxIncarnation?: string;
+}
 export interface GjcTmuxSessionStatus {
     name: string;
     attached: boolean;
@@ -73,9 +91,12 @@ export interface ForceCloseOwnerDependencies {
     listPanePids(sessionName: string, env: NodeJS.ProcessEnv): number[];
     /** Test/runtime seam for an exact owner-exit observer; durable validation remains authoritative. */
     waitForOwnerExitVerdict?(): Promise<OwnerVerdict>;
+    /** Broker close pin; production callers use this to reject reused session identity. */
+    expectedManagedProof?: ManagedTmuxLaunchProof;
 }
 export interface CreateGjcTmuxSessionOptions {
     platform?: NodeJS.Platform;
+    launch?: ManagedTmuxLaunchSpec;
 }
 export type CreateOwnerIsolationTestDependencies = {
     probe?: Partial<OwnerIsolationProbeSync>;
@@ -93,6 +114,12 @@ export declare function findGjcTmuxSessionByName(sessionName: string, env?: Node
 export declare function findGjcTmuxSessionByScope(project: string, branch: string | null | undefined, env?: NodeJS.ProcessEnv): GjcTmuxSessionStatus | undefined;
 export declare function statusGjcTmuxSession(sessionName: string, env?: NodeJS.ProcessEnv): GjcTmuxSessionStatus;
 export declare function createGjcTmuxSession(env?: NodeJS.ProcessEnv, options?: CreateGjcTmuxSessionOptions): GjcTmuxSessionStatus;
+/** Launches one Broker-owned child through the managed owner path and returns only re-proof inputs. */
+export declare function createManagedGjcTmuxSession(spec: ManagedTmuxLaunchSpec, env?: NodeJS.ProcessEnv, options?: Omit<CreateGjcTmuxSessionOptions, "launch">): ManagedTmuxLaunchProof;
+/** Re-proves every mutable multiplexer identity field before a Broker effect. */
+export declare function verifyManagedGjcTmuxSession(expected: ManagedTmuxLaunchProof, env?: NodeJS.ProcessEnv): "verified" | "mismatch" | "gone";
+/** Closes only an identity that passes the same exhaustive verification used for replay and reaping. */
+export declare function forceCloseManagedGjcTmuxSession(expected: ManagedTmuxLaunchProof, env?: NodeJS.ProcessEnv): Promise<GjcTmuxSessionStatus>;
 /** Proves a managed reusable name still resolves to one immutable session on one server. */
 export declare function proveGjcTmuxSessionMutationTarget(sessionName: string, env?: NodeJS.ProcessEnv, provisionalAuthority?: ProviderAuthority): ProvenTmuxSessionIdentity;
 /** @internal */

package/dist/types/master-mode/context.d.ts

@@ -0,0 +1,21 @@
+import type { Args } from "../cli/args";
+export type MasterScope = "repo" | "pwd" | "global";
+/**
+ * Process-local master authority. Its capability accessor is deliberately the
+ * only way to reach the raw capability; this context is never serializable.
+ */
+export interface MasterModeContext {
+    readonly scope: MasterScope;
+    readonly ownerSessionId: string;
+    readonly attestationEpoch: string;
+    getCapability(): string;
+}
+export declare function createMasterModeContext(scope: MasterScope, ownerSessionId: string, attestationEpoch: string): MasterModeContext;
+/** Reject routes that cannot establish an interactive, durable master session. */
+export declare function assertMasterLaunchArgs(parsed: Args): void;
+export declare function assertMasterLaunchDisposition(input: {
+    master: boolean | undefined;
+    isInteractive: boolean;
+    autoPrint: boolean;
+    nonInteractiveError?: string;
+}): void;

package/dist/types/master-mode/first-request.d.ts

@@ -0,0 +1,34 @@
+import type { MasterScope } from "./context";
+import { type MasterPeerSnapshotLifecycle } from "./snapshot";
+export declare const MASTER_PEER_SNAPSHOT_CUSTOM_TYPE = "master-peer-snapshot";
+/** The injected message shape consumed by the agent-session contributor seam. */
+export interface MasterPeerSnapshotMessage {
+    customType: string;
+    content: string;
+    display: false;
+    attribution: "agent";
+}
+export interface MasterPeerSnapshotContributorInput {
+    readonly lifecycle: MasterPeerSnapshotLifecycle;
+    readonly ownerSessionId: string;
+    /** Current transcript/session identity; differs from ownerSessionId after a branch or switch. */
+    readonly getSessionId?: () => string;
+    readonly scope: MasterScope;
+    /** Live cwd accessor; resolved at injection time, not at registration. */
+    readonly getCwd: () => string;
+    /**
+     * Whether a prior injection was persisted to the session branch. A persisted
+     * block proves a first request was accepted, so later turns never duplicate
+     * it; a pre-accept cancellation persists nothing and the next attempt
+     * re-collects a fresh snapshot.
+     */
+    readonly hasPersistedInjection: () => boolean;
+    readonly onError?: (error: unknown) => void;
+}
+/**
+ * Builds the one-shot before-agent-start contributor that injects the scoped,
+ * no-probe master peer snapshot immediately before the first accepted provider
+ * request. Idle masters never collect: the snapshot is gathered only when a
+ * prompt actually starts.
+ */
+export declare function createMasterPeerSnapshotContributor(input: MasterPeerSnapshotContributorInput): () => Promise<MasterPeerSnapshotMessage | undefined>;

package/dist/types/master-mode/snapshot.d.ts

@@ -0,0 +1,32 @@
+import { type ResolvedScopeV1, type ScopeNameV1, type ScopeRequestV1, type SdkSearchResultV1, type SdkSearchRowV1 } from "../sdk/broker/session-scope";
+import type { SessionLifecycleActor, SessionListOutcome, SessionListRequest } from "../sdk/lifecycle/service";
+export type MasterPeerSnapshot = {
+    readonly status: SdkSearchResultV1["status"];
+    readonly scope: ResolvedScopeV1;
+    readonly observedAt: string;
+    readonly indexSeq?: number;
+    readonly rows: readonly SdkSearchRowV1[];
+    readonly truncated?: boolean;
+};
+/** The scoped Broker surface needed for the one-time master peer snapshot. */
+export interface MasterPeerSnapshotLifecycle {
+    list(request: Omit<SessionListRequest, "operation">): Promise<SessionListOutcome>;
+}
+export interface CollectMasterPeerSnapshotInput {
+    readonly lifecycle: MasterPeerSnapshotLifecycle;
+    readonly actor: SessionLifecycleActor;
+    readonly ownerSessionId: string;
+    readonly currentSessionId?: string;
+    readonly scope: ScopeNameV1;
+    readonly requestAnchor: ScopeRequestV1["requestAnchor"];
+    readonly timeoutMs?: number;
+}
+/**
+ * Collects the first-request peer snapshot through scoped Broker session.list.
+ * It deliberately has no Router or endpoint-probe dependency.
+ */
+export declare function collectMasterPeerSnapshot(input: CollectMasterPeerSnapshotInput): Promise<MasterPeerSnapshot>;
+/** Escapes untrusted metadata before it is placed in fixed prompt framing. */
+export declare function escapeMasterPeerSnapshotText(input: string): string;
+/** Renders the fixed, escaped prompt block for one master peer observation. */
+export declare function renderMasterPeerSnapshot(snapshot: MasterPeerSnapshot): string;

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

@@ -1,5 +1,15 @@
 import { Container } from "@gajae-code/tui";
 import type { OnboardingProfile } from "../../setup/frictionless-onboarding";
+import { type UiLanguage } from "../ui-language";
+export declare const UI_LANGUAGE_CHOICES: readonly {
+    value: UiLanguage;
+    label: string;
+}[];
+export declare class InterfaceLanguageSelectorComponent extends Container {
+    #private;
+    constructor(onSelect: (language: UiLanguage) => void, onCancel: () => void);
+    handleInput(keyData: string): void;
+}
 export type FrictionlessOnboardingAction = "analyze" | "apply" | "skip" | "later" | "manual" | "manual-migration" | "manual-learn";
 export type FrictionlessOnboardingStage = "disclosure" | "manual" | "preview";
 export interface FrictionlessOnboardingCopy {