@gajae-code/coding-agent 0.15.5 → 0.16.0

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 (日本語)";
@@ -1888,6 +1897,15 @@ export declare const SETTINGS_SCHEMA: {
             }];
         };
     };
+    readonly "telemetry.enabled": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "interaction";
+            readonly label: "Anonymous Usage Telemetry";
+            readonly description: "Send minimal allowlisted update and adoption events. Disabled by default; no prompts, paths, environment, identity, or arbitrary errors are collected.";
+        };
+    };
     readonly "starReminder.enabled": {
         readonly type: "boolean";
         readonly default: true;

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/model-preset.d.ts

@@ -2,20 +2,22 @@ export interface CoordinatorModelProfile {
     name: string;
 }
 /**
- * Loads the merged built-in + custom model-profile names from `models.yml`
+ * Loads the merged embedded + accepted registry + custom model-profile names
  * without loading the session-host model registry. The child still owns
  * profile activation; this validates the selection before session creation.
  */
 export type CoordinatorModelProfileLoader = () => Map<string, CoordinatorModelProfile> | Promise<Map<string, CoordinatorModelProfile>>;
 /**
- * Thrown by the default loader when `models.yml` exists but is invalid or
- * unreadable. This lets the resolver fail closed with a distinct, stable reason
- * instead of silently collapsing a broken registry to the built-ins-only set
- * (which would misreport a caller's valid custom profile as unknown).
+ * Thrown by the default loader when `models.yml` or the accepted preset
+ * registry is invalid or unreadable. This lets the resolver fail closed with a
+ * distinct, stable reason instead of silently collapsing a broken registry to
+ * the built-ins-only set (which would misreport a caller's valid custom
+ * profile as unknown).
  */
 export declare class CoordinatorModelProfileRegistryError extends Error {
     constructor(cause?: unknown);
 }
+export declare function createCoordinatorModelProfileLoader(agentDir: string): CoordinatorModelProfileLoader;
 export declare const loadCoordinatorModelProfiles: CoordinatorModelProfileLoader;
 export type CoordinatorMpresetResolution = {
     ok: true;

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

@@ -0,0 +1,54 @@
+/** Test-only platform seam; production always follows the host platform. */
+export declare const ProjectionScanTestHooks: {
+    platform?: NodeJS.Platform;
+};
+/** 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;
+    ino?: number | bigint;
+    nlink?: number | bigint;
+    mtimeNs?: number | bigint;
+    ctimeNs?: number | bigint;
+    isDirectory?(): boolean;
+    isFile(): boolean;
+    isSymbolicLink(): boolean;
+}
+export interface ProjectionScanFs {
+    readdir(dir: string): Promise<string[]>;
+    lstat(file: string): Promise<ProjectionScanStat>;
+    readFile(file: string, encoding: "utf8", expected?: ProjectionScanStat): Promise<string>;
+    /** Optional descriptor-bound reader used by the production filesystem. */
+    readFileSafe?: (file: string, encoding: "utf8", expected?: ProjectionScanStat) => Promise<string>;
+    /** Optional pinned directory authority used for enumeration and every child operation. */
+    openDirectory?: (dir: string) => Promise<ProjectionScanDirectory>;
+}
+export interface ProjectionScanDirectory {
+    readonly stat: ProjectionScanStat;
+    readdir(): Promise<string[]>;
+    lstat(entry: string): Promise<ProjectionScanStat>;
+    readFile(entry: string, encoding: "utf8", expected?: ProjectionScanStat): Promise<string>;
+    close(): Promise<void>;
+}
+export interface ProjectionScanResult {
+    values: unknown[];
+    parsed: number;
+    capped: boolean;
+    skippedDebris: number;
+    skippedEmpty: number;
+    /** Candidates that changed or disappeared after enumeration. */
+    raced: number;
+    /** True when the scan cannot be authoritative for its caller. */
+    incomplete: boolean;
+}
+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/extensibility/extensions/types.d.ts

@@ -344,7 +344,7 @@ export interface ExtensionContext {
             cleanedArgs?: string;
         }) => void;
         preflightSignal?: AbortSignal;
