@kynver-app/runtime 0.1.42 → 0.1.47

package/dist/plan-progress.d.ts

@@ -0,0 +1,10 @@
+export interface PlanProgressCliEvidence {
+    type: string;
+    value: string;
+    exitCode?: number;
+    stdoutTail?: string;
+}
+export declare function emitPlanProgress(args: Record<string, string | boolean>): Promise<void>;
+/** Memory-bounded local verify (npm typecheck/test) before optional API verify. */
+export declare function verifyPlanLocal(args: Record<string, string | boolean>): void;
+export declare function verifyPlan(args: Record<string, string | boolean>): Promise<void>;

package/dist/pr-handoff/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./pr-handoff.types.js";
+export * from "./pr-handoff-assess.js";
+export * from "./pr-handoff-gh.js";
+export { ensurePrReadyHandoff } from "./pr-handoff.js";

package/dist/pr-handoff/pr-handoff-assess.d.ts

@@ -0,0 +1,26 @@
+import type { GitAncestry } from "../git.js";
+import type { PrHandoffRequirement, PrHandoffSnapshot } from "./pr-handoff.types.js";
+/** Best-effort PR URL from free text (completion summary / final result). */
+export declare function extractPrUrlFromText(value: unknown): string | null;
+/**
+ * Board-dispatched implementation workers with code changes must land with a PR
+ * URL before AgentOS completion is posted.
+ */
+export declare function assessPrHandoffRequirement(input: {
+    dispatched?: boolean;
+    routingRule?: string | null;
+    prUrl?: string | null;
+    patchPath?: string | null;
+    artifactBundlePath?: string | null;
+    snapshot: PrHandoffSnapshot;
+}): PrHandoffRequirement;
+export declare function buildPrHandoffSnapshotFromStatus(status: {
+    changedFiles: string[];
+    branch: string;
+    worktreePath: string;
+    gitAncestry: GitAncestry;
+    finalResult: unknown;
+}, extras?: {
+    prUrl?: string | null;
+    headCommit?: string | null;
+}): PrHandoffSnapshot;

package/dist/pr-handoff/pr-handoff-gh.d.ts

@@ -0,0 +1,44 @@
+export interface CommandCapture {
+    status: number | null;
+    stdout: string;
+    stderr: string;
+    error: string | null;
+}
+export interface PrHandoffExec {
+    git: (cwd: string, args: string[]) => CommandCapture;
+    gh: (cwd: string, args: string[]) => CommandCapture;
+}
+export declare const defaultPrHandoffExec: PrHandoffExec;
+export declare function resolveGithubRepo(worktreePath: string, exec: PrHandoffExec): string | null;
+export declare function resolveHeadCommit(worktreePath: string, exec: PrHandoffExec): string | null;
+/** Look up an open PR for this head branch. */
+export declare function findOpenPrUrl(worktreePath: string, repo: string, branch: string, exec: PrHandoffExec): string | null;
+export interface CommitAndPushResult {
+    ok: boolean;
+    committed: boolean;
+    pushed: boolean;
+    headCommit?: string;
+    detail?: string;
+}
+export declare function commitAndPushBranch(input: {
+    worktreePath: string;
+    branch: string;
+    commitMessage: string;
+    hasDirtyFiles: boolean;
+    exec: PrHandoffExec;
+}): CommitAndPushResult;
+export interface CreatePrResult {
+    ok: boolean;
+    prUrl?: string;
+    created?: boolean;
+    detail?: string;
+}
+export declare function createGithubPr(input: {
+    worktreePath: string;
+    repo: string;
+    branch: string;
+    base: string;
+    title: string;
+    body: string;
+    exec: PrHandoffExec;
+}): CreatePrResult;

package/dist/pr-handoff/pr-handoff.d.ts

@@ -0,0 +1,8 @@
+import { type PrHandoffExec } from "./pr-handoff-gh.js";
+import type { EnsurePrHandoffInput, EnsurePrHandoffResult } from "./pr-handoff.types.js";
+/**
+ * Ensure a board-dispatched implementation worker has a GitHub PR before completion
+ * is posted to AgentOS. Commits dirty trees, pushes the branch, and runs
+ * `gh pr create` when needed.
+ */
+export declare function ensurePrReadyHandoff(input: EnsurePrHandoffInput, exec?: PrHandoffExec): EnsurePrHandoffResult;

