@sayknow-cli/coding-agent 0.3.16 → 0.4.1

package/dist/types/goals/tools/goal-tool.d.ts

@@ -1,62 +0,0 @@
-import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@sayknow-cli/agent-core";
-import type { Component } from "@sayknow-cli/tui";
-import * as z from "zod/v4";
-import type { RenderResultOptions } from "../../extensibility/custom-tools/types";
-import type { Theme } from "../../modes/theme/theme";
-import type { ToolSession } from "../../tools";
-import type { Goal, GoalToolDetails } from "../state";
-declare const goalSchema: z.ZodObject<{
-    op: z.ZodEnum<{
-        create: "create";
-        get: "get";
-        complete: "complete";
-        resume: "resume";
-        drop: "drop";
-        pause: "pause";
-    }>;
-    objective: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export type GoalToolInput = z.infer<typeof goalSchema>;
-export interface GoalToolResponse {
-    goal: Goal | null;
-}
-export declare function buildGoalToolResponse(goal: Goal | null | undefined): GoalToolResponse;
-export declare class GoalTool implements AgentTool<typeof goalSchema, GoalToolDetails> {
-    #private;
-    readonly name = "goal";
-    readonly label = "Goal";
-    readonly loadMode: "essential";
-    readonly description: string;
-    readonly parameters: z.ZodObject<{
-        op: z.ZodEnum<{
-            create: "create";
-            get: "get";
-            complete: "complete";
-            resume: "resume";
-            drop: "drop";
-            pause: "pause";
-        }>;
-        objective: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>;
-    readonly strict = true;
-    readonly intent: "omit";
-    constructor(session: ToolSession);
-    execute(_toolCallId: string, params: GoalToolInput, _signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<GoalToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<GoalToolDetails>>;
-}
-interface GoalRenderArgs {
-    op?: GoalToolInput["op"];
-    objective?: string;
-}
-export declare const goalToolRenderer: {
-    renderCall(args: GoalRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component;
-    renderResult(result: {
-        content: Array<{
-            type: string;
-            text?: string;
-        }>;
-        details?: GoalToolDetails;
-        isError?: boolean;
-    }, _options: RenderResultOptions, uiTheme: Theme, args?: GoalRenderArgs): Component;
-    mergeCallAndResult: boolean;
-};
-export {};

package/dist/types/harness-control-plane/classifier.d.ts

@@ -1,13 +0,0 @@
-/**
- * Deterministic recovery classifier (pure).
- *
- * Maps a bounded {@link Observation} + remaining retry budget to exactly one
- * {@link RecoveryDecision}. Encodes the plan's hard data-loss invariants:
- *   - dirty deltas are NEVER `restart-clean`; they map to `restart-preserve-delta`.
- *   - unknown deltas are NEVER destructive; they map to `human-check`.
- *   - a deleted/mismatched worktree maps to `human-check` (never recreate over unknown data).
- * `send-enter` is intentionally never emitted: it is unsupported for the sayknow-cli
- * RPC adapter in v1 (no blind key injection).
- */
-import type { ClassifyInput, RecoveryDecision } from "./types";
-export declare function classifyRecovery(input: ClassifyInput): RecoveryDecision;

package/dist/types/harness-control-plane/control-endpoint.d.ts

@@ -1,31 +0,0 @@
-/**
- * Per-session control endpoint — a Unix domain socket served by the RuntimeOwner so
- * stateless `skc harness` CLI calls can route owner-routed primitives (submit, observe,
- * recover, retire) to the live owner. One JSON request line in, one JSON response line out.
- *
- * The owner is the only listener; clients connect per call. When no socket is reachable
- * the caller falls back to the no-owner behavior (read-only observe, owner-not-live submit).
- *
- * FIFO fallback (for platforms/paths where AF_UNIX is unavailable or path-length limited)
- * is a documented seam tracked as an ADR follow-up.
- */
-export interface EndpointRequest {
-    verb: string;
-    input: Record<string, unknown>;
-}
-export type EndpointHandler = (req: EndpointRequest) => Promise<unknown>;
-export declare class ControlServer {
-    #private;
-    readonly socketPath: string;
-    private readonly handler;
-    constructor(socketPath: string, handler: EndpointHandler);
-    listen(): Promise<void>;
-    close(): Promise<void>;
-}
-export declare class EndpointUnreachableError extends Error {
-    readonly socketPath: string;
-    readonly reason: string;
-    constructor(socketPath: string, reason?: string);
-}
-/** Call the owner's control endpoint. Rejects with {@link EndpointUnreachableError} when no owner listens or responds. */
-export declare function callEndpoint(socketPath: string, req: EndpointRequest, timeoutMs?: number): Promise<unknown>;

package/dist/types/harness-control-plane/finalize.d.ts

@@ -1,60 +0,0 @@
-import { type ReviewVerdict } from "./types";
-export interface ValidationCommandSpec {
-    name: string;
-    command: string;
-}
-export interface ValidationRun {
-    exactCommand: string;
-    cwd: string;
-    exitStatus: number;
-    pass: boolean;
-}
-export interface FinalizeChecks {
-    runValidation(spec: ValidationCommandSpec): Promise<ValidationRun>;
-    resolveCommit(): Promise<string | null>;
-    commitOnBranch(commit: string, branch: string): Promise<boolean>;
-    prOrIssue(): Promise<{
-        prUrl: string | null;
-        issueArtifact: string | null;
-    }>;
-}
-export interface FinalizeOptions {
-    root: string;
-    sessionId: string;
-    workspace: string;
-    branch: string;
-    requireTests?: boolean;
-    requireCommit?: boolean;
-    requirePr?: boolean;
-    /** Review-only sessions produce a terminal verdict instead of implementation validation. */
-    reviewOnly?: boolean;
-    /** Operator/loop-supplied terminal review verdict (closed vocabulary). */
-    verdict?: string | null;
-    /**
-     * Final assistant text from the live RPC owner, used to extract a closed-vocabulary verdict
-     * for review-only sessions when no explicit {@link verdict} is supplied. Never persisted raw.
-     */
-    assistantText?: string | null;
-    /** Bounded PR/issue reference for the review target (e.g. "PR-414"). Never resolved from the live repo. */
-    prTarget?: string | null;
-    validationCommands?: ValidationCommandSpec[];
-    checks: FinalizeChecks;
-    clock?: () => number;
-}
-export interface FinalizeResult {
-    completed: boolean;
-    receiptPath: string | null;
-    validation: {
-        name: string;
-        valid: boolean;
-        exitStatus: number;
-    }[];
-    commitHash: string | null;
-    prUrl: string | null;
-    verdict?: ReviewVerdict | null;
-    issueArtifact: string | null;
-    blockers: string[];
-}
-export declare function runFinalize(opts: FinalizeOptions): Promise<FinalizeResult>;
-/** Real checks: git for commit/branch, gh for PR, Bun.spawn for validation commands. */
-export declare function defaultFinalizeChecks(workspace: string): FinalizeChecks;

package/dist/types/harness-control-plane/gc-adapter.d.ts

@@ -1,3 +0,0 @@
-import { type GcStoreAdapter } from "../skc-runtime/gc-runtime";
-export declare const harnessLeasesGcAdapter: GcStoreAdapter;
-export declare const registryEntriesGcAdapter: GcStoreAdapter;

package/dist/types/harness-control-plane/operate.d.ts

@@ -1,35 +0,0 @@
-import { type FinalizeChecks, type FinalizeResult, type ValidationCommandSpec } from "./finalize";
-import { type PreserveResult } from "./preserve";
-import { type HarnessRpc } from "./rpc-adapter";
-import { type HarnessLifecycle, type Observation, type RecoveryClassification, type RetryBudget, type Severity } from "./types";
-export interface OperateOptions {
-    root: string;
-    sessionId: string;
-    workspace: string;
-    branch: string;
-    rpc: HarnessRpc;
-    /** Factory used to (re)create the RPC subprocess on restart recovery. Defaults to reusing `rpc`. */
-    rpcFactory?: () => HarnessRpc;
-    /** Bounded observation provider (scripted in tests; real = git + rpc state). */
-    observe: () => Promise<Observation>;
-    /** Real dirty-worktree preservation; injectable for tests. Defaults to git stash/diff capture. */
-    preserve?: (workspace: string) => PreserveResult;
-    finalizeChecks: FinalizeChecks;
-    validationCommands?: ValidationCommandSpec[];
-    retryBudget?: Partial<RetryBudget>;
-    acceptanceTimeoutMs?: number;
-    maxIterations?: number;
-    /** Injected event emitter. Production owner calls must pass the lease-guarded single-writer #emit. */
-    emit: (severity: Severity, kind: string, evidence: Record<string, unknown>) => Promise<void>;
-    clock?: () => number;
-}
-export interface OperateResult {
-    completed: boolean;
-    lifecycle: HarnessLifecycle;
-    iterations: number;
-    classifications: RecoveryClassification[];
-    vanishReceiptIds: string[];
-    finalize?: FinalizeResult;
-    blockers: string[];
-}
-export declare function operate(goal: string, opts: OperateOptions): Promise<OperateResult>;

package/dist/types/harness-control-plane/owner.d.ts

@@ -1,53 +0,0 @@
-/**
- * RuntimeOwner — the detached per-session process that makes live control honest.
- *
- * Responsibilities:
- *  - hold the {@link SessionLease} (single writer),
- *  - own the {@link HarnessRpc} subprocess (injected; real `SayknowCliRpc` in prod, fake in tests),
- *  - serve owner-routed primitives over the {@link ControlServer} endpoint,
- *  - be the SOLE writer of the severity event stream,
- *  - heartbeat the lease.
- *
- * Stateless `skc harness` CLI calls reach the owner via {@link resolveOwner} + the endpoint.
- */
-import { type FinalizeChecks, type ValidationCommandSpec } from "./finalize";
-import { type HarnessRpc } from "./rpc-adapter";
-import { type SessionLease } from "./session-lease";
-export interface OwnerOptions {
-    root: string;
-    sessionId: string;
-    rpc: HarnessRpc;
-    ownerId?: string;
-    ttlMs?: number;
-    heartbeatMs?: number;
-    acceptanceTimeoutMs?: number;
-    clock?: () => number;
-    finalizeChecks?: FinalizeChecks;
-    validationCommands?: ValidationCommandSpec[];
-}
-export interface OwnerStartInfo {
-    ownerId: string;
-    socketPath: string;
-    leaseEpoch: number;
-}
-export declare class RuntimeOwner {
-    #private;
-    readonly ownerId: string;
-    constructor(opts: OwnerOptions);
-    start(): Promise<OwnerStartInfo>;
-    stop(): Promise<void>;
-}
-export interface ResolvedOwner {
-    live: boolean;
-    socketPath: string | null;
-    lease: SessionLease | null;
-}
-/** Determine whether a live owner currently holds the session (for CLI routing). */
-export declare function resolveOwner(root: string, sessionId: string): Promise<ResolvedOwner>;
-/**
- * Owner liveness for verbs that do not route to the owner (e.g. `classify`): a routable owner
- * has a live lease and a socket endpoint. This is the same lease/socket probe `observe` uses to
- * decide routing, so non-routing verbs derive `ownerLive` consistently instead of assuming the
- * owner is gone (which would misclassify a live owner as vanished/restart-clean).
- */
-export declare function resolveOwnerLive(root: string, sessionId: string): Promise<boolean>;

package/dist/types/harness-control-plane/phase-rollup.d.ts

@@ -1,23 +0,0 @@
-/**
- * Phase-boundary receipt rollup builder (receipt-of-receipts).
- *
- * At a harness lifecycle boundary, N child task receipts can be superseded by a
- * single `phase-rollup` receipt that preserves per-child pointers (id, status,
- * outputRef, sha256) plus aggregate ROI totals. The rollup is hash-sealed via
- * the standard receipt envelope and validated fail-closed like every other
- * family (see `validatePhaseRollup` in receipts.ts). Pure builder — no runtime
- * injection behavior is changed here.
- */
-import type { TaskResultReceipt } from "../task/receipt";
-import { type BuildReceiptInput, type PhaseRollupEvidence, type ReceiptEnvelope } from "./receipts";
-export interface BuildPhaseRollupInput {
-    receiptId: string;
-    sessionId: string;
-    source: string;
-    subject: BuildReceiptInput<PhaseRollupEvidence>["subject"];
-    phase: string;
-    children: readonly TaskResultReceipt[];
-    /** Supply for deterministic output; defaults to now. */
-    createdAt?: string;
-}
-export declare function buildPhaseRollupReceipt(input: BuildPhaseRollupInput): ReceiptEnvelope<PhaseRollupEvidence>;

package/dist/types/harness-control-plane/preserve.d.ts

@@ -1,19 +0,0 @@
-import type { GitDelta } from "./types";
-export interface UntrackedEntry {
-    path: string;
-    size: number;
-    sha256: string;
-}
-export interface PreserveResult {
-    gitDelta: GitDelta;
-    trackedDiff: string;
-    trackedDiffSha256: string;
-    untrackedManifest: UntrackedEntry[];
-    stashRef: string | null;
-    snapshotComplete: boolean;
-}
-/**
- * Capture + snapshot a (possibly dirty) worktree without mutating it. Safe to call on a clean
- * tree (returns empty evidence). Never deletes, resets, or cleans.
- */
-export declare function preserveDirtyWorktree(workspace: string): PreserveResult;

package/dist/types/harness-control-plane/receipt-ingest.d.ts

@@ -1,19 +0,0 @@
-import type { ReceiptEnvelope } from "./receipts";
-import type { HarnessLifecycle, ReceiptFamily, SessionState } from "./types";
-export declare const RECEIPT_DIGEST_MAX_CHARS = 280;
-export declare const RECEIPT_FAMILY_LIFECYCLE_TARGETS: Partial<Record<ReceiptFamily, HarnessLifecycle>>;
-export interface ReceiptIngestResult {
-    accepted: ReceiptEnvelope<unknown>[];
-    rejected: {
-        receipt: ReceiptEnvelope<unknown>;
-        reasons: string[];
-    }[];
-    transitions: {
-        from: HarnessLifecycle;
-        to: HarnessLifecycle;
-        receiptId: string;
-    }[];
-    finalLifecycle: HarnessLifecycle;
-    digest: string;
-}
-export declare function ingestReceipts(state: SessionState, receipts: readonly ReceiptEnvelope<unknown>[]): ReceiptIngestResult;

package/dist/types/harness-control-plane/receipt-spool.d.ts

@@ -1,19 +0,0 @@
-import type { ReceiptEnvelope } from "./receipts";
-export declare const RECEIPT_SPOOL_DIR_ENV = "SKC_RECEIPT_SPOOL_DIR";
-export declare const RECEIPT_SPOOL_FILENAME = "spool.jsonl";
-export declare const RECEIPT_SPOOL_CURSOR_WIDTH = 12;
-export interface ReceiptSpoolRecord {
-    cursor: string;
-    envelope: ReceiptEnvelope<unknown>;
-}
-export interface ReceiptSpoolAppendResult {
-    cursor: string;
-    path: string;
-}
-export declare function withReceiptSpoolDir<T>(spoolDir: string, fn: () => Promise<T>): Promise<T>;
-export declare function resolveReceiptSpoolDir(env?: NodeJS.ProcessEnv): string | undefined;
-export declare function receiptSpoolPath(spoolDir: string): string;
-export declare function formatReceiptSpoolCursor(cursor: bigint): string;
-export declare function readHighestReceiptSpoolCursor(spoolDir: string): Promise<bigint>;
-export declare function appendReceiptToSpool(spoolDir: string, envelope: ReceiptEnvelope<unknown>): Promise<ReceiptSpoolAppendResult>;
-export declare function appendReceiptToConfiguredSpool(envelope: ReceiptEnvelope<unknown>, env?: NodeJS.ProcessEnv): Promise<ReceiptSpoolAppendResult | undefined>;

package/dist/types/harness-control-plane/receipts.d.ts

@@ -1,149 +0,0 @@
-import { type GitDelta, type ReceiptFamily, type RecoveryClassification, type ReviewVerdict } from "./types";
-export interface ReceiptSubject {
-    workspace: string;
-    branch: string | null;
-    head: string | null;
-    commit: string | null;
-}
-export interface ReceiptEnvelope<E = Record<string, unknown>> {
-    receiptId: string;
-    schemaVersion: number;
-    sessionId: string;
-    family: ReceiptFamily;
-    valid: boolean;
-    createdAt: string;
-    source: string;
-    subject: ReceiptSubject;
-    evidence: E;
-    /** Hashes of out-of-line artifacts (diff patches, validation logs) folded into the receipt hash. */
-    artifactHashes: Record<string, string>;
-    sha256: string;
-}
-export declare const RECEIPT_SCHEMA_VERSION: 1;
-/** Deterministic stringify with sorted keys (stable hash basis). */
-export declare function canonicalJson(value: unknown): string;
-export declare function sha256Hex(input: string): string;
-export interface BuildReceiptInput<E> {
-    receiptId: string;
-    sessionId: string;
-    family: ReceiptFamily;
-    source: string;
-    subject: ReceiptSubject;
-    evidence: E;
-    artifactHashes?: Record<string, string>;
-    createdAt?: string;
-    valid?: boolean;
-}
-export declare function buildReceipt<E>(input: BuildReceiptInput<E>): ReceiptEnvelope<E>;
-export interface ValidationOutcome {
-    valid: boolean;
-    reasons: string[];
-}
-/** Recompute the hash and run structural family checks. Fail-closed. */
-export declare function validateReceipt(receipt: ReceiptEnvelope<unknown>): ValidationOutcome;
-export interface VanishEvidence {
-    classification: RecoveryClassification;
-    gitDelta: GitDelta;
-    gitStatusPorcelain: string;
-    untrackedManifest: {
-        path: string;
-        size: number;
-        sha256: string;
-    }[];
-    preservation: "snapshot" | "stash" | "block";
-    stashRef: string | null;
-    snapshotComplete: boolean;
-    forbiddenActions: string[];
-}
-export interface PromptAcceptanceEvidence {
-    promptSha256: string;
-    rpcCommandId: string;
-    preSubmitState: {
-        isStreaming: boolean;
-        steeringQueueDepth: number;
-        followupQueueDepth: number;
-    };
-    preSubmitCursor: number;
-    agentStartCursor: number;
-    acceptedAt: string;
-    singleFlight: true;
-}
-export interface ValidationEvidence {
-    command: string;
-    exactCommand: string;
-    cwd: string;
-    exitStatus: number;
-    pass: boolean;
-    commitUnderTest: string | null;
-}
-export interface CompletionEvidence {
-    finalCommit: string;
-    branch: string;
-    prUrl: string | null;
-    issueArtifact: string | null;
-    requiredValidationReceiptIds: string[];
-    finalLifecycle: string;
-    finalizedAt: string;
-    blockers: string[];
-}
-export interface ReviewVerdictEvidence {
-    verdict: ReviewVerdict;
-    prTarget: string | null;
-    finalizedAt: string;
-    /** Bounded summary code/reference for the verdict; never raw assistant text. */
-    summaryRef: string | null;
-    /** Where the verdict came from: explicit operator input or extracted from final assistant text. */
-    verdictSource?: "input" | "assistant";
-    /** sha256 of the assistant text the verdict was extracted from, when sourced from the agent. */
-    assistantDigest?: string | null;
-}
-export interface ReviewFailureEvidence {
-    /** Machine-actionable reason the review produced no terminal verdict. */
-    reason: string;
-    prTarget: string | null;
-    failedAt: string;
-    /** Routing hint for the operator/fallback path. */
-    fallback: string;
-    /** sha256 of the assistant text examined for a verdict, when one was available. */
-    assistantDigest?: string | null;
-    /** Bounded, whitespace-collapsed assistant summary (never an unbounded transcript dump). */
-    assistantSummary?: string | null;
-}
-/** Pointer back to one superseded child task receipt. */
-export interface PhaseRollupChildPointer {
-    id: string;
-    status: "completed" | "failed" | "aborted" | "merge_failed" | "paused";
-    /** Artifact URI holding the child's full output, when available. */
-    outputUri: string | null;
-    /** Content hash of the child's output artifact, when available. */
-    outputSha256: string | null;
-    /** Hash of the child receipt itself (canonical JSON), for staleness checks. */
-    receiptSha256: string;
-    /**
-     * Per-child ROI accounting carried into the rollup so the aggregate totals
-     * below are recomputable/verifiable from child evidence (not self-reported).
-     * `tokens` is the child's effective token count; cost/cloned are null when
-     * the child reported no such accounting.
-     */
-    tokens: number;
-    costTotal: number | null;
-    clonedTokens: number | null;
-    lowRoi: boolean;
-}
-export interface PhaseRollupEvidence {
-    /** Harness lifecycle boundary this rollup was emitted at. */
-    phase: string;
-    children: PhaseRollupChildPointer[];
-    aggregate: {
-        childCount: number;
-        completed: number;
-        failed: number;
-        totalTokens: number;
-        totalCostTotal: number | null;
-        totalClonedTokens: number | null;
-        lowRoiChildIds: string[];
-    };
-}
-export declare function validatePhaseRollup(e: PhaseRollupEvidence): string[];
-/** Classifications that MUST have a valid `vanish` receipt before the action proceeds. */
-export declare function requiresVanishBeforeAction(classification: RecoveryClassification): boolean;

package/dist/types/harness-control-plane/rpc-adapter.d.ts

@@ -1,69 +0,0 @@
-export interface RpcStateSnapshot {
-    isStreaming: boolean;
-    steeringQueueDepth: number;
-    followupQueueDepth: number;
-}
-/** Abstract handle to a live sayknow-cli RPC session. */
-export interface HarnessRpc {
-    getState(): Promise<RpcStateSnapshot>;
-    /** Send a prompt; resolves with the RPC command id and whether it was acked. Does NOT await agent_start. */
-    sendPrompt(prompt: string): Promise<{
-        commandId: string;
-        ack: boolean;
-    }>;
-    /** Monotonic count of events observed so far (the acceptance cursor). */
-    eventCursor(): number;
-    /** Resolve when an `agent_start` event arrives strictly after `afterCursor`, else null on timeout. */
-    waitForAgentStart(afterCursor: number, timeoutMs: number): Promise<{
-        cursor: number;
-    } | null>;
-    close(): Promise<void>;
-    /** Subscribe to parsed event frames (non-ready, non-response), fired AFTER the cursor advances. Returns unsubscribe. */
-    onEventFrame?(listener: (frame: Record<string, unknown>) => void): () => void;
-    /** Whether the underlying RPC subprocess is still alive. */
-    isLive?(): boolean;
-    /** ISO timestamp of the last observed event frame, or null. */
-    lastFrameAt?(): string | null;
-    /** Final assistant text from the live session (for review-verdict extraction); null when unavailable. */
-    getLastAssistantText?(): Promise<string | null>;
-}
-export interface AcceptanceResult {
-    accepted: boolean;
-    reason: string;
-    commandId: string | null;
-    preSubmitCursor: number;
-    agentStartCursor: number | null;
-    preSubmitState: RpcStateSnapshot;
-}
-/**
- * Single-flight acceptance: idle + empty-queue pre-state, ack, then the NEXT
- * `agent_start` after the pre-submit cursor within `timeoutMs`.
- */
-export declare function singleFlightAccept(rpc: HarnessRpc, prompt: string, timeoutMs: number): Promise<AcceptanceResult>;
-/**
- * Real adapter: spawns `skc --mode rpc --session-dir <dir>` and speaks the JSONL
- * protocol from docs/rpc.md. Verified end-to-end in the M10 suite.
- */
-export declare class SayknowCliRpc implements HarnessRpc {
-    #private;
-    constructor(opts: {
-        sessionDir: string;
-        command?: string[];
-        cwd?: string;
-        env?: NodeJS.ProcessEnv;
-    });
-    onEventFrame(listener: (frame: Record<string, unknown>) => void): () => void;
-    isLive(): boolean;
-    lastFrameAt(): string | null;
-    getState(): Promise<RpcStateSnapshot>;
-    getLastAssistantText(): Promise<string | null>;
-    sendPrompt(prompt: string): Promise<{
-        commandId: string;
-        ack: boolean;
-    }>;
-    eventCursor(): number;
-    waitForAgentStart(afterCursor: number, timeoutMs: number): Promise<{
-        cursor: number;
-    } | null>;
-    close(): Promise<void>;
-}

package/dist/types/harness-control-plane/seams.d.ts

@@ -1,21 +0,0 @@
-/**
- * v1 seams (M11). The control plane is harness-agnostic by design, but v1 ships ONLY the
- * sayknow-cli adapter. Other harnesses and transports are explicit, designed-not-built seams
- * that fail closed with a clear `seam_unsupported_in_v1` signal rather than silently degrading.
- */
-import type { Harness } from "./types";
-export declare const SUPPORTED_HARNESSES: readonly Harness[];
-export declare const DEFERRED_SEAMS: readonly ["codex-adapter", "omx-adapter", "remote-transport", "global-daemon", "capability-token-auth", "web-viewer", "fleet-control-plane", "rich-tui-coview"];
-export type DeferredSeam = (typeof DEFERRED_SEAMS)[number];
-export declare function isHarnessSupported(harness: string): harness is Harness;
-export interface UnsupportedSeamResult {
-    ok: false;
-    error: string;
-    evidence: {
-        seam: true;
-        name: string;
-        supported: readonly Harness[];
-        deferred: readonly string[];
-    };
-}
-export declare function unsupportedSeam(name: string): UnsupportedSeamResult;

package/dist/types/harness-control-plane/session-lease.d.ts

@@ -1,65 +0,0 @@
-export interface SessionLease {
-    ownerId: string;
-    sessionId: string;
-    pid: number;
-    leaseTokenHash: string;
-    endpoint: {
-        kind: "unix-socket" | "fifo";
-        path: string;
-    } | null;
-    eventsPath: string;
-    heartbeatAt: string;
-    expiresAt: string;
-    leaseEpoch: number;
-    writer: {
-        ownerId: string;
-        leaseEpoch: number;
-    };
-}
-export declare class LeaseError extends Error {
-    readonly code: string;
-    constructor(message: string, code: string);
-}
-export type LeaseStatus = "missing" | "live" | "expiredAlive" | "dead" | "epermAlive";
-type PidStatus = "alive" | "dead" | "eperm";
-export declare function readLease(root: string, sessionId: string): Promise<SessionLease | null>;
-export declare function isExpired(lease: SessionLease, clock?: () => number): boolean;
-export declare function classifyLeaseStatus(lease: SessionLease | null, opts?: {
-    clock?: () => number;
-    probe?: (pid: number) => PidStatus;
-}): LeaseStatus;
-/** Liveness probe via signal 0. Defaults to the real process table; injectable for tests. */
-export declare function isOwnerAlive(pid: number, probe?: (pid: number) => boolean): boolean;
-export declare function isStale(lease: SessionLease, opts?: {
-    clock?: () => number;
-    probe?: (pid: number) => boolean;
-}): boolean;
-export interface AcquireOptions {
-    ownerId: string;
-    pid: number;
-    endpoint?: SessionLease["endpoint"];
-    eventsPath: string;
-    ttlMs: number;
-    clock?: () => number;
-    probe?: (pid: number) => boolean | PidStatus;
-}
-export interface AcquiredLease {
-    lease: SessionLease;
-    token: string;
-}
-/**
- * Acquire (or take over a stale) lease. Fails closed with `lease_held` when a live,
- * unexpired lease is held by a different owner. Re-acquiring as the current owner refreshes.
- */
-export declare function acquireLease(root: string, sessionId: string, opts: AcquireOptions): Promise<AcquiredLease>;
-/** Refresh the lease expiry. Only the recorded owner may heartbeat (single-writer). */
-export declare function heartbeat(root: string, sessionId: string, ownerId: string, ttlMs: number, clock?: () => number): Promise<SessionLease>;
-/** Whether `ownerId` is the live, unexpired single writer permitted to append events. */
-export declare function canWriteEvents(lease: SessionLease, ownerId: string, clock?: () => number): boolean;
-/** Release the lease (owner shutdown). Only the holder may release. */
-export declare function releaseLease(root: string, sessionId: string, ownerId: string): Promise<void>;
-export declare function reapDeadOwnerArtifacts(root: string, sessionId: string, expectedOwnerId: string, expectedEpoch: number, opts?: {
-    clock?: () => number;
-    probe?: (pid: number) => PidStatus;
-}): Promise<boolean>;
-export {};