-        sdkRunToken?: string;
+        sdkRunCapability?: unknown;
     }): Promise<unknown>;
     setPlanMode?(on: boolean): unknown;
     operateGoal?(op: "create" | "get" | "resume" | "pause" | "complete" | "drop", objective?: string): Promise<unknown>;
@@ -844,8 +844,6 @@ export interface ExtensionAPI {
             startsOwnRun: boolean;
         }) => void;
         preflightSignal?: AbortSignal;
-        /** Internal SDK correlation owner for an exact queued follow-up. */
-        sdkRunToken?: string;
     }): Promise<void>;
     /** Append a custom entry to the session for state persistence (not sent to LLM). */
     appendEntry<T = unknown>(customType: string, data?: T): void;
@@ -1031,8 +1029,6 @@ export type SendUserMessageHandler = (content: string | (TextContent | ImageCont
         removed?: boolean;
     }) => void;
     preflightSignal?: AbortSignal;
-    /** Internal SDK correlation owner for an exact queued follow-up. */
-    sdkRunToken?: string;
 }) => void | Promise<void>;
 export type AppendEntryHandler = <T = unknown>(customType: string, data?: T) => void;
 export type GetActiveToolsHandler = () => string[];
@@ -1169,6 +1165,7 @@ export interface ExtensionContextActions {
             cleanedArgs?: string;
         }) => void;
         preflightSignal?: AbortSignal;
+        sdkRunCapability?: unknown;
     }) => Promise<unknown>;
     setPlanMode?: (on: boolean) => unknown;
     operateGoal?: (op: "create" | "get" | "resume" | "pause" | "complete" | "drop", objective?: string) => Promise<unknown>;

package/dist/types/gjc-runtime/empty-delete-gc.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Official GC of already-quarantined empty `.gjc-delete-*` receipts.
+ * Roots are operator operands — never hardcoded host paths.
+ */
+import type { BigIntStats } from "node:fs";
+import { exactUnlinkDirect } from "@gajae-code/natives";
+export declare const EMPTY_DELETE_PREFIX = ".gjc-delete-";
+export interface EmptyDeleteIdentity {
+    dev: bigint;
+    ino: bigint;
+    nlink: bigint;
+    size: bigint;
+    mtimeNs: bigint;
+    parentDev: bigint;
+    parentIno: bigint;
+    sha256: string;
+}
+export interface EmptyDeleteGcRecord {
+    root: string;
+    path: string;
+    action: "would_remove" | "removed" | "kept" | "skipped";
+    reason: string;
+    identity?: EmptyDeleteIdentity;
+    /** A dry-run candidate is an observation, never deletion authority. */
+    observationOnly?: boolean;
+    /** Retained-object paths a native direct unlink left behind; operator-recoverable only there. */
+    retainedPaths?: {
+        detached?: string;
+        successor?: string;
+        placeholder?: string;
+        unknown?: string;
+    };
+}
+export interface EmptyDeleteGcReport {
+    dry_run: boolean;
+    roots: string[];
+    records: EmptyDeleteGcRecord[];
+    would_remove: number;
+    removed: number;
+    kept: number;
+    skipped: number;
+    errors: string[];
+}
+export interface EmptyDeleteGcOptions {
+    roots: string[];
+    prune: boolean;
+}
+export interface EmptyDeleteGcDependencies {
+    /** Internal seam for deterministic collect-to-prune race tests. */
+    collect?: (root: string) => Promise<EmptyDeleteGcRecord[]>;
+    exactUnlinkDirect?: typeof exactUnlinkDirect;
+}
+export declare function collectEmptyDeleteReceipts(root: string, deps?: {
+    lstat?: (file: string, options: {
+        bigint: true;
+    }) => Promise<BigIntStats>;
+}): Promise<EmptyDeleteGcRecord[]>;
+export declare function runEmptyDeleteGc(options: EmptyDeleteGcOptions, deps?: EmptyDeleteGcDependencies): Promise<EmptyDeleteGcReport>;

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