package/dist/pr-handoff/pr-handoff.types.d.ts

@@ -0,0 +1,45 @@
+import type { GitAncestry } from "../git.js";
+import type { RawHarnessWorkerStatus } from "../status.js";
+import type { HarnessRunRecord } from "../run-store.js";
+import type { HarnessWorkerRecord } from "../status.js";
+export interface PrHandoffSnapshot {
+    changedFiles: string[];
+    headCommit: string | null;
+    prUrl: string | null;
+    branch: string;
+    worktreePath: string;
+    gitAncestry: GitAncestry;
+    finalResult: unknown;
+}
+export type PrHandoffSkipReason = "not_dispatched" | "review_lane" | "already_has_pr" | "no_work_product" | "patch_or_bundle";
+export interface PrHandoffNotRequired {
+    required: false;
+    reason: PrHandoffSkipReason;
+}
+export interface PrHandoffRequired {
+    required: true;
+    snapshot: PrHandoffSnapshot;
+}
+export type PrHandoffRequirement = PrHandoffNotRequired | PrHandoffRequired;
+export interface EnsurePrHandoffInput {
+    worker: HarnessWorkerRecord;
+    run: HarnessRunRecord;
+    status: RawHarnessWorkerStatus;
+    /** PR url extracted from finalResult text when the flat field is absent. */
+    prUrlHint?: string | null;
+}
+export interface EnsurePrHandoffOk {
+    ok: true;
+    /** Present when a PR was created or discovered. */
+    prUrl?: string;
+    headCommit?: string;
+    committed?: boolean;
+    pushed?: boolean;
+    created?: boolean;
+}
+export interface EnsurePrHandoffBlocked {
+    ok: false;
+    reason: string;
+    nextAction: string;
+}
+export type EnsurePrHandoffResult = EnsurePrHandoffOk | EnsurePrHandoffBlocked;

package/dist/prompt.d.ts

@@ -0,0 +1,14 @@
+export declare function buildPrompt(input: {
+    task: string;
+    ownedPaths: string[];
+    worktreePath: string;
+    heartbeatPath: string;
+    planId?: string;
+    taskId?: string;
+    /** Lane A operating rules from dispatch-next `harnessWorkerContext`. */
+    instructionPolicyMarkdown?: string | null;
+    /** Anchored task context-envelope persona block (required when task has personaSlug). */
+    personaMarkdown?: string | null;
+    /** When set, Haiku/compact models get a shorter harness instruction block. */
+    model?: string;
+}): string;

package/dist/providers/claude.d.ts

@@ -0,0 +1,4 @@
+import type { WorkerProvider } from "./types.js";
+/** Provider default when no explicit model is passed — Sonnet, not Opus. */
+export declare const CLAUDE_DEFAULT_MODEL = "claude-sonnet-4-6";
+export declare const claudeProvider: WorkerProvider;

package/dist/providers/cursor-windows.d.ts

@@ -0,0 +1,7 @@
+export declare function parseCursorVersionSortKey(versionName: string): number | null;
+export declare function pickLatestCursorVersionDir(agentRoot: string): string | null;
+export declare function resolveWindowsCursorBundled(agentRoot?: string): {
+    nodeExe: string;
+    indexJs: string;
+    versionDir: string;
+} | null;

package/dist/providers/cursor.d.ts

@@ -0,0 +1,11 @@
+import type { WorkerProvider } from "./types.js";
+export interface CursorSpawnTarget {
+    executable: string;
+    prefixArgs: string[];
+    shell: boolean;
+    detached: boolean;
+    bundledVersionDir?: string;
+}
+/** Resolve a headless Windows spawn target (node.exe + index.js), never agent.cmd via shell. */
+export declare function resolveCursorSpawn(agentBin: string): CursorSpawnTarget;
+export declare const cursorProvider: WorkerProvider;

package/dist/providers/model-preflight.d.ts

