@sayknow-cli/coding-agent 0.4.2 → 0.4.4

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

@@ -0,0 +1,111 @@
+import type { ResolvedTmuxBinary } from "./psmux-detect";
+export declare const SKC_DEFAULT_TMUX_SESSION = "sayknow_cli";
+export declare const SKC_TMUX_SESSION_PREFIX = "sayknow_cli_";
+export declare const SKC_TMUX_COMMAND_ENV = "SKC_TMUX_COMMAND";
+export declare const SKC_TMUX_ACTIVE_SESSION_ENV = "SKC_TMUX_ACTIVE_SESSION";
+export declare const SKC_TMUX_PROFILE_ENV = "SKC_TMUX_PROFILE";
+export declare const SKC_TMUX_MOUSE_ENV = "SKC_MOUSE";
+export declare const SKC_TMUX_PROFILE_OPTION = "@skc-profile";
+export declare const SKC_TMUX_PROFILE_VALUE = "1";
+export declare const SKC_TMUX_BRANCH_OPTION = "@skc-branch";
+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 {
+    description: string;
+    args: string[];
+}
+export interface TmuxCommandResult {
+    exitCode: number | null;
+    stdout?: string;
+    stderr?: string;
+    signalCode?: string | null;
+}
+export type TmuxCommandRunner = (args: string[]) => TmuxCommandResult;
+export declare function envDisabled(value: string | undefined): boolean;
+/**
+ * Resolve the tmux (or tmux-compatible multiplexer) command SKC should invoke.
+ *
+ * This is the shared entry point used by every SKC code path that needs to talk
+ * to a multiplexer: `skc --tmux` planning, `skc session ...`, `skc team ...`,
+ * the lifecycle controller, and the harness resident owner. Routing all of
+ * them through the same resolver means a single `SKC_TMUX_COMMAND` override or
+ * a single Windows psmux / pmux detection wins for the whole process — the
+ * failure mode where `skc --tmux` creates a psmux-backed session and then
+ * `skc session status` fails because it queries literal `tmux` is closed off.
+ *
+ * Explicit `SKC_TMUX_COMMAND` / `SKC_TEAM_TMUX_COMMAND` overrides are honored on
+ * every platform. On native Windows without an override the resolver walks
+ * `psmux`, then `pmux`, then `tmux` and uses the first binary present on PATH.
+ * On POSIX the resolver returns `tmux` (the historical default) and only
+ * falls through to the platform-aware walker if the caller opts in.
+ */
+export declare function resolveSkcTmuxCommand(env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform): string;
+export type { PsmuxProbe, ResolvedTmuxBinary, ResolveSkcTmuxBinaryOptions } from "./psmux-detect";
+export { clearPsmuxDetectionCache, detectPsmux, probePsmux, resolveSkcTmuxBinary } from "./psmux-detect";
+/**
+ * Build the exact-session target for tmux *option* commands
+ * (`show-options` / `set-option`) and `display-message -t`.
+ *
+ * Session-scoped commands such as `kill-session` / `attach-session` resolve a
+ * bare exact target (`=NAME`), but tmux 3.6a refuses to resolve a bare `=NAME`
+ * for option/display commands. Appending the empty window separator (`=NAME:`)
+ * keeps the exact-session match while giving tmux the window-qualified target
+ * those commands require. See sayknow-cli#580.
+ */
+export declare function buildSkcTmuxExactOptionTarget(sessionName: string, opts?: {
+    env?: NodeJS.ProcessEnv;
+    platform?: NodeJS.Platform;
+    binary?: ResolvedTmuxBinary;
+}): string;
+/**
+ * Build the exact-session target for tmux *session-scoped* commands such as
+ * `attach-session` and `kill-session`. Native tmux accepts `=NAME` for an
+ * exact session match, but Windows psmux 3.3.x rejects that target form for
+ * session commands even though the bare `NAME` resolves. Keep native tmux on
+ * exact targets and intentionally use the bare session name for psmux.
+ */
+export declare function buildSkcTmuxExactSessionTarget(sessionName: string, opts?: {
+    env?: NodeJS.ProcessEnv;
+    platform?: NodeJS.Platform;
+    binary?: ResolvedTmuxBinary;
+}): string;
+export declare const SKC_TMUX_UNTAGGED_REASON = "skc_tmux_session_untagged";
+export declare function buildSkcTmuxUntaggedSessionHint(tmuxCommand: string): string;
+export declare function buildSkcTmuxUntaggedSessionError(sessionName: string, tmuxCommand: string): string;
+export declare function sanitizeTmuxToken(value: string): string;
+export declare function buildSkcTmuxSessionSlug(value: string): string;
+export declare function buildSkcTmuxSessionName(env?: NodeJS.ProcessEnv, context?: {
+    branch?: string | null;
+    now?: number;
+    id?: string;
+}): string;
+export declare function buildSkcTmuxRequiredProfileCommands(target: string, metadata?: {
+    branch?: string | null;
+    branchSlug?: string | null;
+    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?: {
+    branch?: string | null;
+    branchSlug?: string | null;
+    project?: string | null;
+    sessionId?: string | null;
+    sessionStateFile?: string | null;
+    ownerGeneration?: string | null;
+    ownerServerKey?: string | null;
+    version?: string | null;
+}, opts?: {
+    platform?: NodeJS.Platform;
+    tmuxCommand?: string;
+}): SkcTmuxProfileCommand[];
+export declare function normalizeTmuxCreatedAt(raw: string): string;

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

@@ -0,0 +1,7 @@
+/**
+ * GC adapter for skc-tagged tmux sessions. Destructive cleanup is authorized
+ * only for detached pane-less sessions whose exact runtime marker revalidates a
+ * terminal state. Project/branch/orphan heuristics are discovery signals only.
+ */
+import type { GcStoreAdapter } from "./gc-runtime";
+export declare const tmuxSessionsGcAdapter: GcStoreAdapter;

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

@@ -0,0 +1,18 @@
+import { type TmuxServerProof } from "./tmux-owner-isolation";
+/** Matches the sole argv shape allowed to enter the owner-isolation JSON-line protocol. */
+export declare function isTmuxOwnerIsolationCliArgv(argv: readonly string[]): boolean;
+interface TmuxListSessionsResult {
+    exitCode: number | null;
+    stdout: string;
+    stderr: string;
+}
+interface TmuxServerProofOptions {
+    platform?: NodeJS.Platform;
+    runListSessions?: (argv: string[]) => TmuxListSessionsResult;
+}
+/** Probes a tmux server using an injectable list-sessions runner for platform-bounded callers. */
+export declare function tmuxServerProof(socketKey: string, tmuxControlArgv?: string[], options?: TmuxServerProofOptions): Promise<TmuxServerProof>;
+/** 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>;
+export {};

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

@@ -0,0 +1,326 @@
+/**
+ * Provenance and lifecycle primitives for tmux-resident SKC owners.
+ * This module intentionally accepts and stores only opaque identifiers and
+ * process/cgroup metadata; it never reads panes, prompts, environment, or logs.
+ */
+export declare const TMUX_OWNER_ISOLATION_SCHEMA_VERSION = 1;
+export declare const TMUX_OWNER_ISOLATION_MAX_LINE_BYTES: number;
+export declare const TMUX_OWNER_ISOLATION_MAX_DIAGNOSTIC_CHARS = 512;
+export declare function tmuxOwnerIsolationBootstrapArgv(): string[];
+export type CgroupClassification = "not_applicable" | "safe" | "unsafe_service" | "unverifiable";
+export type ServerState = "absent" | "safe" | "unsafe" | "unverifiable";
+export type PlanErrorCode = "scope_unavailable" | "server_unsafe" | "server_unverifiable" | "server_race" | "scope_bootstrap_failed";
+export type ExpectedTerminalResult = "owner_term_then_session_cleanup";
+export type TerminalSignal = "SIGTERM" | "SIGHUP" | "SIGINT" | "SIGKILL" | "EXIT" | "MANUAL" | "UNKNOWN";
+export type VerdictClassification = "expected_operator_shutdown" | "unexpected_owner_loss" | "non_operator_cleanup";
+export type TerminalObserver = "sidecar" | "raw_monitor";
+export interface CgroupInfo {
+    classification: CgroupClassification;
+    scope?: string;
+    diagnostic?: string;
+}
+/** Classify only public cgroup path metadata; malformed Linux data fails closed. */
+export declare function classifyCgroup(input: {
+    platform: NodeJS.Platform;
+    cgroupText?: string | null;
+}): CgroupInfo;
+export declare function ownerProcessStartTime(platform: NodeJS.Platform, stat: string | null): string | null;
+export interface TmuxServerProof {
+    state: ServerState;
+    pid?: number;
+    startTime?: string;
+    cgroup?: CgroupInfo;
+    sessionNames?: string[];
+}
+export interface PlanRequest {
+    schema_version: 1;
+    op: "plan";
+    platform: NodeJS.Platform;
+    session_id: string;
+    owner_generation: string;
+    cwd: string;
+    state_dir: string;
+    socket_key: string;
+    tmux_argv: string[];
+    baseline: OwnerGenerationBaseline;
+}
+export interface PublishGenerationRequest {
+    schema_version: 1;
+    op: "publish_generation";
+    session_id: string;
+    owner_generation: string;
+    state_dir: string;
+    baseline: OwnerGenerationBaseline;
+}
+export interface PublishGenerationResult {
+    schema_version: 1;
+    ok: true;
+    code: "generation_published";
+    generation: string;
+}
+export interface AttemptCapability {
+    token: string;
+    session_name: string;
+    socket_key: string;
+    server_absent_before: boolean;
+    baseline: OwnerGenerationBaseline;
+    expires_at: string;
+}
+export interface DirectExecution {
+    mode: "direct";
+    argv: string[];
+    attempt_session: string;
+    server_key: string;
+    server_absent_before: boolean;
+    server_pid?: number;
+    server_start_time?: string;
+}
+export interface ScopedExecution {
+    mode: "scoped";
+    argv: string[];
+    stdin_line: string;
+    expected_scope: string;
+    attempt: AttemptCapability;
+    attempt_session: string;
+    server_key: string;
+    server_absent_before: true;
+}
+export type PlanExecution = DirectExecution | ScopedExecution;
+export interface PlanSuccess {
+    schema_version: 1;
+    ok: true;
+    code: "not_required" | "unsafe_scope_required";
+    execution: PlanExecution;
+    classification: CgroupInfo;
+    server_state: ServerState;
+}
+export interface TmuxOwnerIsolationExecutionSuccess {
+    ok: true;
+    code: "executed";
+    execution: PlanExecution;
+    server: TmuxServerProof;
+    server_key: string;
+    server_pid: number;
+    server_start_time: string;
+    server_session: string;
+    native_session_id?: string;
+}
+export interface PlanFailure {
+    schema_version: 1;
+    ok: false;
+    code: PlanErrorCode;
+    diagnostic: string;
+}
+export type PlanResponse = PlanSuccess | PlanFailure;
+export interface OwnerIsolationProbe {
+    readCallerCgroup(): Promise<string | null>;
+    probeServer(socketKey: string, tmuxArgv?: string[]): Promise<TmuxServerProof>;
+}
+/** Synchronous probe boundary for managed launch paths. */
+export interface OwnerIsolationProbeSync {
+    readCallerCgroup(): string | null;
+    probeServer(socketKey: string): TmuxServerProof;
+    recordAttempt(input: {
+        stateDir: string;
+        sessionId: string;
+        generation: string;
+        attempt: AttemptCapability;
+    }): void;
+}
+export interface TmuxOwnerIsolationExecutionFailure {
+    ok: false;
+    code: PlanErrorCode;
+    diagnostic: string;
+}
+export type TmuxOwnerIsolationExecutionResult = TmuxOwnerIsolationExecutionSuccess | TmuxOwnerIsolationExecutionFailure;
+/** Synchronous spawn boundary; callers pass argv and scoped stdin unchanged. */
+export interface TmuxOwnerIsolationExecutionDependencies {
+    socketKey: string;
+    spawn(argv: string[], stdinLine?: string): {
+        exitCode: number | null;
+        stdout?: string;
+    };
+    probeServer(socketKey: string): TmuxServerProof;
+    /** Reads the published owner generation immediately around direct execution. */
+    isCurrentGeneration?(): boolean;
+    cleanupSpawned?(input: {
+        execution: DirectExecution;
+        nativeSessionId: string;
+        server: TmuxServerProof;
+    }): void;
+}
+export declare function isExactScopedBootstrapSuccessReceipt(stdout: string): boolean;
+export declare function isSafeServerProof(server: TmuxServerProof, platform?: NodeJS.Platform): server is TmuxServerProof & {
+    state: "safe";
+    pid: number;
+    startTime: string;
+    cgroup: CgroupInfo;
+};
+/** Compares the stable identity fields of independently observed tmux servers. */
+export declare function sameServerIdentity(left: TmuxServerProof, right: TmuxServerProof): boolean;
+/**
+ * Synchronous equivalent of the target-server truth table for managed callers.
+ * Attempt persistence is injected so a caller can use its existing atomic state writer.
+ */
+export declare function planTmuxOwnerIsolationSync(request: PlanRequest, probe: OwnerIsolationProbeSync): PlanResponse;
+/**
+ * Runs one planned argv exactly and re-proves the target server before callers
+ * perform profile, attach, or cleanup operations.
+ */
+export declare function executeTmuxOwnerIsolationPlanSync(plan: PlanResponse, deps: TmuxOwnerIsolationExecutionDependencies): TmuxOwnerIsolationExecutionResult;
+/** Implements the target-server truth table before any tmux operation. */
+export declare function planTmuxOwnerIsolation(request: PlanRequest, probe: OwnerIsolationProbe): Promise<PlanResponse>;
+export interface BootstrapRequest {
+    schema_version: 1;
+    op: "bootstrap";
+    session_id: string;
+    owner_generation: string;
+    state_dir: string;
+    socket_key: string;
+    expected_scope: string;
+    tmux_argv: string[];
+    attempt: AttemptCapability;
+}
+export interface BootstrapResult {
+    schema_version: 1;
+    ok: boolean;
+    code: "bootstrapped" | "scope_bootstrap_failed";
+    native_session_id?: string;
+    server_pid?: number;
+    server_start_time?: string;
+    session_name?: string;
+    diagnostic?: string;
+}
+export interface BootstrapDependencies {
+    readSelfCgroup(): Promise<string | null>;
+    spawn(argv: string[]): {
+        exitCode: number | null;
+        stdout?: string;
+    };
+    probeServer(socketKey: string, tmuxControlArgv?: string[]): Promise<TmuxServerProof>;
+}
+/** Self-proves the scope and synchronously invokes the exact supplied argv. */
+export declare function bootstrapTmuxOwnerIsolation(request: BootstrapRequest, deps: BootstrapDependencies): Promise<BootstrapResult>;
+export interface OwnerIntent {
+    schema_version: 1;
+    intent_id: string;
+    generation: string;
+    session_id: string;
+    server_key: string;
+    expected_terminal: {
+        signal: "SIGTERM";
+        result: ExpectedTerminalResult;
+    };
+    dispatch_id: string;
+    created_at: string;
+    expires_at: string;
+    state: "pending";
+}
+export interface OwnerVerdict {
+    schema_version: 1;
+    generation: string;
+    session_id: string;
+    server_key: string;
+    observed_at: string;
+    signal: TerminalSignal;
+    exit_code: number | null;
+    result: string;
+    observer: TerminalObserver;
+    classification: VerdictClassification;
+    reason: string;
+    intent_id?: string;
+    dedupe_key: string;
+}
+export interface OwnerIncident {
+    schema_version: 1;
+    generation: string;
+    session_id: string;
+    dedupe_key: string;
+    created_at: string;
+    classification: "unexpected_owner_loss";
+}
+export interface ObserveTerminalRequest {
+    schema_version: 1;
+    op: "observe_terminal";
+    session_id: string;
+    owner_generation: string;
+    state_dir: string;
+    socket_key: string;
+    observer: TerminalObserver;
+    observed_at: string;
+    signal: TerminalSignal;
+    exit_code: number | null;
+    exit_kind: string;
+    reason: string;
+    operator_dispatch_id?: string;
+}
+export interface LifecyclePaths {
+    root: string;
+    generation: string;
+    generationFile: string;
+    generationMarkerFile: string;
+    intentFile: string;
+    verdictFile: string;
+    verdictAliasFile: string;
+    incidentFile: string;
+    lockDatabaseFile: string;
+    journalFile: string;
+}
+export declare function lifecyclePaths(stateDir: string, sessionId: string, generation: string): LifecyclePaths;
+export declare function replaceOwnerGeneration(stateDir: string, sessionId: string, generation?: string, expectedBaseline?: OwnerGenerationBaseline): Promise<string>;
+export type OwnerGenerationBaseline = {
+    state: "absent";
+} | {
+    state: "current";
+    schema_version: 1;
+    generation: string;
+    session_id: string;
+    published_at: string;
+};
+export interface ManagedOwnerPredecessorEvidence {
+    generation: string;
+    sessionId: string;
+    runId: string;
+    incarnation: string;
+    predecessorToken: string;
+}
+/** Resolve one SIGABRT predecessor from the retained exact prior-generation root. */
+export declare function resolveManagedOwnerPredecessorSync(stateDir: string, sessionId: string, baseline: OwnerGenerationBaseline): ManagedOwnerPredecessorEvidence | undefined;
+export declare function captureOwnerGenerationBaseline(stateDir: string, sessionId: string): Promise<OwnerGenerationBaseline>;
+/** Captures the full immutable generation record for a planned owner launch. */
+export declare function captureOwnerGenerationBaselineSync(stateDir: string, sessionId: string): OwnerGenerationBaseline;
+export declare function isOwnerGenerationBaselineCurrentSync(stateDir: string, sessionId: string, baseline: OwnerGenerationBaseline): boolean;
+/** Synchronous publication for managed launch paths, serialized by a SQLite write transaction. */
+export declare function replaceOwnerGenerationSync(stateDir: string, sessionId: string, generation: string, expectedBaseline: OwnerGenerationBaseline): string;
+/** Publishes a raw-owner generation through the canonical SQLite-serialized CAS path. */
+export declare function publishOwnerGenerationSync(request: PublishGenerationRequest): PublishGenerationResult;
+export declare function createOwnerIntent(stateDir: string, input: Omit<OwnerIntent, "schema_version" | "intent_id" | "state">): Promise<OwnerIntent>;
+/** Publish exactly one terminal verdict. Existing valid verdicts always win. */
+export declare function observeOwnerTerminal(request: ObserveTerminalRequest): Promise<OwnerVerdict>;
+/** Strictly validate the persisted authorization, optionally against its terminal observation. */
+export declare function isValidOwnerIntent(intent: unknown, request?: ObserveTerminalRequest): intent is OwnerIntent;
+/** Accept only real UTC timestamps in the canonical evidence serialization. */
+export declare function isCanonicalUtcTimestamp(value: unknown): value is string;
+/** Strictly validate a complete persisted verdict, optionally against its observation. */
+export declare function isValidOwnerVerdict(verdict: unknown, request?: ObserveTerminalRequest): verdict is OwnerVerdict;
+export interface ExactOwnerCloseRequest {
+    stateDir: string;
+    sessionId: string;
+    generation: string;
+    serverKey: string;
+    pid: number;
+    startTime: string;
+    dispatchId: string;
+    createdAt: string;
+    expiresAt: string;
+}
+export interface ExactOwnerCloseDependencies {
+    readStartTime(pid: number): Promise<string | null>;
+    sendSigterm(pid: number): Promise<void>;
+    waitForVerdict(): Promise<OwnerVerdict | null>;
+    cleanupSession(): Promise<void>;
+}
+/** Authorizes only an exact, start-time-validated SIGTERM before compatibility cleanup. */
+export declare function closeExactTmuxOwner(request: ExactOwnerCloseRequest, deps: ExactOwnerCloseDependencies): Promise<OwnerVerdict>;
+export declare function parseOwnerIsolationRequest(line: string): PlanRequest | BootstrapRequest | PublishGenerationRequest | ObserveTerminalRequest | null;
+export declare function serializeOwnerIsolationResponse(response: PlanResponse | BootstrapResult | PublishGenerationResult | OwnerVerdict): string;

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

@@ -0,0 +1,97 @@
+import { type OwnerIsolationProbeSync, type PlanResponse, type TmuxOwnerIsolationExecutionDependencies, type TmuxOwnerIsolationExecutionResult } from "./tmux-owner-isolation";
+export interface SkcTmuxSessionStatus {
+    name: string;
+    attached: boolean;
+    windows: number;
+    panes: number;
+    bindings: string;
+    createdAt: string;
+    branch?: string;
+    branchSlug?: string;
+    project?: string;
+    sessionId?: string;
+    sessionStateFile?: string;
+    version?: string;
+    ownerGeneration?: string;
+    nativeSessionId?: string;
+    panePids: number[];
+    profile?: string;
+}
+export interface SkcTmuxSessionTagsForGc {
+    profile?: string;
+    project?: string;
+    branch?: string;
+    branchSlug?: string;
+    sessionId?: string;
+    sessionStateFile?: string;
+    version?: string;
+    ownerGeneration?: string;
+    nativeSessionId?: string;
+    createdAt?: string;
+    attached?: boolean;
+    panePids?: number[];
+}
+export interface SkcTmuxSessionsForGc {
+    tagged: SkcTmuxSessionStatus[];
+    untagged: SkcTmuxSessionStatus[];
+}
+export interface ProvenTmuxSessionIdentity {
+    nativeSessionId: string;
+    serverPid: number;
+    serverStartTime: string;
+}
+export interface ExpectedSkcTmuxSessionIdentity {
+    nativeSessionId: string;
+    ownerGeneration: string;
+    sessionId: string;
+    sessionStateFile: string;
+    project: string;
+    createdAt: string;
+}
+export interface ExactOwnerIdentity {
+    sessionId: string;
+    stateDir: string;
+    socketKey: string;
+    generation: string;
+    pid: number;
+    startTime: string;
+}
+export interface ForceCloseOwnerDependencies {
+    resolveOwner(sessionName: string, env: NodeJS.ProcessEnv): Promise<ExactOwnerIdentity>;
+    signalTerm(pid: number): void;
+    readProcessStartTime(pid: number): Promise<string | null>;
+    cleanupSession(sessionTarget: string, env: NodeJS.ProcessEnv): void;
+    now(): Date;
+    sleep(ms: number): Promise<void>;
+    listPanePids(sessionName: string, env: NodeJS.ProcessEnv): number[];
+}
+export interface CreateSkcTmuxSessionOptions {
+    platform?: NodeJS.Platform;
+}
+export type CreateOwnerIsolationTestDependencies = {
+    probe?: Partial<OwnerIsolationProbeSync>;
+    execute?: (plan: PlanResponse, deps: TmuxOwnerIsolationExecutionDependencies) => TmuxOwnerIsolationExecutionResult;
+};
+/** @internal Test-only seam; production create always uses live fail-closed probes. */
+export declare function __setCreateOwnerIsolationForTests(dependencies: CreateOwnerIsolationTestDependencies | null): void;
+/** @internal Test-only seam; production mutations always use live fail-closed proofs. */
+export declare function __setMutationServerProofForTests(dependency: ((tmuxCommand: string, env: NodeJS.ProcessEnv) => unknown) | null): void;
+export declare function listSkcTmuxSessions(env?: NodeJS.ProcessEnv): SkcTmuxSessionStatus[];
+/** @internal */
+export declare function listTmuxSessionsForGc(env?: NodeJS.ProcessEnv): SkcTmuxSessionsForGc;
+export declare function findSkcTmuxSessionByBranch(branch: string, env?: NodeJS.ProcessEnv, project?: string | null): SkcTmuxSessionStatus | undefined;
+export declare function findSkcTmuxSessionByName(sessionName: string, env?: NodeJS.ProcessEnv): SkcTmuxSessionStatus | undefined;
+export declare function findSkcTmuxSessionByScope(project: string, branch: string | null | undefined, env?: NodeJS.ProcessEnv): SkcTmuxSessionStatus | undefined;
+export declare function statusSkcTmuxSession(sessionName: string, env?: NodeJS.ProcessEnv): SkcTmuxSessionStatus;
+export declare function createSkcTmuxSession(env?: NodeJS.ProcessEnv, options?: CreateSkcTmuxSessionOptions): SkcTmuxSessionStatus;
+/** Proves a managed reusable name still resolves to one immutable session on one server. */
+export declare function proveSkcTmuxSessionMutationTarget(sessionName: string, env?: NodeJS.ProcessEnv): ProvenTmuxSessionIdentity;
+/** @internal */
+export declare function readTmuxSessionTagsForGc(sessionName: string, env?: NodeJS.ProcessEnv): SkcTmuxSessionTagsForGc;
+export declare function removeSkcTmuxSession(sessionName: string, env?: NodeJS.ProcessEnv, expectedIdentity?: ExpectedSkcTmuxSessionIdentity): SkcTmuxSessionStatus;
+/**
+ * Requests an exact tagged owner shutdown. Session cleanup is compatibility-only
+ * and follows a validated SIGTERM verdict; it never authorizes the close.
+ */
+export declare function forceCloseSkcTmuxSession(sessionName: string, env?: NodeJS.ProcessEnv, expectedSessionId?: string, expectedStateFile?: string, deps?: Partial<ForceCloseOwnerDependencies>): Promise<SkcTmuxSessionStatus>;
+export declare function attachSkcTmuxSession(sessionName: string, env?: NodeJS.ProcessEnv): never;

package/dist/types/skc-runtime/ultragoal-change-set.d.ts

@@ -0,0 +1,13 @@
+import { type UltragoalChangeSet, type UltragoalChangeSetPath } from "./ultragoal-runtime";
+export declare function spawnText(command: string[], options: {
+    cwd: string;
+    timeoutMs?: number;
+}): Promise<{
+    ok: boolean;
+    stdout: string;
+    stderr: string;
+}>;
+export declare function resolveGitBase(cwd: string, branch?: string): Promise<string>;
+export declare function parseGitNameStatus(output: string): UltragoalChangeSetPath[];
+export declare function computeCheckpointChangeSet(cwd: string): Promise<UltragoalChangeSet | undefined>;
+export declare function parseUnifiedDiffPaths(diff: string): UltragoalChangeSetPath[];

package/dist/types/skc-runtime/ultragoal-evidence.d.ts

@@ -0,0 +1,38 @@
+import { type JsonObject, type SurfaceFamily } from "./ultragoal-runtime";
+export declare function pngCrc32(bytes: Buffer): number;
+export declare function parsePngDimensions(bytes: Buffer): {
+    width: number;
+    height: number;
+    headerBytes: number;
+    sampleBytes?: Buffer;
+} | null;
+export declare function parseJpegDimensions(bytes: Buffer): {
+    width: number;
+    height: number;
+    headerBytes: number;
+    sampleBytes?: Buffer;
+} | null;
+export declare function validateStructuralArtifact(cwd: string, row: JsonObject, fieldName: string, options: {
+    surfaceFamily: SurfaceFamily;
+    live: boolean;
+}): Promise<boolean>;
+export declare function isAllowedGitReplayCommand(args: readonly string[]): boolean;
+export declare function readCliReplayRecord(cwd: string, row: JsonObject, fieldName: string): Promise<JsonObject | null>;
+export interface ReplayProcessHandle {
+    readonly exited: Promise<number>;
+    kill(signal?: number | NodeJS.Signals): void;
+}
+export declare function waitForReplayProcessWithTimeout(process: ReplayProcessHandle, timeoutMs: number, graceMs?: number): Promise<number>;
+export declare function validateReplayExemptFallback(cwd: string, record: JsonObject, fieldName: string, artifactRefs: Map<string, JsonObject>, options: {
+    surfaceFamily: SurfaceFamily;
+    live: boolean;
+}): Promise<boolean>;
+export declare function validateCliReplay(cwd: string, row: JsonObject, fieldName: string, options: {
+    live: boolean;
+}): Promise<boolean>;
+export declare function validateLiveSurfaceProofPresence(cwd: string, family: SurfaceFamily, artifactIds: string[], artifactRefs: Map<string, JsonObject>): Promise<void>;
+export declare function validateSurfaceStructuralRequirement(cwd: string, family: SurfaceFamily, artifactIds: string[], artifactRefs: Map<string, JsonObject>, fieldName: string): Promise<void>;
+export declare function validateArtifactProof(cwd: string, row: JsonObject, fieldName: string, options: {
+    surfaceFamily: SurfaceFamily;
+    live: boolean;
+}): Promise<void>;