@@ -12,6 +12,7 @@
  *   error all mean KEEP — a live process is never signalled or killed.
  * - Dry-run by default: nothing is deleted unless `--prune`/`--force`.
  */
+import { type EmptyDeleteGcReport } from "./empty-delete-gc";
 import { type GcSessionScopeUsage } from "./gc-session-scope";
 export type GcStore = "harness_leases" | "file_locks" | "tmux_sessions" | "registry_entries" | "local_roots";
 export declare const GC_STORES: readonly GcStore[];
@@ -127,6 +128,7 @@ export interface GcReport {
      * PID-liveness axis above is unchanged by its absence or presence.
      */
     disk?: GcDiskReport;
+    empty_delete_receipts?: EmptyDeleteGcReport;
 }
 export interface GcRunResult {
     stdout: string;

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-lock.d.ts

@@ -62,6 +62,12 @@ export declare const SessionStateLockTestHooks: {
     unqualifiedOwnerIsLocal?: boolean;
     /** @internal Runs after final live-owner validation and before descriptor rewrite. */
     afterCurrentOwnerValidation?: (file: string) => void | Promise<void>;
+    /** @internal Fault seam immediately before a held owner record rewrite mutates bytes. */
+    beforeOwnerRecordRewrite?: (file: string) => void | Promise<void>;
+    /** @internal Fault seam immediately before final transition-generation validation. */
+    beforeTransitionReleaseLstat?: (transitionDir: string) => void | Promise<void>;
+    /** @internal Fault seam immediately before setup generation capture. */
+    beforeTransitionSetupLstat?: (transitionDir: string) => void | Promise<void>;
     /**
      * @internal Runs after a live owner has been proven and immediately before its
      * final pathname capture for release. Tests use it to replace the pathname and
@@ -69,10 +75,30 @@ export declare const SessionStateLockTestHooks: {
      */
     beforeCurrentOwnerRelease?: (file: string) => void | Promise<void>;
     beforeLegacyDirectoryRemoval?: (lockDir: string) => void | Promise<void>;
+    /** @internal Last quarantine name minted in the current lock cycle (tests). */
+    lastQuarantineName?: string;
+    /** @internal Count of quarantine names minted in the current lock cycle (tests). */
+    quarantineMints?: number;
+    /** @internal Force the next mint to this name so leftover-collision tests can plant it. */
+    forcedQuarantineName?: string;
+    /** @internal Observes bounded acquisition retries without changing their timing. */
+    afterAcquireContention?: (lockFile: string, attempt: number, elapsedMs: number) => void;
 };
 /** Raised when the lock could not be acquired; callers map it to their own refusal. */
+export type SessionStateLockUnavailableReason = "acquire_timeout" | "legacy_directory_owner_unprovenanced" | "lock_initialization_failed" | "lock_inspection_failed" | "lock_owner_live_or_unverifiable" | "lock_owner_record_fresh" | "lock_owner_record_unprovenanced" | "lock_release_failed" | "transition_claim_timeout" | "unsafe_lock_path_type";
+interface SessionStateLockUnavailableDetails {
+    lockPath: string;
+    reason: SessionStateLockUnavailableReason;
+    attempts?: number;
+    elapsedMs?: number;
+    cause?: unknown;
+}
 export declare class SessionStateLockUnavailableError extends Error {
-    constructor(cause?: unknown);
+    readonly lockPath?: string;
+    readonly reason?: SessionStateLockUnavailableReason;
+    readonly attempts?: number;
+    readonly elapsedMs?: number;
+    constructor(causeOrDetails?: unknown | SessionStateLockUnavailableDetails);
 }
 /**
  * The identity-bound deletion primitives this lock is built on.
@@ -85,7 +111,7 @@ export declare class SessionStateLockUnavailableError extends Error {
  * caller proved. A replacement is therefore never deleted, by construction rather than by
  * a narrower window.
  */
-export type SessionStateLockNativeBindings = Pick<typeof import("@gajae-code/natives"), "exactRemoveDirectoryTree" | "exactUnlink" | "snapshotDirectoryTree">;
+export type SessionStateLockNativeBindings = Pick<typeof import("@gajae-code/natives"), "exactRemoveDirectoryTree" | "exactUnlink" | "exactUnlinkDirect" | "snapshotDirectoryTree">;
 /** How the deletion primitives are obtained. Throwing means they are unavailable. */
 type SessionStateLockNativeLoader = () => SessionStateLockNativeBindings;
 /**
@@ -102,12 +128,15 @@ type SessionStateLockNativeLoader = () => SessionStateLockNativeBindings;
  */
 export declare function setSessionStateLockNativeBindings(load: SessionStateLockNativeLoader | undefined): void;
 /**
- * Decide what actually occupies the lock path, without following it.
+ * Verified empty leftover at a reserved quarantine name is incomplete debris, not
+ * in-progress cleanup.
  *
- * @internal exported as the seam these decisions are tested through: a live legacy
- * directory owner must be provably left alone without waiting out a real stale window.
+ * Deletion authority is the native identity-bound direct unlink — never a plain
+ * pathname unlink. A replacement planted at the reserved name between observation
+ * and deletion has a different inode identity and is refused by construction.
  */
-export declare function reclaimStaleSessionStateLock(lockFile: string): Promise<void>;
+export declare function removeVerifiedEmptyQuarantine(directory: string, name: string): Promise<void>;
+export declare function reclaimStaleSessionStateLock(lockFile: string, quarantineName?: string): Promise<void>;
 /**
  * Serialize one read-modify-write of `stateFile` against every other holder of
  * `<stateFile>.lock`.

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;
@@ -195,7 +208,65 @@ export declare function persistCoordinatorRuntimeStateFromEvent(event: RuntimeSt
  * sidecar never trusts a model-supplied name.
  */
 observation?: CoordinatorToolObservation): Promise<void>;