@@ -0,0 +1,31 @@
+export interface ModelPreflightResult {
+    /** False when the model/provider combination is structurally invalid. */
+    ok: boolean;
+    /** The model to launch with (normalized). Meaningful only when `ok`. */
+    model: string;
+    /** True when the requested model was rewritten to a different launch model. */
+    normalized: boolean;
+    /** The originally requested model, present only when it differs from `model`. */
+    requested?: string;
+    /** Human-readable note: the normalization explanation, or the rejection reason. */
+    note?: string;
+}
+/** Strip a single trailing reasoning-effort suffix from a model id. */
+export declare function stripReasoningSuffix(model: string): string;
+/**
+ * Normalize provider=cursor requests that pass model=cursor (or similar aliases)
+ * to a real Cursor CLI model. `auto` is the supported default when the board
+ * does not pin a specific composer id.
+ */
+export declare function normalizeCursorModelAlias(model: string): string | null;
+/**
+ * Preflight a model for the `claude` provider. Normalizes reasoning-effort
+ * suffixes; rejects models that clearly belong to another provider.
+ */
+export declare function preflightClaudeModel(model: string | undefined, defaultModel: string): ModelPreflightResult;
+/**
+ * Preflight a model for the `cursor` provider. The Cursor agent owns its own
+ * reasoning levels, so suffixed ids pass through; we only flag a Claude-family
+ * model that was clearly meant for the `claude` provider.
+ */
+export declare function preflightCursorModel(model: string | undefined, defaultModel: string): ModelPreflightResult;

package/dist/providers/registry.d.ts

@@ -0,0 +1,4 @@
+import type { WorkerProvider } from "./types.js";
+/** Test hook — inject a stub provider without spawning Claude. */
+export declare function setWorkerProviderForTests(provider: WorkerProvider | null): void;
+export declare function resolveWorkerProvider(name?: string): WorkerProvider;

package/dist/providers/types.d.ts

@@ -0,0 +1,32 @@
+export interface WorkerProviderStartOptions {
+    name: string;
+    task: string;
+    ownedPaths?: string[];
+    model?: string;
+    branch?: string;
+    worktreePath: string;
+    workerDir: string;
+    stdoutPath: string;
+    stderrPath: string;
+    heartbeatPath: string;
+    /** Fully built agent prompt passed to the provider CLI. */
+    prompt: string;
+}
+export interface WorkerProviderStartResult {
+    pid: number;
+    model?: string;
+}
+export type { ModelPreflightResult } from "./model-preflight.js";
+import type { ModelPreflightResult } from "./model-preflight.js";
+export interface WorkerProvider {
+    name: string;
+    /** Model launched when the caller does not request one. */
+    defaultModel?: string;
+    /**
+     * Validate + normalize a requested model before spawn. Returns the launch model
+     * (possibly rewritten) or a structured failure for an invalid model/provider
+     * combination. When absent, the model is passed through unchanged.
+     */
+    preflightModel?(model: string | undefined): ModelPreflightResult;
+    start(opts: WorkerProviderStartOptions): WorkerProviderStartResult;
+}

package/dist/redact.d.ts

@@ -0,0 +1 @@
+export declare function redactHarness(text: string, secret?: string): string;

package/dist/resource-gate.d.ts

@@ -0,0 +1,53 @@
+import { type KynverUserConfig } from "./config.js";
+/** Default RAM budget per worker (~500 MiB, dogfood measured). Internal — not a setup knob. */
+export declare const DEFAULT_PER_WORKER_MEM_BYTES: number;
+/** Keep headroom for OS / IDE. Internal — not a setup knob. */
+export declare const DEFAULT_MEM_RESERVE_BYTES: number;
+/** Fraction of total RAM used when auto-sizing worker cap. Internal. */
+export declare const DEFAULT_MEM_UTILIZATION = 0.85;
+/** Auto cap when the user has not set maxConcurrentWorkers (safety on huge hosts). */
+export declare const AUTO_MAX_WORKERS_CEILING = 64;
+export interface RunnerResourceGateShape {
+    ok: boolean;
+    totalMemBytes: number;
+    freeMemBytes: number;
+    memReserveBytes: number;
+    perWorkerMemBytes: number;
+    configuredMaxWorkers: number | null;
+    autoCap: number;
+    capacityWorkers: number;
+    maxConcurrentWorkers: number;
+    activeWorkers: number;
+    slotsAvailable: number;
+    reason: string | null;
+}
+export interface ObserveResourceGateInput {
+    runId: string;
+    config?: KynverUserConfig;
+    /** Command Center / workspace override — wins over local config when set. */
+    configuredMaxWorkersOverride?: number | null;
+    /** Override active worker count (tests). */
+    activeWorkers?: number;
+    totalMemBytes?: number;
+    freeMemBytes?: number;
+}
+/** How many workers this host could run from RAM alone (before a user cap). */
+export declare function computeAutoMaxWorkers(totalMemBytes: number, opts?: {
+    perWorkerMemBytes?: number;
+    memReserveBytes?: number;
+    memUtilization?: number;
+}): number;
+/** Count active workers in ONE run (kept for callers/tests scoped to a run). */
+export declare function countActiveWorkers(runId: string): number;
+/**
+ * Count active workers across EVERY run on disk. The harness creates a new run
+ * per task, so a per-run count let concurrent runs each believe the machine was
+ * idle — the configured cap was never a real global ceiling (the "spawns 4 or
+ * infinity, never N" bug). This machine-wide count is what the gate must use.
+ */
+export declare function countActiveWorkersGlobal(): number;
+/**
+ * Compute how many workers this host can run and how many dispatch slots remain.
+ * Uses total RAM for steady-state capacity and free RAM as a hard safety gate.
+ */
+export declare function observeRunnerResourceGate(input: ObserveResourceGateInput): RunnerResourceGateShape;

