@kynver-app/runtime 0.1.62 → 0.1.69

package/dist/landing-contract-gate.d.ts

@@ -9,8 +9,10 @@ export interface TargetPrReconciliation {
 export interface WorkerLandingContract {
     landingOnly: boolean;
     targetPrUrls: string[];
+    targetPrUrl?: string | null;
+    repairEnforceOriginalPr?: boolean;
 }
-export type WorkerLandingContractBlockReason = "unrelated_implementation_pr" | "missing_target_pr_reconciliation" | "incomplete_target_pr_landing";
+export type WorkerLandingContractBlockReason = "unrelated_implementation_pr" | "missing_target_pr_reconciliation" | "incomplete_target_pr_landing" | "duplicate_repair_pr" | "missing_repair_target_reconciliation";
 export interface WorkerLandingContractVerdict {
     blocked: boolean;
     reason?: WorkerLandingContractBlockReason;

package/dist/model-routing.d.ts

@@ -23,6 +23,8 @@ export declare function inferModelRoutingFromTask(task: Record<string, unknown>)
 export declare function resolveWorkerLaunch(input: {
     explicitModel?: string;
     explicitProvider?: string;
+    /** When true, `--provider claude` is honored without a task-level override. */
+    explicitProviderIsOperatorOverride?: boolean;
     task?: Record<string, unknown>;
 }): ModelRoutingDecision;
 /** Fallback chain tail after provider start — never hard-code Opus here. */

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

@@ -29,6 +29,8 @@ export declare function assessPrHandoffRequirement(input: {
     parentTaskId?: string | null;
     /** Target PR on the board task row (review workers inherit parent prUrl). */
     taskPrUrl?: string | null;
+    /** Repair worker canonical target — never auto-open a new PR. */
+    repairTargetPrUrl?: string | null;
 }): PrHandoffRequirement;
 export declare function buildPrHandoffSnapshotFromStatus(status: {
     changedFiles: string[];

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

@@ -11,7 +11,7 @@ export interface PrHandoffSnapshot {
     gitAncestry: GitAncestry;
     finalResult: unknown;
 }
-export type PrHandoffSkipReason = "not_dispatched" | "review_lane" | "expert_review_task" | "review_artifact" | "no_remote_branch_delta" | "already_has_pr" | "no_work_product" | "patch_or_bundle";
+export type PrHandoffSkipReason = "not_dispatched" | "review_lane" | "expert_review_task" | "review_artifact" | "no_remote_branch_delta" | "already_has_pr" | "no_work_product" | "patch_or_bundle" | "repair_target_pr";
 export interface PrHandoffNotRequired {
     required: false;
     reason: PrHandoffSkipReason;

package/dist/prompt.d.ts

@@ -11,4 +11,6 @@ export declare function buildPrompt(input: {
     personaMarkdown?: string | null;
     /** When set, Haiku/compact models get a shorter harness instruction block. */
     model?: string;
+    repairTargetPrUrl?: string;
+    repairTargetBranch?: string;
 }): string;

package/dist/repair-target-worktree.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Add a worktree checked out at an existing remote branch (repair-target checkout).
+ */
+export declare function addWorktreeForRepairBranch(repo: string, worktreePath: string, branch: string): void;

package/dist/resource-gate.d.ts

@@ -1,4 +1,5 @@
 import { type KynverUserConfig } from "./config.js";
+import type { DispatchNextDiskGateShape } from "./callbacks.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. */
@@ -20,6 +21,8 @@ export interface RunnerResourceGateShape {
     activeWorkers: number;
     slotsAvailable: number;
     reason: string | null;
+    /** Present unless `KYNVER_RESOURCE_GATE_SKIP_DISK=1`. */
+    diskGate?: DispatchNextDiskGateShape;
 }
 export interface ObserveResourceGateInput {
     runId: string;
@@ -30,6 +33,8 @@ export interface ObserveResourceGateInput {
     activeWorkers?: number;
     totalMemBytes?: number;
     freeMemBytes?: number;
+    diskPath?: string;
+    skipDiskGate?: boolean;
 }
 /** How many workers this host could run from RAM alone (before a user cap). */
 export declare function computeAutoMaxWorkers(totalMemBytes: number, opts?: {

package/dist/run-list.d.ts

@@ -0,0 +1,38 @@
+export interface RunListWorkerEvidence {
+    worker: string;
+    workerStatus: string;
+    attention: string;
+    attentionReason?: string;
+    missingHeartbeat: boolean;
+    missingFinalResult: boolean;
+    landingBlocked: boolean;
+    completionBlocked: boolean;
+}
+export type RunListFinalizeBlockedReason = "landing_blocked" | "completion_blocked" | "active_workers" | null;
+export interface RunListRow {
+    id: string;
+    name: string;
+    /** Persisted `run.json` status (updated by `finalizeStaleRuns` after reconcile). */
+    status: string;
+    /** Derived from worker attention/status — aligns with operator board semantics. */
+    effectiveStatus: string;
+    repo: string;
+    createdAt: string;
+    /** Workers still alive without a terminal result. */
+    openWorkerCount: number;
+    /** Highest-severity attention across workers (matches board rollup semantics). */
+    attention: "ok" | "done" | "stale" | "needs_attention" | "blocked";
+    attentionReason?: string;
+    /** Why `finalizeStaleRuns` may keep `status` active while workers are dead. */
+    finalizeBlockedReason: RunListFinalizeBlockedReason;
+    evidence: {
+        missingHeartbeatWorkers: string[];
+        missingFinalResultWorkers: string[];
+        landingBlockedWorkers: string[];
+        completionBlockedWorkers: string[];
+        workers: RunListWorkerEvidence[];
+    };
+}
+export declare function buildRunListRows(): RunListRow[];
+/** `kynver run list` — reconciles stale workers first, then prints run rows (JSON array). */
+export declare function listRunsCli(): void;

package/dist/run-store.d.ts

@@ -24,7 +24,9 @@ export declare function loadRun(id: string): HarnessRunRecord;
  * iterates the whole set). Unreadable/partial run dirs are skipped.
  */
 export declare function listRunRecords(): HarnessRunRecord[];
+export declare function listRunRecordsForHarnessRoot(harnessRoot: string): 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;
+export declare function runDirectoryAt(harnessRoot: string, id: string): string;

package/dist/runner-identity.d.ts

@@ -0,0 +1,12 @@
+export interface RunnerPresencePayload {
+    runnerId: string;
+    hostname: string | null;
+    profile: string | null;
+    harnessRepo: string | null;
+    runId?: string | null;
+}
+/** Stable runner identity for multi-box AgentOS coordination. */
+export declare function resolveRunnerPresencePayload(input?: {
+    runId?: string | null;
+    env?: NodeJS.ProcessEnv;
+}): RunnerPresencePayload;

package/dist/scheduler-cutover-cli.d.ts

@@ -0,0 +1,2 @@
+export declare function runSchedulerCutoverCheckCli(json?: boolean): void;
+export declare function runSchedulerAttestCutoverCli(json?: boolean): void;

package/dist/scheduler-cutover.d.ts

@@ -0,0 +1,22 @@
+import type { KynverUserConfig } from "./config.js";
+export type DeploymentSchedulerProvider = "qstash" | "kynver-cron" | "openclaw-cron";
+export declare const SCHEDULER_CUTOVER_RUNNER_ENV_KEYS: readonly ["KYNVER_SCHEDULER_PROVIDER", "OPENCLAW_CRON_STORE_PATH", "OPENCLAW_CRON_SECRET", "OPENCLAW_CRON_FIRE_BASE_URL"];
+export interface SchedulerCutoverEnvSnapshot {
+    kynverSchedulerProvider: string | null;
+    openclawCronStorePath: string | null;
+    openclawCronSecret: boolean;
+    openclawCronFireBaseUrl: string | null;
+}
+export interface SchedulerCutoverReport {
+    ok: boolean;
+    blockers: string[];
+    runnerEnv: SchedulerCutoverEnvSnapshot;
+    deploymentSchedulerProvider: DeploymentSchedulerProvider | null;
+    deploymentSteps: string[];
+    runnerSteps: string[];
+}
+export declare const DEPLOYMENT_SCHEDULER_CUTOVER_STEPS: readonly ["Vercel/hosted: set KYNVER_SCHEDULER_PROVIDER=qstash", "Vercel/hosted: ensure QSTASH_TOKEN (and QStash signing keys) are configured", "Vercel/hosted: unset OPENCLAW_CRON_STORE_PATH if present"];
+export declare const RUNNER_SCHEDULER_CUTOVER_STEPS: readonly ["User runner: unset KYNVER_SCHEDULER_PROVIDER (scheduling is deployment-owned)", "User runner: unset OPENCLAW_CRON_STORE_PATH, OPENCLAW_CRON_SECRET, OPENCLAW_CRON_FIRE_BASE_URL", "User runner: after deployment cutover, run `kynver scheduler attest-cutover` (or set deploymentSchedulerProvider to \"qstash\" in ~/.kynver/config.json)", "Verify: kynver doctor runtime-takeover — hotspot_openclaw_scheduler should pass"];
+export declare function readSchedulerCutoverEnv(env?: NodeJS.ProcessEnv): SchedulerCutoverEnvSnapshot;
+export declare function assessSchedulerCutover(config: Pick<KynverUserConfig, "deploymentSchedulerProvider">, env?: SchedulerCutoverEnvSnapshot): SchedulerCutoverReport;
+export declare function applySchedulerCutoverAttestation(config: KynverUserConfig): KynverUserConfig;

package/dist/status.d.ts

@@ -69,6 +69,9 @@ export interface HarnessWorkerRecord {
     parentTaskId?: string;
     taskTitle?: string;
     taskPrUrl?: string;
+    /** Canonical target PR for repair workers (must not spawn duplicate PRs). */
+    repairTargetPrUrl?: string;
+    repairTargetBranch?: string;
     /** Set when stale-reconcile patches a dead/stale worker record. */
     reconciledAt?: string;
     reconcileReason?: string;

package/dist/supervisor.d.ts

@@ -25,6 +25,8 @@ export interface SpawnWorkerOptions {
     parentTaskId?: string;
     taskTitle?: string;
     taskPrUrl?: string;
+    repairTargetPrUrl?: string;
+    repairTargetBranch?: string;
 }
 export declare function spawnWorkerProcess(run: HarnessRunRecord, opts: SpawnWorkerOptions): HarnessWorkerRecord;
 export declare function startWorker(args: Record<string, string | boolean>): Promise<void>;

package/dist/vercel/index.d.ts

@@ -1,3 +1,3 @@
-export { classifyVercelUrl, isDashboardVercelUrl, type ClassifiedVercelUrl, type VercelUrlKind, } from "./vercel-url.js";
+export { classifyVercelUrl, isDashboardVercelUrl, isInspectableVercelTarget, 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";

package/dist/vercel/vercel-url.d.ts

@@ -8,6 +8,8 @@ export interface ClassifiedVercelUrl {
     /** Deployment id extracted from dashboard paths when present. */
     deploymentId: string | null;
 }
+/** True when the string is safe to pass to `vercel inspect` (never a dashboard page URL). */
+export declare function isInspectableVercelTarget(target: string): boolean;
 /**
  * Classify a Vercel-related URL from GitHub commit status target_url.
  * `vercel inspect` accepts deployment ids and `*.vercel.app` hosts — not vercel.com dashboard links.

package/dist/worker-provider-policy.d.ts

@@ -0,0 +1,26 @@
+import type { ModelRoutingDecision } from "./model-routing.js";
+/** Default harness worker CLI provider unless an operator override allows Claude. */
+export declare const DEFAULT_WORKER_PROVIDER = "cursor";
+export declare function isClaudeFamilyProvider(provider: string | null | undefined): boolean;
+/**
+ * True when the board row explicitly opts into a Claude/Opus worker
+ * (operator override on the task).
+ */
+export declare function taskAllowsClaudeWorker(task: Record<string, unknown> | null | undefined): boolean;
+export interface EnforceCursorWorkerProviderInput {
+    routing: ModelRoutingDecision;
+    task?: Record<string, unknown> | null;
+    /** Per-invocation `--provider` from the harness CLI. */
+    explicitProvider?: string | null;
+    /** When true, `--provider claude` is treated as an operator run override. */
+    explicitProviderIsOperatorOverride?: boolean;
+}
+/**
+ * Rewrites Claude/Opus routing to Cursor unless the task or an explicit operator
+ * run override allows Claude workers.
+ */
+export declare function enforceCursorWorkerProvider(input: EnforceCursorWorkerProviderInput): ModelRoutingDecision;
+/** Normalize config/registry defaults — legacy `claude` configs map to Cursor unless overridden. */
+export declare function resolveConfiguredWorkerProvider(configured: string | null | undefined, fallback?: string): string;
+/** Plan / Command Center executor lists — Cursor wins when both families appear. */
+export declare function preferCursorExecutor(executors: string[]): string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kynver-app/runtime",
-  "version": "0.1.62",
+  "version": "0.1.69",
   "description": "Kynver AgentOS local execution runtime and CLI",
   "type": "module",
   "main": "./dist/index.js",