@sayknow-cli/coding-agent 0.3.12 → 0.3.15

package/dist/types/session/session-manager.d.ts

@@ -1,10 +1,10 @@
-import type { AgentMessage } from "@sayknow-cli/agent-core";
+import { type AgentMessage } from "@sayknow-cli/agent-core";
 import type { ImageContent, Message, MessageAttribution, ServiceTier, TextContent } from "@sayknow-cli/ai";
 import type { TtsrInjectionRecord } from "../export/ttsr";
 import { ArtifactManager } from "./artifacts";
 import { type BlobPutResult, BlobStore } from "./blob-store";
 import { type BashExecutionMessage, type CustomMessage, type FileMentionMessage, type HookMessage, type PythonExecutionMessage } from "./messages";
-import type { SessionStorage } from "./session-storage";
+import type { SessionStorage, SessionStorageStat, VerifiedSessionDeleteResult, VerifiedSessionDeleteTarget } from "./session-storage";
 export declare const CURRENT_SESSION_VERSION = 3;
 export interface SessionHeader {
     type: "session";
@@ -73,6 +73,13 @@ export interface SessionMessageEntry extends SessionEntryBase {
      *  metadata (not a message field) so strict message types stay intact. */
     evictedContent?: EvictedContentMarker;
 }
+export declare function associateSessionMessageEntryId(message: AgentMessage, entryId: string): void;
+export declare function getSessionMessageEntryId(message: AgentMessage): string | undefined;
+export declare function associateSessionMessageObservationId(message: AgentMessage, observationId: string): string;
+export declare function getSessionMessageObservationId(message: AgentMessage): string | undefined;
+export declare function associateSessionMessageViewportAnchorId(message: AgentMessage, anchorId: string): void;
+export declare function getSessionMessageViewportAnchorId(message: AgentMessage): string | undefined;
+export declare function transferSessionMessageIdentity(source: AgentMessage[], target: AgentMessage[]): void;
 export interface ThinkingLevelChangeEntry extends SessionEntryBase {
     type: "thinking_level_change";
     thinkingLevel?: string | null;
@@ -230,6 +237,40 @@ export interface SessionContext {
     /** Mode-specific data from the last mode_change entry */
     modeData?: Record<string, unknown>;
 }
+/** Immutable fingerprint captured during read-only resume inspection. */
+export interface ResumeSessionIdentity {
+    canonicalPath: string;
+    sessionId: string;
+    dev: bigint;
+    ino: bigint;
+    size: number;
+    mtimeMs: number;
+    mtimeNs: bigint;
+    sha256: string;
+}
+export interface ResumeTailResumable {
+    kind: "resumable";
+    identity: ResumeSessionIdentity;
+}
+export interface ResumeTailTerminal {
+    kind: "terminal";
+    identity: ResumeSessionIdentity;
+}
+export interface ResumeTailError {
+    kind: "error";
+    reason: "missing" | "malformed" | "unstable" | "read-failed";
+}
+export type ResumeTailInspection = ResumeTailResumable | ResumeTailTerminal | ResumeTailError;
+export interface StrictSessionOpenSuccess {
+    kind: "opened";
+    manager: SessionManager;
+}
+export interface StrictSessionOpenFailure {
+    kind: "error";
+    reason: ResumeTailError["reason"] | "identity-mismatch";
+}
+/** Result of opening an inspected session without create-or-rewrite fallback. */
+export type StrictSessionOpenResult = StrictSessionOpenSuccess | StrictSessionOpenFailure;
 export interface SessionInfo {
     path: string;
     id: string;
@@ -246,6 +287,47 @@ export interface SessionInfo {
     firstMessage: string;
     allMessagesText: string;
 }
+/** Kind of failure surfaced by strict scoped inventory. Any failure grants zero authority. */
+export type StrictInventoryFailureKind = "root" | "scan" | "lstat" | "read" | "parse" | "stat" | "header" | "cwd" | "containment" | "identity";
+/** Sanitized strict-inventory failure. Never carries raw file content. */
+export interface StrictInventoryFailure {
+    kind: StrictInventoryFailureKind;
+    message: string;
+    path?: string;
+}
+/** One exact-identity candidate suitable for ACP authorization binding. */
+export interface StrictInventoryCandidate {
+    /** Canonical absolute transcript path. */
+    path: string;
+    /** Session id parsed from the header. */
+    id: string;
+    /** Canonical cwd parsed from the header. */
+    cwd: string;
+    /** Descriptor-bound transcript identity (dev, ino, ...). */
+    identity: SessionStorageStat;
+}
+/**
+ * Strict inventory result. `complete` carries the full validated candidate set;
+ * `failure` carries every sanitized failure and grants zero page/cursor/authority.
+ * A failure result is never reduced to a partial candidate set.
+ */
+export type StrictInventoryResult = {
+    kind: "complete";
+    candidates: StrictInventoryCandidate[];
+} | {
+    kind: "failure";
+    failures: StrictInventoryFailure[];
+};
+/** Certainty-aware close outcome for strict ACP disposal. */
+export type SessionManagerCloseOutcome = {
+    kind: "closed";
+} | {
+    kind: "close_failed_retryable";
+    error: Error;
+} | {
+    kind: "close_unknown";
+    error: Error;
+};
 export type ReadonlySessionManager = Pick<SessionManager, "getCwd" | "getSessionDir" | "getSessionId" | "getSessionFile" | "getSessionName" | "getArtifactsDir" | "getArtifactManager" | "allocateArtifactPath" | "saveArtifact" | "getArtifactPath" | "getLeafId" | "getLeafEntry" | "getEntry" | "getLabel" | "getBranch" | "getHeader" | "getEntries" | "getTree" | "getUsageStatistics" | "putBlob">;
 /** Exported for testing */
 export declare function migrateSessionEntries(entries: FileEntry[]): void;
@@ -257,7 +339,7 @@ export declare function getLatestCompactionEntry(entries: SessionEntry[]): Compa
  * If leafId is provided, walks from that entry to root.
  * Handles compaction and branch summaries along the path.
  */
-export declare function buildSessionContext(entries: SessionEntry[], leafId?: string | null, byId?: Map<string, SessionEntry>): SessionContext;
+export declare function buildSessionContext(entries: SessionEntry[], leafId?: string | null, byId?: Map<string, SessionEntry>, sessionIdentityNamespace?: string): SessionContext;
 /** Exported for testing */
 export declare function loadEntriesFromFile(filePath: string, storage?: SessionStorage): Promise<FileEntry[]>;
 declare class RecentSessionInfo {
@@ -386,6 +468,15 @@ export declare class SessionManager {
     flush(): Promise<void>;
     /** Close the persistent writer after flushing all pending data. */
     close(): Promise<void>;
+    /** Flush while open, then strictly close; retryable close skips the invalid second flush. */
+    flushAndCloseStrict(): Promise<SessionManagerCloseOutcome>;
+    /**
+     * Strictly flush and close the persist writer, returning the certainty-aware close
+     * outcome without manufacturing success. The existing {@link close} path is
+     * preserved for best-effort callers; this seam lets strict ACP disposal prove
+     * writer closure before any destructive operation.
+     */
+    closeStrict(): Promise<SessionManagerCloseOutcome>;
     getCwd(): string;
     /** Get usage statistics across all assistant messages in the session. */
     getUsageStatistics(): UsageStatistics;
@@ -515,7 +606,7 @@ export declare class SessionManager {
      * @param attribution Who initiated this message for billing/attribution semantics
      * @returns Entry id
      */
-    appendCustomMessageEntry<T = unknown>(customType: string, content: string | (TextContent | ImageContent)[], display: boolean, details?: T, attribution?: MessageAttribution): string;
+    appendCustomMessageEntry<T = unknown>(customType: string, content: string | (TextContent | ImageContent)[], display: boolean, details?: T, attribution?: MessageAttribution, observationId?: string): string;
     /**
      * Append an MCP tool selection entry recording the discovery-selected MCP tools.
      * @param selectedToolNames MCP tool names selected for this branch
@@ -639,6 +730,18 @@ export declare class SessionManager {
      * @param sessionDir Optional session directory for /new or /branch. If omitted, derives from file's parent.
      */
     static open(filePath: string, sessionDir?: string, storage?: SessionStorage): Promise<SessionManager>;
+    /**
+     * List sessions for the resume picker without recovery or other maintenance writes.
+     */
+    static listForResumePickerReadOnly(cwd: string, sessionDir?: string, storage?: SessionStorage): Promise<SessionInfo[]>;
+    /** Inspect a selected session without acquiring write-capable ownership. */
+    static inspectSessionTailReadOnly(filePath: string, storage?: SessionStorage): Promise<ResumeTailInspection>;
+    /**
+     * Main startup code MUST retain the consented inspection identity and branch on
+     * the returned discriminant; an error result never creates, rewrites, or adopts
+     * the selected path. Breadcrumb ownership begins only after `kind: "opened"`.
+     */
+    static openExistingStrict(identity: ResumeSessionIdentity, sessionDir?: string, storage?: SessionStorage): Promise<StrictSessionOpenResult>;
     /**
      * Continue the most recent session, or create new if none.
      * @param cwd Working directory
@@ -657,5 +760,22 @@ export declare class SessionManager {
      * List all sessions across all project directories.
      */
     static listAll(storage?: SessionStorage): Promise<SessionInfo[]>;
+    /**
+     * Strict raw scoped inventory for ACP authorization. Enumerates the scoped
+     * session directory without suppressing any root/scan/lstat/read/parse/stat/
+     * header/cwd/containment/identity failure. A failure result carries every
+     * sanitized failure and grants zero authority — it is never reduced to a
+     * partial candidate set. Display/global {@link list} behavior is unaffected.
+     */
+    static inventorySessionsStrict(cwd: string, options?: {
+        sessionDir?: string;
+        storage?: SessionStorage;
+    }): StrictInventoryResult;
+    /**
+     * Propagate the storage-layer verified hard delete bound to exact identity evidence.
+     * Never performs ID lookup or first-match selection; the caller supplies the exact
+     * authorization target captured from a complete strict inventory.
+     */
+    deleteSessionVerified(target: VerifiedSessionDeleteTarget): Promise<VerifiedSessionDeleteResult>;
 }
 export {};

package/dist/types/session/session-storage.d.ts

@@ -1,7 +1,53 @@
 export interface SessionStorageStat {
+    dev: bigint;
+    ino: bigint;
     size: number;
     mtimeMs: number;
+    mtimeNs: bigint;
     mtime: Date;
+    isFile: boolean;
+}
+/** Exact bytes and identity captured from one opened regular-file descriptor. */
+export interface SessionStorageSnapshot {
+    bytes: Uint8Array;
+    stat: SessionStorageStat;
+}
+/**
+ * Four-state writer close lifecycle. Only a successful underlying close confirms
+ * `closed`. A failure certified to have happened BEFORE the OS close was dispatched
+ * is `close_failed_retryable` (ownership of the numeric fd is still proven, so a
+ * later retry/finalizer close is safe). Any exception from an actually dispatched
+ * close call is terminal `close_unknown`: the numeric fd cannot be safely retried
+ * or finalizer-closed, and the writer blocks strict deletion.
+ */
+export type SessionStorageWriterCloseState = "open" | "close_failed_retryable" | "close_unknown" | "closed";
+/**
+ * Thrown by a {@link SessionStorageWriterCloseAdapter} to certify that a close
+ * failure occurred BEFORE the real OS close (`fs.closeSync`-equivalent) was ever
+ * dispatched. Because no OS close ran, the numeric fd is still owned and a retry
+ * is safe. Any other thrown value is treated as a dispatched close failure
+ * (`close_unknown`) and forbids retry/finalizer close of that fd.
+ */
+export declare class SessionStorageWriterRetryableCloseError extends Error {
+    readonly name = "SessionStorageWriterRetryableCloseError";
+    constructor(message?: string, options?: ErrorOptions);
+}
+/**
+ * Injectable dispatcher for the numeric-fd OS close. The default implementation
+ * calls `fs.closeSync(fd)`. Tests inject adapters that throw
+ * {@link SessionStorageWriterRetryableCloseError} to certify a pre-dispatch
+ * failure, or that call the real close and throw to simulate a dispatched
+ * failure (`close_unknown`).
+ */
+export interface SessionStorageWriterCloseAdapter {
+    close(fd: number): void;
+}
+/** Options for opening a {@link SessionStorageWriter}. */
+export interface SessionStorageWriterOpenOptions {
+    flags?: "a" | "w";
+    onError?: (err: Error) => void;
+    /** Injectable OS-close dispatcher; defaults to `fs.closeSync`. */
+    closeAdapter?: SessionStorageWriterCloseAdapter;
 }
 export interface SessionStorageWriter {
     writeLine(line: string): Promise<void>;
@@ -16,15 +62,35 @@ export interface SessionStorageWriter {
     flush(): Promise<void>;
     fsync(): Promise<void>;
     close(): Promise<void>;
+    /**
+     * Synchronously close the underlying descriptor. The certainty-aware close
+     * state is updated synchronously and any close failure throws before this
+     * returns, so sync callers (atomic rewrite) can observe a close failure
+     * before proceeding to rename. Mirrors {@link close} semantics exactly.
+     */
+    closeSync(): void;
     getError(): Error | undefined;
+    /** Current certainty-aware close lifecycle state. */
+    getCloseState(): SessionStorageWriterCloseState;
+    /** Stored error for non-success close states (`close_failed_retryable`/`close_unknown`). */
+    getCloseError(): Error | undefined;
 }
 export interface SessionStorage {
     ensureDirSync(dir: string): void;
     existsSync(path: string): boolean;
     writeTextSync(path: string, content: string): void;
     readTextSync(path: string): string;
+    /** Exact on-disk bytes for strict read-only session inspection. */
+    readBytesSync?(path: string): Uint8Array;
+    /** Exact bytes and descriptor-bound identity captured from one opened regular file. */
+    readSnapshotSync?(path: string): SessionStorageSnapshot;
     statSync(path: string): SessionStorageStat;
     listFilesSync(dir: string, pattern: string): string[];
+    /**
+     * Strict directory scan that never suppresses scan/root errors. Used by strict
+     * authorization inventory; the forgiving {@link listFilesSync} stays display-only.
+     */
+    listFilesStrictSync?(dir: string, pattern: string): string[];
     exists(path: string): Promise<boolean>;
     readText(path: string): Promise<string>;
     readTextPrefix(path: string, maxBytes: number): Promise<string>;
@@ -34,18 +100,90 @@ export interface SessionStorage {
     unlink(path: string): Promise<void>;
     unlinkSync(path: string): void;
     deleteSessionWithArtifacts(sessionPath: string): Promise<void>;
-    openWriter(path: string, options?: {
-        flags?: "a" | "w";
-        onError?: (err: Error) => void;
-    }): SessionStorageWriter;
+    /**
+     * Verified hard delete bound to exact identity evidence. Removes the verified
+     * artifact directory first, revalidates, and unlinks the transcript last. Returns
+     * typed partial-cleanup evidence for exact-identity retry; never returns success
+     * for a partial deletion.
+     */
+    deleteSessionVerified?(target: VerifiedSessionDeleteTarget): Promise<VerifiedSessionDeleteResult>;
+    openWriter(path: string, options?: SessionStorageWriterOpenOptions): SessionStorageWriter;
 }
+/** Exact (dev, ino) identity fields used for ACP authorization binding. */
+export interface SessionStorageFileIdentity {
+    dev: bigint;
+    ino: bigint;
+}
+/** Kind of verification failure surfaced by {@link deleteSessionVerified}. */
+export type VerifiedDeleteFailureKind = "containment" | "symlink" | "stat" | "identity" | "header" | "cwd" | "artifacts";
+/**
+ * Thrown by {@link deleteSessionVerified} when canonical containment, transcript
+ * non-symlink/identity, header id/cwd, parent identity, or artifact identity
+ * verification fails. These are visible, sanitized failures: they never mutate
+ * the transcript or artifacts and grant zero authority.
+ */
+export declare class SessionDeleteVerificationError extends Error {
+    readonly kind: VerifiedDeleteFailureKind;
+    constructor(kind: VerifiedDeleteFailureKind, message: string, options?: ErrorOptions);
+}
+/**
+ * Exact identity evidence a verified hard delete binds to. All fields are captured
+ * at authorization time; delete revalidates each one before any mutation. Retry
+ * after a partial cleanup supplies the recorded artifact identity via
+ * {@link expectedArtifactsIdentity}.
+ */
+export interface VerifiedSessionDeleteTarget {
+    /** Canonical sessions root; the transcript must be contained within it. */
+    sessionsRoot: string;
+    /** Canonical transcript path (absolute `*.jsonl`). */
+    transcriptPath: string;
+    /** Expected session id parsed from the header. */
+    sessionId: string;
+    /** Expected canonical cwd parsed from the header. */
+    cwd: string;
+    /** Expected transcript file `(dev, ino)` captured at authorization. */
+    transcriptIdentity: SessionStorageFileIdentity;
+    /**
+     * For retry after an `artifacts` `cleanup_pending`: the recorded artifact
+     * directory identity to re-accept. A replacement/different artifact directory
+     * fails closed. Omit on first attempt or to accept recorded absence.
+     */
+    expectedArtifactsIdentity?: SessionStorageFileIdentity;
+}
+/**
+ * Outcome of a verified hard delete. Artifact removal happens first; only after
+ * revalidation is the transcript unlinked last. A partial deletion returns
+ * `cleanup_pending` with exact evidence for same-connection retry — never
+ * `deleted` and never `{}`.
+ */
+export type VerifiedSessionDeleteResult = {
+    kind: "deleted";
+} | {
+    kind: "cleanup_pending";
+    phase: "artifacts";
+    error: Error;
+    /** Artifact directory identity at failure time; undefined when absent. */
+    artifactsIdentity: SessionStorageFileIdentity | undefined;
+    /** Transcript identity (unchanged) for retry binding. */
+    transcriptIdentity: SessionStorageFileIdentity;
+} | {
+    kind: "cleanup_pending";
+    phase: "transcript";
+    error: Error;
+    /** Transcript identity at failure time for retry binding. */
+    transcriptIdentity: SessionStorageFileIdentity;
+};
 export declare class FileSessionStorage implements SessionStorage {
+    #private;
     ensureDirSync(dir: string): void;
     existsSync(path: string): boolean;
     writeTextSync(fpath: string, content: string): void;
     readTextSync(fpath: string): string;
+    readBytesSync(fpath: string): Uint8Array;
+    readSnapshotSync(fpath: string): SessionStorageSnapshot;
     statSync(path: string): SessionStorageStat;
     listFilesSync(dir: string, pattern: string): string[];
+    listFilesStrictSync(dir: string, pattern: string): string[];
     exists(path: string): Promise<boolean>;
     readText(path: string): Promise<string>;
     readTextPrefix(path: string, maxBytes: number): Promise<string>;
@@ -54,15 +192,18 @@ export declare class FileSessionStorage implements SessionStorage {
     renameSync(path: string, nextPath: string): void;
     unlink(path: string): Promise<void>;
     unlinkSync(path: string): void;
-    openWriter(path: string, options?: {
-        flags?: "a" | "w";
-        onError?: (err: Error) => void;
-    }): SessionStorageWriter;
+    openWriter(path: string, options?: SessionStorageWriterOpenOptions): SessionStorageWriter;
     /**
      * Delete a session file and its artifacts directory.
      * Artifacts are stored in a sibling directory with the same name minus .jsonl extension.
      */
     deleteSessionWithArtifacts(sessionPath: string): Promise<void>;
+    /**
+     * Verified hard delete bound to exact identity evidence. Artifact directory first,
+     * revalidate, transcript last. Partial deletion returns typed cleanup_pending
+     * evidence; identity/symlink/containment/header/cwd mismatch throws.
+     */
+    deleteSessionVerified(target: VerifiedSessionDeleteTarget): Promise<VerifiedSessionDeleteResult>;
 }
 export declare class MemorySessionStorage implements SessionStorage {
     #private;
@@ -70,8 +211,11 @@ export declare class MemorySessionStorage implements SessionStorage {
     existsSync(path: string): boolean;
     writeTextSync(path: string, content: string): void;
     readTextSync(path: string): string;
+    readBytesSync(path: string): Uint8Array;
+    readSnapshotSync(path: string): SessionStorageSnapshot;
     statSync(path: string): SessionStorageStat;
     listFilesSync(dir: string, pattern: string): string[];
+    listFilesStrictSync(dir: string, pattern: string): string[];
     exists(path: string): Promise<boolean>;
     readText(path: string): Promise<string>;
     readTextPrefix(path: string, maxBytes: number): Promise<string>;
@@ -80,9 +224,7 @@ export declare class MemorySessionStorage implements SessionStorage {
     renameSync(path: string, nextPath: string): void;
     unlink(path: string): Promise<void>;
     unlinkSync(path: string): void;
-    deleteSessionWithArtifacts(_sessionPath: string): Promise<void>;
-    openWriter(path: string, options?: {
-        flags?: "a" | "w";
-        onError?: (err: Error) => void;
-    }): SessionStorageWriter;
+    deleteSessionWithArtifacts(sessionPath: string): Promise<void>;
+    deleteSessionVerified(target: VerifiedSessionDeleteTarget): Promise<VerifiedSessionDeleteResult>;
+    openWriter(path: string, options?: SessionStorageWriterOpenOptions): SessionStorageWriter;
 }

package/dist/types/setup/credential-auto-import.d.ts

@@ -45,7 +45,7 @@ export interface CredentialAutoImportOptions {
     trigger: CredentialAutoImportTrigger;
     sourceLabel?: CredentialAutoImportSourceLabel;
 }
-export declare function runExternalCredentialAutoImport({ authStorage, discover, discoveryOptions }: CredentialAutoImportOptions): Promise<CredentialAutoImportResult>;
+export declare function runExternalCredentialAutoImport({ authStorage, discover, discoveryOptions, }: CredentialAutoImportOptions): Promise<CredentialAutoImportResult>;
 export declare function buildCredentialAutoImportNotice(result: Pick<CredentialAutoImportResult, "imported">): string | undefined;
 export declare function formatCredentialAutoImportResult(result: CredentialAutoImportResult): string[];
 export interface CredentialImportMarkerStore {
@@ -60,4 +60,4 @@ export interface StartupCredentialAutoImportOptions {
     agentDir?: string;
     markerStore?: CredentialImportMarkerStore;
 }
-export declare function runStartupCredentialAutoImportIfNeeded({ authStorage: activeAuthStorage, modelRegistry: activeModelRegistry, discover, version, agentDir, markerStore }: StartupCredentialAutoImportOptions): Promise<string | undefined>;
+export declare function runStartupCredentialAutoImportIfNeeded({ authStorage: activeAuthStorage, modelRegistry: activeModelRegistry, discover, version, agentDir, markerStore, }: StartupCredentialAutoImportOptions): Promise<string | undefined>;

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

@@ -1,7 +1,23 @@
 import { postmortem } from "@sayknow-cli/utils";
+/** Managed tmux owner provenance propagated only to the launched child process. */
+export declare const SKC_TMUX_OWNER_GENERATION_ENV = "SKC_TMUX_OWNER_GENERATION";
+export declare const SKC_TMUX_OWNER_STATE_DIR_ENV = "SKC_TMUX_OWNER_STATE_DIR";
+export declare const SKC_TMUX_OWNER_SERVER_KEY_ENV = "SKC_TMUX_OWNER_SERVER_KEY";
 export declare const SKC_COORDINATOR_SESSION_STATE_FILE_ENV = "SKC_COORDINATOR_SESSION_STATE_FILE";
 export declare const SKC_COORDINATOR_SESSION_ID_ENV = "SKC_COORDINATOR_SESSION_ID";
 export declare const SKC_COORDINATOR_SESSION_BRANCH_ENV = "SKC_COORDINATOR_SESSION_BRANCH";
+export declare const SKC_COORDINATOR_SESSION_LAUNCH_ID_ENV = "SKC_COORDINATOR_SESSION_LAUNCH_ID";
+export declare const SKC_COORDINATOR_SESSION_READINESS_FILE_ENV = "SKC_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: "skc_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/skc-runtime/state-schema.d.ts

@@ -11,13 +11,13 @@ export declare const WorkflowStateReceiptSchema: z.ZodObject<{
     skill: z.ZodEnum<{
         "deep-interview": "deep-interview";
         ralplan: "ralplan";
-        team: "team";
         ultragoal: "ultragoal";
+        team: "team";
     }>;
     owner: z.ZodEnum<{
-        "skc-hook": "skc-hook";
-        "skc-runtime": "skc-runtime";
         "skc-state-cli": "skc-state-cli";
+        "skc-runtime": "skc-runtime";
+        "skc-hook": "skc-hook";
     }>;
     command: z.ZodString;
     state_path: z.ZodString;
@@ -54,13 +54,13 @@ export declare const WorkflowStateEnvelopeSchema: z.ZodObject<{
         skill: z.ZodEnum<{
             "deep-interview": "deep-interview";
             ralplan: "ralplan";
-            team: "team";
             ultragoal: "ultragoal";
+            team: "team";
         }>;
         owner: z.ZodEnum<{
-            "skc-hook": "skc-hook";
-            "skc-runtime": "skc-runtime";
             "skc-state-cli": "skc-state-cli";
+            "skc-runtime": "skc-runtime";
+            "skc-hook": "skc-hook";
         }>;
         command: z.ZodString;
         state_path: z.ZodString;
@@ -95,13 +95,13 @@ export declare const RequiredWorkflowStateReceiptSchema: z.ZodObject<{
     skill: z.ZodEnum<{
         "deep-interview": "deep-interview";
         ralplan: "ralplan";
-        team: "team";
         ultragoal: "ultragoal";
+        team: "team";
     }>;
     owner: z.ZodEnum<{
-        "skc-hook": "skc-hook";
-        "skc-runtime": "skc-runtime";
         "skc-state-cli": "skc-state-cli";
+        "skc-runtime": "skc-runtime";
+        "skc-hook": "skc-hook";
     }>;
     command: z.ZodString;
     state_path: z.ZodString;
@@ -128,8 +128,8 @@ export declare const RequiredOnWriteEnvelopeSchema: z.ZodObject<{
     skill: z.ZodEnum<{
         "deep-interview": "deep-interview";
         ralplan: "ralplan";
-        team: "team";
         ultragoal: "ultragoal";
+        team: "team";
     }>;
     version: z.ZodLiteral<2>;
     updated_at: z.ZodString;
@@ -140,13 +140,13 @@ export declare const RequiredOnWriteEnvelopeSchema: z.ZodObject<{
         skill: z.ZodEnum<{
             "deep-interview": "deep-interview";
             ralplan: "ralplan";
-            team: "team";
             ultragoal: "ultragoal";
+            team: "team";
         }>;
         owner: z.ZodEnum<{
-            "skc-hook": "skc-hook";
-            "skc-runtime": "skc-runtime";
             "skc-state-cli": "skc-state-cli";
+            "skc-runtime": "skc-runtime";
+            "skc-hook": "skc-hook";
         }>;
         command: z.ZodString;
         state_path: z.ZodString;
@@ -198,13 +198,13 @@ export declare const SkillActiveEntrySchema: z.ZodObject<{
         skill: z.ZodEnum<{
             "deep-interview": "deep-interview";
             ralplan: "ralplan";
-            team: "team";
             ultragoal: "ultragoal";
+            team: "team";
         }>;
         owner: z.ZodEnum<{
-            "skc-hook": "skc-hook";
-            "skc-runtime": "skc-runtime";
             "skc-state-cli": "skc-state-cli";
+            "skc-runtime": "skc-runtime";
+            "skc-hook": "skc-hook";
         }>;
         command: z.ZodString;
         state_path: z.ZodString;
@@ -259,13 +259,13 @@ export declare const SkillActiveStateSchema: z.ZodObject<{
             skill: z.ZodEnum<{
                 "deep-interview": "deep-interview";
                 ralplan: "ralplan";
-                team: "team";
                 ultragoal: "ultragoal";
+                team: "team";
             }>;
             owner: z.ZodEnum<{
-                "skc-hook": "skc-hook";
-                "skc-runtime": "skc-runtime";
                 "skc-state-cli": "skc-state-cli";
+                "skc-runtime": "skc-runtime";
+                "skc-hook": "skc-hook";
             }>;
             command: z.ZodString;
             state_path: z.ZodString;

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

@@ -12,6 +12,8 @@ export declare const SKC_TMUX_BRANCH_SLUG_OPTION = "@skc-branch-slug";
 export declare const SKC_TMUX_PROJECT_OPTION = "@skc-project";
 export declare const SKC_TMUX_SESSION_ID_OPTION = "@skc-session-id";
 export declare const SKC_TMUX_SESSION_STATE_FILE_OPTION = "@skc-session-state-file";
+export declare const SKC_TMUX_OWNER_GENERATION_OPTION = "@skc-owner-generation";
+export declare const SKC_TMUX_OWNER_SERVER_KEY_OPTION = "@skc-owner-server-key";
 export declare const SKC_TMUX_VERSION_OPTION = "@skc-version";
 export declare const SKC_PSMUX_PROFILE_FORCE_ENV = "SKC_PSMUX_PROFILE_FORCE";
 export interface SkcTmuxProfileCommand {
@@ -89,6 +91,8 @@ export declare function buildSkcTmuxRequiredProfileCommands(target: string, meta
     project?: string | null;
     sessionId?: string | null;
     sessionStateFile?: string | null;
+    ownerGeneration?: string | null;
+    ownerServerKey?: string | null;
     version?: string | null;
 }): SkcTmuxProfileCommand[];
 export declare function buildSkcTmuxProfileCommands(target: string, env?: NodeJS.ProcessEnv, metadata?: {
@@ -97,6 +101,8 @@ export declare function buildSkcTmuxProfileCommands(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/skc-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>;