package/dist/retry-limits.d.ts

@@ -0,0 +1,8 @@
+/** Local dispatch retry/cooldown limits. */
+export interface HarnessRetryLimits {
+    /** Advisory max task attempts surfaced to operator/dispatch (default 3). */
+    maxTaskAttempts: number;
+    /** Minimum ms between dispatch starts for the same run (default 5s). */
+    dispatchCooldownMs: number;
+}
+export declare function readHarnessRetryLimits(): HarnessRetryLimits;

package/dist/run-store.d.ts

@@ -0,0 +1,30 @@
+import type { HarnessWorkerRecord } from "./status.js";
+export interface HarnessRunRecord {
+    id: string;
+    name: string;
+    repo: string;
+    base: string;
+    baseCommit: string;
+    status: string;
+    createdAt: string;
+    workers: Record<string, {
+        workerDir: string;
+        statusPath: string;
+    }>;
+}
+export declare function getPaths(): {
+    harnessRoot: string;
+    runsDir: string;
+    worktreesDir: string;
+};
+export declare function loadRun(id: string): HarnessRunRecord;
+/**
+ * Load every run record on disk. Used for global, cross-run accounting (the
+ * resource gate must see workers from ALL runs, and stale-run finalization
+ * iterates the whole set). Unreadable/partial run dirs are skipped.
+ */
+export declare function listRunRecords(): HarnessRunRecord[];
+export declare function loadWorker(runId: string, name: string): HarnessWorkerRecord;
+export declare function saveRun(run: HarnessRunRecord): void;
+export declare function saveWorker(runId: string, worker: HarnessWorkerRecord): void;
+export declare function runDirectory(id: string): string;

package/dist/shell-command-outcome.d.ts

@@ -0,0 +1,32 @@
+export type ShellCommandOutcomeKind = "success" | "audit_findings" | "command_failure";
+export interface NpmAuditSummary {
+    total: number;
+    critical: number;
+    high: number;
+    moderate: number;
+    low: number;
+    info: number;
+}
+export interface ShellCommandOutcome {
+    kind: ShellCommandOutcomeKind;
+    exitCode: number;
+    /** Short operator-facing line (no raw JSON blob). */
+    summary: string;
+    /** Present when kind === audit_findings and JSON parsed. */
+    audit?: NpmAuditSummary;
+    /** When JSON was expected but invalid. */
+    parseError?: string;
+}
+export declare function summarizeNpmAuditReport(report: Record<string, unknown>): NpmAuditSummary | null;
+export declare function classifyNpmAuditOutcome(input: {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}): ShellCommandOutcome;
+export declare function classifyShellCommandOutcome(input: {
+    command: string;
+    exitCode: number;
+    stdout?: string;
+    stderr?: string;
+    interleavedOutput?: string;
+}): ShellCommandOutcome;

package/dist/stale-reconcile.d.ts

