@gajae-code/coding-agent 0.9.6 → 0.10.1

package/dist/types/coordinator-mcp/server.d.ts

@@ -1,5 +1,8 @@
 import { COORDINATOR_MCP_PROTOCOL_VERSION, COORDINATOR_MCP_SERVER_NAME, COORDINATOR_MCP_TOOL_NAMES, type CoordinatorToolName } from "../coordinator/contract";
+import { type OwnerIsolationProbe } from "../gjc-runtime/tmux-owner-isolation";
+import { type CoordinatorModelProfileLoader } from "./model-preset";
 import { type CoordinatorMcpConfig } from "./policy";
+import { type SessionReaper } from "./session-reaper";
 export type { CoordinatorToolName };
 export { COORDINATOR_MCP_PROTOCOL_VERSION, COORDINATOR_MCP_SERVER_NAME, COORDINATOR_MCP_TOOL_NAMES };
 interface JsonRpcRequest {
@@ -22,20 +25,32 @@ interface JsonRpcResponse {
 interface SessionStartInput {
     cwd: string;
     prompt?: string;
+    mpreset?: string | null;
     namespace: {
         profile: string | null;
         repo: string | null;
     };
     worktree: true;
+    sessionId: string;
+    launchId: string;
+    /** Canonical, coordinator-owned immutable readiness marker path. */
+    readinessMarkerFile: string;
+    /** @deprecated Compatibility alias for injected launch providers. */
+    readinessFile: string;
 }
+interface CommandResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+type CommandRunner = (command: string[], stdinLine?: string) => Promise<CommandResult>;
 interface CoordinatorServices {
     listSessions?: () => unknown[] | Promise<unknown[]>;
     startSession?: (input: SessionStartInput) => unknown | Promise<unknown>;
-    commandRunner?: (command: string[]) => Promise<{
-        exitCode: number;
-        stdout: string;
-        stderr: string;
-    }>;
+    commandRunner?: CommandRunner;
+    forceCloseSession?: (sessionName: string, env: NodeJS.ProcessEnv, expectedSessionId?: string, expectedStateFile?: string) => Promise<unknown>;
+    ownerIsolationProbe?: OwnerIsolationProbe;
+    resolveModelProfiles?: CoordinatorModelProfileLoader;
 }
 interface CoordinatorMcpServerOptions {
     env?: NodeJS.ProcessEnv;
@@ -43,16 +58,35 @@ interface CoordinatorMcpServerOptions {
 }
 interface LegacyHandlerOptions {
     env?: NodeJS.ProcessEnv;
-    createSession?: () => unknown;
+    createSession?: (input: SessionStartInput) => unknown;
 }
+/**
+ * Append an authoritative `--mpreset <profile>` to the coordinator child launch
+ * command so the spawned GJC session activates the selected profile from its
+ * first turn. The profile name is validated against the merged registry before
+ * reaching here; it is still shell-quoted as defense in depth.
+ *
+ * Precedence note: this matches `gjc --mpreset <profile>` semantics exactly, so
+ * an explicit model-affecting flag already present in the operator-configured
+ * `sessionCommand` (e.g. a `--model`/`--thinking` baked into the launch command)
+ * follows the same CLI precedence as a direct `gjc --mpreset ... --model ...`
+ * invocation. The effective profile recorded on the session is the
+ * coordinator-resolved request, not a child-attested activation receipt; a
+ * cross-process activation receipt is a possible future enhancement and is out
+ * of scope for the per-session selection contract here.
+ */
+export declare function buildCoordinatorSessionCommand(sessionCommand: string, mpreset: string | null | undefined): string;
 export declare const COORDINATOR_AWAIT_TURN_TIMEOUT_MAX_MS: number;
 export declare const COORDINATOR_RUNTIME_PROMPT_ACK_TIMEOUT_MAX_MS: number;
+export declare const COORDINATOR_RUNTIME_READINESS_TIMEOUT_MAX_MS: number;
 export declare const COORDINATOR_EVENT_WATCH_TIMEOUT_MAX_MS = 30000;
 export declare const COORDINATOR_POLL_INTERVAL_MAX_MS = 10000;
 export declare function boundedAwaitTurnTimeoutMs(value: unknown): number;
 export declare function boundedRuntimePromptAckTimeoutMs(value: unknown): number;
+export declare function boundedRuntimeReadinessTimeoutMs(value: unknown): number;
 export declare function boundedEventWatchTimeoutMs(value: unknown): number;
 export declare function boundedPollIntervalMs(value: unknown): number;
+export declare function coordinatorOwnerIsolationProbe(runner: CommandRunner): Promise<OwnerIsolationProbe>;
 export declare function readCoordinatorArtifact(config: CoordinatorMcpConfig, args: {
     path: unknown;
 }): Promise<Record<string, unknown>>;
@@ -61,6 +95,45 @@ export declare function createCoordinatorMcpServer(options?: CoordinatorMcpServe
     callTool: (name: string, args?: Record<string, unknown>) => Promise<Record<string, unknown>>;
     handleJsonRpc: (request: JsonRpcRequest) => Promise<JsonRpcResponse>;
     handle: (request: JsonRpcRequest) => Promise<JsonRpcResponse>;
+    reapSession: (rawId: unknown, opts?: {
+        force?: boolean;
+        reason?: string;
+    }) => Promise<{
+        ok: boolean;
+        reason?: string;
+        killed: boolean;
+        active_turn_id?: string;
+        detail?: string;
+    }>;
+    sessionReaper: SessionReaper;
 };
 export declare function handleCoordinatorMcpRequest(request: JsonRpcRequest, options?: LegacyHandlerOptions): Promise<JsonRpcResponse>;
+export interface PumpCoordinatorOptions {
+    /** Max concurrent in-flight *data* (non-control) handlers. Control frames (ping) bypass this. */
+    maxDataConcurrency?: number;
+    /** Max data requests queued waiting for a slot before overflow is rejected as server_busy. */
+    maxQueueDepth?: number;
+    /** Bounded wait for in-flight handlers/writes to settle after input ends. */
+    drainTimeoutMs?: number;
+}
+/**
+ * Pump a newline-delimited JSON-RPC stream with BOUNDED concurrent dispatch.
+ *
+ * A long-running tool call (e.g. gjc_coordinator_await_turn, which polls for
+ * minutes) must not block the read loop from answering keepalive pings on the
+ * same stdio channel. But naive unbounded concurrency reintroduces its own
+ * hazards, so this pump enforces the safety envelope the coordinator needs:
+ *
+ *  - Control frames (ping) bypass the data-concurrency cap → keepalive is always
+ *    answerable even while data handlers saturate.
+ *  - Data handlers are capped at `maxDataConcurrency`; excess is queued up to
+ *    `maxQueueDepth`, then rejected as `server_busy` (bounded memory / fanout).
+ *  - A coded local `EPIPE` terminalizes writer and dispatch together; other
+ *    writer faults reject the pump without poisoning the serialized write chain.
+ *  - On EOF or a closed peer the pump drains already-running handlers (bounded
+ *    by `drainTimeoutMs`) and never promotes queued work.
+ *  - Byte chunks are decoded with a streaming decoder so multibyte characters
+ *    split across chunks are not corrupted.
+ */
+export declare function pumpCoordinatorMcpStream(handleJsonRpc: (request: JsonRpcRequest) => Promise<JsonRpcResponse>, input: AsyncIterable<string | Uint8Array>, writeLine: (line: string) => void | Promise<void>, options?: PumpCoordinatorOptions): Promise<void>;
 export declare function runCoordinatorMcpStdio(options?: CoordinatorMcpServerOptions): Promise<void>;

package/dist/types/coordinator-mcp/session-reaper.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Idle reaper for coordinator-managed GJC worker sessions.
+ *
+ * Every `gjc_delegate_*` call that omits `session_id` starts a fresh tmux worker
+ * session. Nothing in the coordinator ever tore those down, so completed/crashed
+ * sessions accumulated (RAM + worktrees) until something killed them by hand.
+ *
+ * This is the automatic backstop (defense-in-depth): a periodic sweep force-closes
+ * sessions that are (a) ephemeral — coordinator delegate-created, never a user's
+ * registered resident session, (b) not mid-turn, and (c) idle past a TTL.
+ *
+ * The controller is pure + fully injectable (clock / list / reap side-effects) so
+ * it is unit-testable without tmux, the filesystem, or wall-clock waits. The
+ * scheduling mirrors the proven resource-gc controller: a recursive setTimeout
+ * with a generation guard so a stop()+start() can never leak a duplicate timer.
+ */
+export declare const DEFAULT_SESSION_IDLE_TTL_MS: number;
+export declare const DEFAULT_SESSION_SWEEP_INTERVAL_MS: number;
+export declare const MIN_SESSION_IDLE_TTL_MS = 60000;
+export declare const MIN_SESSION_SWEEP_INTERVAL_MS = 30000;
+/** Minimal projection of a coordinator session the reaper needs to decide. */
+export interface ReapableSession {
+    sessionId: string;
+    /** True only for coordinator delegate-created sessions. User-registered resident sessions are false and never reaped. */
+    ephemeral: boolean;
+    /** Epoch ms of last observed activity (turn update / session-state write / session creation). */
+    lastActivityMs: number;
+    /** True while a turn is active — never reap mid-turn. */
+    hasActiveTurn: boolean;
+}
+export interface SessionReaperPolicy {
+    idleTtlMs: number;
+    sweepIntervalMs: number;
+}
+/**
+ * Pure selection: which sessions are safe to reap at `now`.
+ * A session is reapable iff ephemeral AND not mid-turn AND idle ≥ (clamped) TTL.
+ */
+export declare function selectReapableSessions(sessions: readonly ReapableSession[], now: number, idleTtlMs: number): ReapableSession[];
+/** Injectable side-effects so the controller runs in tests without tmux/fs/real time. */
+export interface SessionReaperDeps {
+    listSessions: () => Promise<ReapableSession[]>;
+    reapSession: (sessionId: string) => Promise<void>;
+    now: () => number;
+}
+export interface SessionReaper {
+    /** Run one sweep; returns the number of sessions successfully reaped. */
+    sweepOnce: () => Promise<number>;
+    start: () => void;
+    stop: () => void;
+    readonly running: boolean;
+}
+export declare function createSessionReaper(deps: SessionReaperDeps, policy: SessionReaperPolicy): SessionReaper;

package/dist/types/daemon/control-types.d.ts

@@ -40,6 +40,14 @@ export interface DaemonOperationOptions {
     /** For reload: spawn a fresh owner even when none is currently running. */
     spawnIfStopped?: boolean;
 }
+export interface DaemonRecovery {
+    /** Machine-readable recovery category for automation branching. */
+    reason: "ownership_mismatch";
+    /** One-line human summary of why the operation could not proceed. */
+    summary: string;
+    /** Ordered, copy-pasteable remediation steps. */
+    steps: string[];
+}
 export interface DaemonOperationResult {
     kind: DaemonKind;
     action: Exclude<DaemonAction, "list">;
@@ -48,6 +56,8 @@ export interface DaemonOperationResult {
     after?: DaemonStatus;
     warnings: string[];
     message: string;
+    /** Present when the operation was refused with an actionable recovery path (e.g. ownership mismatch). */
+    recovery?: DaemonRecovery;
 }
 export interface BuiltInDaemonController {
     readonly kind: DaemonKind;

package/dist/types/daemon/operator-contract.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Shared operator contract for the `gjc daemon` command surface.
+ *
+ * One source of truth for the beginner-safe operational vocabulary so the
+ * guided human surface and the machine-readable JSON never drift:
+ * - the terse action verbs plus operator aliases (e.g. `restart` -> `reload`),
+ * - process exit codes,
+ * - concise vs. `--verbose` human rendering of statuses and results, and
+ * - actionable recovery guidance for a token/chat ownership mismatch.
+ *
+ * The full roots/debug payload lives behind `--verbose` (human) or `--json`
+ * (automation); the default human output stays a concise per-daemon result.
+ */
+import type { DaemonAction, DaemonOperationResult, DaemonRecovery, DaemonStatus } from "./control-types";
+/** Canonical daemon actions accepted as the leading verb. */
+export declare const DAEMON_CANONICAL_ACTIONS: readonly DaemonAction[];
+/**
+ * Operator-friendly aliases resolved to a canonical action. `restart` is the
+ * routine "reload if running, otherwise start" verb; it maps onto `reload`,
+ * whose default already spawns a fresh owner when none is running.
+ */
+export declare const DAEMON_ACTION_ALIASES: Readonly<Record<string, DaemonAction>>;
+/** Every token accepted in the leading action position (canonical + aliases). */
+export declare const DAEMON_ACTION_TOKENS: readonly string[];
+/** Resolve a leading verb (canonical or alias) to its canonical action. */
+export declare function resolveDaemonAction(token: string | undefined): DaemonAction | undefined;
+/** Exit codes for `gjc daemon`. Backward compatible: success 0, any failure 1. */
+export declare const DAEMON_EXIT: {
+    readonly ok: 0;
+    readonly failure: 1;
+};
+/** Human-facing headline when a spawn/reload is refused by a live foreign identity. */
+export declare const OWNERSHIP_MISMATCH_MESSAGE = "refused: a live Telegram daemon with a different bot token or chat already owns this workspace";
+/** Structured, actionable recovery for a token/chat ownership mismatch. */
+export declare function ownershipMismatchRecovery(): DaemonRecovery;
+/**
+ * Render one daemon status. Concise by default (single head line + any
+ * actionable warning); `--verbose` adds runtime detail and the full roots list.
+ */
+export declare function formatDaemonStatus(status: DaemonStatus, opts?: {
+    verbose?: boolean;
+}): string;
+/**
+ * Render one operation result. Keeps the stable `<kind> <action>: ok|failed —
+ * <message>` head line, then any warnings, then actionable recovery steps.
+ */
+export declare function formatDaemonResult(result: DaemonOperationResult): string;

package/dist/types/defaults/gjc/extensions/grok-cli-vendor/src/models/catalog.d.ts

@@ -1,6 +1,7 @@
 /**
  * Model definitions for Grok CLI's API.
  */
+import { Effort } from '@gajae-code/ai/model-thinking';
 export interface GrokCliModelConfig {
     id: string;
     name: string;
@@ -14,9 +15,12 @@ export interface GrokCliModelConfig {
     };
     contextWindow: number;
     maxTokens: number;
+    /** Highest reasoning effort supported by this model. */
+    maxReasoningEffort?: Effort;
     /** Models that don't support reasoning.effort get a thinkingLevelMap. */
     thinkingLevelMap?: Record<string, string | null>;
 }
+export declare function getMaxReasoningEffort(modelId: string): Effort | undefined;
 export declare function supportsReasoningEffort(modelId: string): boolean;
 /**
  * Resolve the active model list. If `GJC_GROK_CLI_MODELS` is set,

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

@@ -11,7 +11,7 @@ export declare const SOURCE_PATHS: {
     readonly native: {
         readonly userBase: string;
         readonly userAgent: string;
-        projectDir: string;
+        readonly projectDir: string;
     };
     readonly claude: {
         readonly userBase: ".claude";

package/dist/types/discovery/substitute-plugin-root.d.ts

@@ -1,5 +1 @@
-/**
- * Recursively substitute ${ANTHROPIC_MODEL_PLUGIN_ROOT} and ${GJC_PLUGIN_ROOT}
- * with the actual plugin root path in strings, arrays, and plain objects.
- */
 export declare function substitutePluginRoot<T>(value: T, rootPath: string): T;

package/dist/types/extensibility/extensions/types.d.ts

@@ -176,11 +176,13 @@ export interface ExtensionUIContext {
     setToolsExpanded(expanded: boolean): void;
 }
 export interface ContextUsage {
-    /** Estimated context tokens, or null if unknown (e.g. right after compaction, before next LLM response). */
+    /** Context tokens, or null if unknown (e.g. right after compaction, before next LLM response). */
     tokens: number | null;
     contextWindow: number;
     /** Context usage as percentage of context window, or null if tokens is unknown. */
     percent: number | null;
+    /** Provenance: "provider_anchor" = anchored on provider-reported usage (+ heuristic trailing delta); "heuristic" = no provider anchor available, full estimate; "unknown" = post-compaction, no post-compaction provider response yet. */
+    source: "provider_anchor" | "heuristic" | "unknown";
 }
 export interface CompactOptions {
     onComplete?: (result: CompactionResult) => void;

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

@@ -1,10 +1,10 @@
 import type { Args } from "../cli/args";
 import { buildGjcTmuxExactSessionTarget, buildGjcTmuxProfileCommands, GJC_DEFAULT_TMUX_SESSION, GJC_TMUX_COMMAND_ENV, GJC_TMUX_MOUSE_ENV, GJC_TMUX_PROFILE_ENV, GJC_TMUX_SESSION_PREFIX, type GjcTmuxProfileCommand } from "./tmux-common";
+import { type OwnerIsolationProbeSync } from "./tmux-owner-isolation";
 export { buildGjcTmuxExactSessionTarget, buildGjcTmuxProfileCommands, GJC_DEFAULT_TMUX_SESSION, GJC_TMUX_COMMAND_ENV, GJC_TMUX_MOUSE_ENV, GJC_TMUX_PROFILE_ENV, GJC_TMUX_SESSION_PREFIX, };
 export declare const GJC_TMUX_LAUNCHED_ENV = "GJC_TMUX_LAUNCHED";
 export declare const GJC_LAUNCH_POLICY_ENV = "GJC_LAUNCH_POLICY";
 export declare const GJC_TMUX_WINDOW_LABEL_MAX_WIDTH = 48;
-export declare const GJC_PSMUX_PROFILE_FORCE_ENV = "GJC_PSMUX_PROFILE_FORCE";
 interface TtyState {
     stdin: boolean;
     stdout: boolean;
@@ -28,11 +28,19 @@ export interface TmuxLaunchContext {
     existingBranchSessionName?: string | null;
     project?: string | null;
     diagnosticWriter?: (message: string) => void;
+    /**
+     * Synchronous owner-isolation proof boundary for managed tmux creation.
+     * Production uses Linux /proc probes; callers may inject deterministic proofs.
+     */
+    ownerIsolationProbe?: OwnerIsolationProbeSync;
+    /** Test seam for deterministic default-probe caller cgroup classification. */
+    callerCgroupReader?: () => string | null;
 }
 export interface TmuxSpawnResult {
     exitCode: number | null;
     signalCode?: string | null;
     stderr?: string;
+    stdout?: string;
 }
 export interface TmuxTerminalSize {
     columns: number;
@@ -46,14 +54,12 @@ export interface TmuxSpawnOptions {
     stdout: "inherit" | "pipe";
     stderr: "inherit" | "pipe";
     /**
-     * When true, the spawn captures stderr into a buffer and forwards it to
-     * the parent stderr so the user still sees the live output. The captured
-     * text is also returned in TmuxSpawnResult.stderr for diagnostic
-     * surfacing in "attach failed" / "profile tagging failed" messages.
-     * Defaults to false to preserve the previous PTY-binding behavior for
-     * attach-session and other interactive commands.
+     * Captures control-plane stderr for sanitized, bounded diagnostics. PTY-bound
+     * commands retain inherited stderr for multiplexer compatibility.
      */
     captureStderr?: boolean;
+    /** Internal scoped-bootstrap input; never used for ordinary tmux commands. */
+    stdinLine?: string;
 }
 export interface TmuxLaunchPlan {
     tmuxCommand: string;
@@ -67,6 +73,17 @@ export interface TmuxLaunchPlan {
     project?: string | null;
     sessionId?: string | null;
     sessionStateFile?: string | null;
+    /** Immutable Linux-managed owner provenance, assigned immediately before creation. */
+    ownerGeneration?: string;
+    /** Generation state captured before owner-isolation planning; required for publication CAS. */
+    ownerGenerationBaseline?: import("./tmux-owner-isolation").OwnerGenerationBaseline;
+    /** Native tmux session identity emitted atomically by `new-session -P -F`. */
+    createdSessionId?: string;
+    /** Safe server identity proven immediately after creation. */
+    createdServerIdentity?: {
+        pid: number;
+        startTime: string;
+    };
     isPsmux: boolean;
     platform: NodeJS.Platform;
 }
@@ -89,6 +106,8 @@ export interface GjcTmuxProfileContext {
     project?: string | null;
     sessionId?: string | null;
     sessionStateFile?: string | null;
+    ownerGeneration?: string | null;
+    ownerServerKey?: string | null;
     version?: string | null;
 }
 export declare function applyGjcTmuxProfile(context: GjcTmuxProfileContext): GjcTmuxProfileResult;

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

@@ -1,7 +1,23 @@
 import { postmortem } from "@gajae-code/utils";
+/** Managed tmux owner provenance propagated only to the launched child process. */
+export declare const GJC_TMUX_OWNER_GENERATION_ENV = "GJC_TMUX_OWNER_GENERATION";
+export declare const GJC_TMUX_OWNER_STATE_DIR_ENV = "GJC_TMUX_OWNER_STATE_DIR";
+export declare const GJC_TMUX_OWNER_SERVER_KEY_ENV = "GJC_TMUX_OWNER_SERVER_KEY";
 export declare const GJC_COORDINATOR_SESSION_STATE_FILE_ENV = "GJC_COORDINATOR_SESSION_STATE_FILE";
 export declare const GJC_COORDINATOR_SESSION_ID_ENV = "GJC_COORDINATOR_SESSION_ID";
 export declare const GJC_COORDINATOR_SESSION_BRANCH_ENV = "GJC_COORDINATOR_SESSION_BRANCH";
+export declare const GJC_COORDINATOR_SESSION_LAUNCH_ID_ENV = "GJC_COORDINATOR_SESSION_LAUNCH_ID";
+export declare const GJC_COORDINATOR_SESSION_READINESS_FILE_ENV = "GJC_COORDINATOR_SESSION_READINESS_FILE";
+export type RuntimeInputReadyMarker = Readonly<{
+    schema_version: 1;
+    session_id: string;
+    launch_id: string;
+    state: "ready_for_input";
+    event: "interactive_input_ready";
+    source: "gjc_interactive_runtime";
+    ready_for_input: true;
+    created_at: string;
+}>;
 export type RuntimeState = "ready_for_input" | "running" | "needs_user_input" | "completed" | "errored";
 /** Test-only counters for runtime sidecar hot-path assertions. */
 export declare const __sessionStateSidecarPerfCounters: {
@@ -12,19 +28,33 @@ interface RuntimeStateEvent {
     type: string;
     messages?: unknown[];
 }
-interface RuntimeStateContext {
+export interface OwnerTerminalContext {
+    generation: string;
+    stateDir: string;
+    socketKey: string;
+    scope?: string | null;
+    ownerPid?: number | null;
+    ownerName?: string | null;
+    operatorDispatchId?: string | null;
+}
+export interface RuntimeStateContext {
     sessionId: string;
     cwd: string;
     sessionFile?: string | null;
     branch?: string | null;
+    /** Public-safe owner metadata used to persist the canonical terminal verdict. */
+    ownerTerminal?: OwnerTerminalContext | null;
+    /** Internal fail-closed marker set only when managed owner metadata is malformed or missing. */
+    ownerTerminalMetadataInvalid?: boolean;
 }
 export type TerminalRuntimeStateStatus = {
     terminal: true;
     state: "completed" | "errored";
 } | {
     terminal: false;
-    reason: "missing_state_file" | "invalid_json" | "session_id_mismatch" | "cwd_mismatch" | "session_file_mismatch" | "non_terminal_state";
+    reason: "missing_state_file" | "invalid_json" | "invalid_state_marker" | "session_id_mismatch" | "cwd_mismatch" | "session_file_mismatch" | "non_terminal_state";
 };
+export declare function persistCoordinatorRuntimeInputReady(): Promise<RuntimeInputReadyMarker | null>;
 export declare function readTerminalRuntimeStateMarker(input: {
     stateFile?: string | null;
     sessionId?: string | null;
@@ -34,6 +64,7 @@ export declare function readTerminalRuntimeStateMarker(input: {
 export declare function stateForEvent(event: RuntimeStateEvent): RuntimeState | null;
 export declare function eventAffectsCoordinatorRuntimeState(event: RuntimeStateEvent): boolean;
 export declare function persistCoordinatorRuntimeStateFromEvent(event: RuntimeStateEvent, context: RuntimeStateContext): Promise<void>;
-export declare function persistCoordinatorRuntimeStateFromPostmortem(reason: postmortem.Reason, context: RuntimeStateContext): void;
+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 {};

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

@@ -12,6 +12,8 @@ export declare const GJC_TMUX_BRANCH_SLUG_OPTION = "@gjc-branch-slug";
 export declare const GJC_TMUX_PROJECT_OPTION = "@gjc-project";
 export declare const GJC_TMUX_SESSION_ID_OPTION = "@gjc-session-id";
 export declare const GJC_TMUX_SESSION_STATE_FILE_OPTION = "@gjc-session-state-file";
+export declare const GJC_TMUX_OWNER_GENERATION_OPTION = "@gjc-owner-generation";
+export declare const GJC_TMUX_OWNER_SERVER_KEY_OPTION = "@gjc-owner-server-key";
 export declare const GJC_TMUX_VERSION_OPTION = "@gjc-version";
 export declare const GJC_PSMUX_PROFILE_FORCE_ENV = "GJC_PSMUX_PROFILE_FORCE";
 export interface GjcTmuxProfileCommand {
@@ -89,6 +91,8 @@ export declare function buildGjcTmuxRequiredProfileCommands(target: string, meta
     project?: string | null;
     sessionId?: string | null;
     sessionStateFile?: string | null;
+    ownerGeneration?: string | null;
+    ownerServerKey?: string | null;
     version?: string | null;
 }): GjcTmuxProfileCommand[];
 export declare function buildGjcTmuxProfileCommands(target: string, env?: NodeJS.ProcessEnv, metadata?: {
@@ -97,6 +101,8 @@ export declare function buildGjcTmuxProfileCommands(target: string, env?: NodeJS
     project?: string | null;
     sessionId?: string | null;
     sessionStateFile?: string | null;
+    ownerGeneration?: string | null;
+    ownerServerKey?: string | null;
     version?: string | null;
 }, opts?: {
     platform?: NodeJS.Platform;

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

@@ -0,0 +1,5 @@
+/** Matches the sole argv shape allowed to enter the owner-isolation JSON-line protocol. */
+export declare function isTmuxOwnerIsolationCliArgv(argv: readonly string[]): boolean;
+/** Reads exactly one bounded JSON line and writes exactly one JSON response line. */
+export declare function runTmuxOwnerIsolationCli(stdin: string): Promise<string>;
+export declare function runTmuxOwnerIsolationCliFromStdin(): Promise<void>;