+export declare function persistCoordinatorWorkerIntegrationOutcome(context: RuntimeStateContext, outcome: {
+    kind: "worker_integration" | "terminal_persistence";
+    status: "completed" | "failed" | "timed_out";
+    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/index.d.ts

@@ -28,6 +28,7 @@ export * from "./session/session-dump-format";
 export * from "./session/session-manager";
 export * from "./task/executor";
 export type * from "./task/types";
+export * from "./telemetry";
 export * from "./tools";
 export * from "./utils/git";
 export { HookEditorComponent as ExtensionEditorComponent, HookInputComponent as ExtensionInputComponent, HookSelectorComponent as ExtensionSelectorComponent, };

package/dist/types/main.d.ts

@@ -47,7 +47,9 @@ export interface InteractiveModeNotify {
     kind: "warn" | "error" | "info";
     message: string;
 }
-export declare function submitInteractiveInput(mode: Pick<InteractiveMode, "markPendingSubmissionStarted" | "finishPendingSubmission" | "showError" | "checkShutdownRequested" | "waitForAgentEnd">, session: Pick<AgentSession, "prompt" | "promptCustomMessage">, input: SubmittedUserInput): Promise<void>;
+export declare function submitInteractiveInput(mode: Pick<InteractiveMode, "markPendingSubmissionStarted" | "finishPendingSubmission" | "showError" | "checkShutdownRequested" | "waitForAgentEnd">, session: Pick<AgentSession, "prompt" | "promptCustomMessage"> & {
+    continuePersistedHistory?: AgentSession["continuePersistedHistory"];
+}, input: SubmittedUserInput): Promise<void>;
 type StartupModelProfileArgs = {
     session: AgentSession;
     settings: Settings;

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;