@@ -0,0 +1,25 @@
+import { type RunFinalizeResult } from "./finalize.js";
+/** No heartbeat this long + dead PID → reconcile as exited. */
+export declare const STALE_RECONCILE_HEARTBEAT_MS: number;
+export interface StaleWorkerReconcileOutcome {
+    runId: string;
+    worker: string;
+    action: "marked_exited" | "killed_stale" | "skipped";
+    reason: string;
+}
+export interface ReconcileStaleWorkersResult {
+    workers: StaleWorkerReconcileOutcome[];
+    finalizedRuns: RunFinalizeResult[];
+}
+/**
+ * Reconcile workers that exited without updating worker.json, and optionally
+ * terminate long-idle live processes. Paused workers with recent heartbeat
+ * blockers are left alone (heartbeat freshness gate).
+ */
+export declare function reconcileStaleWorkers(): ReconcileStaleWorkersResult;
+/**
+ * One-shot CLI entry for `kynver run reconcile`: reconciles stale workers and
+ * finalizes dead runs globally without requiring a running daemon. Prints a
+ * JSON summary to stdout.
+ */
+export declare function reconcileRunsCli(): void;

package/dist/status.d.ts

@@ -0,0 +1,161 @@
+import { type GitAncestry } from "./git.js";
+import { type WorkerLandingContract } from "./landing-contract-gate.js";
+export declare const NO_START_MS = 180000;
+export declare const STALE_MS = 600000;
+export interface WorkerAttention {
+    state: "done" | "needs_attention" | "blocked" | "stale" | "ok";
+    reason: string;
+}
+/** Snapshot of Lane A policy injection at worker spawn (from dispatch-next). */
+export interface InstructionPolicyEvidenceSnapshot {
+    fingerprint?: string;
+    ruleSlugs?: string[];
+    globalRuleCount?: number;
+    personaRuleCount?: number;
+    explicitKindCount?: number;
+    invariantCount?: number;
+    markdownChars?: number;
+    injectedAt?: string;
+}
+/** Snapshot of anchored persona context-envelope injection at worker spawn. */
+export interface PersonaContextEvidenceSnapshot {
+    expectedPersonaSlug?: string;
+    injectedPersonaSlug?: string;
+    displayName?: string;
+    operatingRuleCount?: number;
+    anchorTaskId?: string;
+    envelopeGeneratedAt?: string;
+    injectedAt?: string;
+    markdownChars?: number;
+}
+export interface HarnessWorkerRecord {
+    name: string;
+    runId: string;
+    status: string;
+    pid?: number;
+    model?: string;
+    branch: string;
+    worktreePath: string;
+    workerDir: string;
+    stdoutPath: string;
+    stderrPath: string;
+    heartbeatPath: string;
+    ownedPaths?: string[];
+    agentOsId?: string;
+    taskId?: string;
+    planId?: string;
+    /** Lane A policy fingerprint when dispatch injected operating rules. */
+    instructionPolicyFingerprint?: string;
+    instructionPolicyEvidence?: InstructionPolicyEvidenceSnapshot;
+    personaSlug?: string;
+    personaEvidence?: PersonaContextEvidenceSnapshot;
+    leaseOwner?: string;
+    dispatched?: boolean;
+    startedAt?: string;
+    /** Routing audit — which rule selected model/provider (dispatch inference). */
+    routingRule?: string;
+    requestedModel?: string;
+    /** Set when stale-reconcile patches a dead/stale worker record. */
+    reconciledAt?: string;
+    reconcileReason?: string;
+    /** Last heartbeat blocker text successfully synced to plan-progress-sync (dedupe). */
+    lastSyncedHeartbeatBlocker?: string;
+    /**
+     * Set when the most recent AgentOS completion replay for this finished worker
+     * was rejected (e.g. a revoked / expired / cross-workspace runner token) or
+     * otherwise failed. While set, the worker is NOT treated as cleanly done:
+     * `finalizeStaleRuns` keeps the run non-terminal and the board surfaces it.
+     * Cleared once the completion is acknowledged (2xx). Local-only — never sent
+     * to the server as part of the worker's intrinsic status.
+     */
+    completionBlocker?: string;
+    /** ISO timestamp when `/harness/completion` returned 2xx for this worker. */
+    completionReportedAt?: string;
+    /** Snapshot from the acknowledged completion POST — local-only. */
+    completionSnapshot?: {
+        finalResult?: unknown;
+        prUrl?: string | null;
+        summary?: string | null;
+    };
+    /** Audit tag for how `completionReportedAt` was set (`tryCompleteWorker`, `board-task-*`). */
+    completionAckSource?: string;
+    /** Local mirror of the last completion POST outcome. */
+    completionOutcome?: "acknowledged" | "rejected";
+    /** Truncated JSON body from the last acknowledged completion response. */
+    completionResponse?: unknown;
+    /**
+     * Direct/local worker with no board linkage — must not be mistaken for an
+     * AgentTask-backed harness worker in completion or dispatch paths.
+     */
+    localOnly?: boolean;
+    /** Sidecar PID when detached; used for observability only. */
+    completionSidecarPid?: number;
+    completionSidecarSpawnFailedAt?: string;
+}
+export interface RawHarnessWorkerStatus {
+    runId: string;
+    worker: string;
+    pid?: number;
+    alive: boolean;
+    status: string;
+    attention: WorkerAttention;
+    branch: string;
+    worktreePath: string;
+    ownedPaths?: string[];
+    stdoutBytes: number;
+    stderrBytes: number;
+    heartbeatBytes: number;
+    firstEventAt: string | null;
+    lastEventAt: string | null;
+    lastActivityAt: string | null;
+    currentTool: string | null;
+    heartbeatCount: number;
+    lastHeartbeatAt: string | null;
+    lastHeartbeatPhase: string | null;
+    lastHeartbeatSummary: string | null;
+    heartbeatBlocker: string | null;
+    /** Parser-detected timestamp anomalies (e.g., future heartbeat ts). */
+    timestampAnomalies?: Array<{
+        kind: "future_heartbeat_timestamp";
+        observedAt: string;
+        clampedTo: string;
+    }>;
+    finalResult: unknown;
+    error?: string;
+    changedFiles: string[];
+    gitAncestry: GitAncestry;
+    /** Set by PR-ready handoff before completion is posted. */
+    prUrl?: string;
+    headCommit?: string;
+}
+export interface WorkerStatusOptions {
+    /** Branch ref for ancestry when baseCommit is not set. */
+    base?: string;
+    /** Pinned SHA from run creation — preferred for ancestry vs a moving branch tip. */
+    baseCommit?: string;
+}
+export declare function computeAttention(input: {
+    alive: boolean;
+    finalResult: unknown;
+    firstEventAt: string | null;
+    stdoutBytes: number;
+    heartbeatBytes: number;
+    lastActivityAt: string | null;
+    heartbeatBlocker: string | null;
+    startedAt?: string;
+    /** stderr tail / parsed error for a worker that died without a final result. */
+    error?: string | null;
+    changedFiles?: string[];
+    gitAncestry?: GitAncestry | null;
+    completionBlocker?: string | null;
+    landingContract?: WorkerLandingContract | null;
+    prUrl?: string | null;
+}): WorkerAttention;
+export declare function computeWorkerStatus(worker: HarnessWorkerRecord, options?: WorkerStatusOptions): RawHarnessWorkerStatus;
+export declare function isFinishedWorkerStatus(status: RawHarnessWorkerStatus): boolean;
+/** True when a worker recorded a final result but failed the landing gate. */
+export declare function isLandingBlockedWorkerStatus(status: RawHarnessWorkerStatus): boolean;
+export declare function deriveRunStatus(fallback: string, workers: Array<{
+    attention?: string;
+    status?: string;
+}>): string;

package/dist/stream.d.ts

@@ -0,0 +1,20 @@
+import { type ShellCommandOutcome } from "./shell-command-outcome.js";
+export interface ParsedStream {
+    firstEventAt: string | null;
+    lastEventAt: string | null;
+    currentTool: string | null;
+    finalResult: unknown;
+    error: string | null;
+    /** Most recent non-success shell outcome for operator error streams. */
+    lastShellOutcome: ShellCommandOutcome | null;
+}
+/**
+ * Parse harness worker stdout (`stream-json` from Claude Code or Cursor Agent).
+ * Cursor emits `tool_call` events and may only write `type: "result"` after exit;
+ * completion heartbeats are merged in `computeWorkerStatus`.
+ */
+export declare function parseHarnessStream(file: string): ParsedStream;
+/** @deprecated Use {@link parseHarnessStream} — kept for existing imports. */
+export declare function parseClaudeStream(file: string): ParsedStream;
+export declare function summarizeShellToolCallEvent(event: Record<string, unknown>): string | undefined;
+export declare function summarizeEvent(event: Record<string, unknown>): string | undefined;

package/dist/supervisor.d.ts

@@ -0,0 +1,25 @@
+import type { HarnessRunRecord } from "./run-store.js";
+import type { HarnessWorkerRecord, InstructionPolicyEvidenceSnapshot, PersonaContextEvidenceSnapshot } from "./status.js";
+export interface SpawnWorkerOptions {
+    name: string;
+    task: string;
+    ownedPaths?: string[];
+    model?: string;
+    branch?: string;
+    agentOsId?: string;
+    taskId?: string;
+    planId?: string;
+    instructionPolicyMarkdown?: string | null;
+    instructionPolicyFingerprint?: string | null;
+    instructionPolicyEvidence?: InstructionPolicyEvidenceSnapshot | null;
+    personaMarkdown?: string | null;
+    personaSlug?: string | null;
+    personaEvidence?: PersonaContextEvidenceSnapshot | null;
+    leaseOwner?: string;
+    dispatched?: boolean;
+    provider?: string;
+    routingRule?: string;
+    requestedModel?: string;
+}
+export declare function spawnWorkerProcess(run: HarnessRunRecord, opts: SpawnWorkerOptions): HarnessWorkerRecord;
+export declare function startWorker(args: Record<string, string | boolean>): Promise<void>;

package/dist/sweep.d.ts

@@ -0,0 +1 @@
+export declare function sweepRun(args: Record<string, string | boolean>): Promise<Record<string, unknown> | void>;

package/dist/util.d.ts

@@ -0,0 +1,22 @@
+export declare function fail(message: string): never;
+/** Avoid flashing a visible console on Windows when spawning worker/sidecar children. */
+export declare function hiddenSpawnOptions<T extends Record<string, unknown>>(opts: T): T;
+export declare function required(value: string | undefined, name: string): string;
+export declare function safeJson(line: string): unknown;
+export declare function readJson<T>(file: string, fallback?: T): T;
+export declare function writeJson(file: string, value: unknown): void;
+export declare function safeSlug(value: string | undefined): string;
+export declare function timestampSlug(name: string): string;
+export declare function splitCsv(value: string | undefined): string[];
+export declare function trimTrailingSlash(url: string): string;
+export declare function oneLine(value: string): string;
+export declare function fileSize(file: string): number;
+export declare function fileMtime(file: string): string | null;
+export declare function tailFile(file: string, lines: number): string;
+export declare function readMaybeFile(file: string | undefined): string;
+export declare function listRunIds(runsDir: string): string[];
+export declare function sleepMs(ms: number): void;
+export declare function isPidAlive(pid: number | undefined): boolean;
+export declare function killWorkerProcess(pid: number, signal: NodeJS.Signals): void;
+export declare function latestIso(values: Array<string | null | undefined>): string | null;
+export declare function secsAgo(ms: number): number;

package/dist/validate.d.ts

@@ -0,0 +1,5 @@
+export declare function validateRunId(runId: string): string;
+export declare function validateWorkerName(name: string): string;
+export declare function validateRepo(repo: string): string;
+export declare function validateOwnedPaths(repoRoot: string, ownedPaths: string[]): string[];
+export declare function validateTailLines(lines: number): number;

package/dist/vercel/index.d.ts

@@ -0,0 +1,3 @@
+export { classifyVercelUrl, isDashboardVercelUrl, type ClassifiedVercelUrl, type VercelUrlKind, } from "./vercel-url.js";
+export { isVercelStatusContext, normalizeGitHubStatusState, pickVercelStatusContext, type GitHubCommitStatusRow, type GitHubStatusState, type GitHubVercelStatusContext, } from "./vercel-github-status.js";
+export { collectVercelEvidence, evidenceFromGitHubVercelStatus, resolveVercelInspectTarget, type CollectVercelEvidenceInput, type RunVercelInspect, type VercelEvidenceResult, type VercelEvidenceStatus, type VercelInspectCommandResult, } from "./vercel-evidence.js";