@kynver-app/runtime 0.1.73 → 0.1.76

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

@@ -11,6 +11,7 @@ export interface WorkerLandingContract {
     targetPrUrls: string[];
     targetPrUrl?: string | null;
     repairEnforceOriginalPr?: boolean;
+    requiresTargetPrReconciliation?: boolean;
 }
 export type WorkerLandingContractBlockReason = "unrelated_implementation_pr" | "missing_target_pr_reconciliation" | "incomplete_target_pr_landing" | "duplicate_repair_pr" | "missing_repair_target_reconciliation";
 export interface WorkerLandingContractVerdict {

package/dist/model-routing.d.ts

@@ -1,16 +1,19 @@
 import { type KynverUserConfig } from "./config.js";
+import type { OrchestrationRoutingAudit } from "./orchestration-providers/types.js";
 /** Conservative default — Sonnet for ordinary harness work (not Opus). */
 export declare const GLOBAL_DEFAULT_MODEL = "claude-sonnet-4-6";
 export declare const CURSOR_DEFAULT_MODEL = "composer-2.5";
 export interface ModelRoutingDecision {
     /** Model id passed to the provider CLI (undefined → provider default). */
     model?: string;
-    /** Worker provider key (`claude` | `cursor`). */
+    /** Worker provider key (`claude` | `cursor` | `codex`). */
     provider: string;
     /** Audit trail for Command Center / worker.json. */
     rule: string;
     /** Original task/board model request when inferred from metadata. */
     requestedModel?: string;
+    /** Provider/auth/cost audit for orchestration routing (no secrets). */
+    orchestrationAudit?: OrchestrationRoutingAudit;
 }
 /** Resolve global default: config → env → Sonnet. */
 export declare function resolveGlobalDefaultModel(config?: KynverUserConfig): string;

package/dist/orchestration-providers/audit.d.ts

@@ -0,0 +1,3 @@
+import type { OrchestrationRoutingAudit } from "./types.js";
+export declare function sanitizeOrchestrationAudit(audit: OrchestrationRoutingAudit): OrchestrationRoutingAudit;
+export declare function orchestrationAuditForWorkerJson(audit: OrchestrationRoutingAudit): OrchestrationRoutingAudit;

package/dist/orchestration-providers/capabilities.d.ts

@@ -0,0 +1,3 @@
+import type { OrchestrationProviderCapability, OrchestrationProviderId } from "./types.js";
+export declare function getOrchestrationProviderCapability(id: OrchestrationProviderId): OrchestrationProviderCapability;
+export declare function listOrchestrationProviderCapabilities(): OrchestrationProviderCapability[];

package/dist/orchestration-providers/claude-oauth-binding.d.ts

@@ -0,0 +1,6 @@
+import type { OrchestrationProviderBindingStatus } from "./types.js";
+/**
+ * Probe Claude Code OAuth on the local runner. Never reads or returns raw OAuth tokens.
+ * ANTHROPIC_API_KEY is reported separately as api_key_env (cloud credits path).
+ */
+export declare function probeClaudeOAuthBinding(nowIso?: string): OrchestrationProviderBindingStatus;

package/dist/orchestration-providers/codex-oauth-binding.d.ts

@@ -0,0 +1,5 @@
+import type { OrchestrationProviderBindingStatus } from "./types.js";
+/**
+ * Probe BYO Codex OAuth on the local runner. Never reads or returns raw OAuth tokens.
+ */
+export declare function probeCodexOAuthBinding(nowIso?: string): OrchestrationProviderBindingStatus;

package/dist/orchestration-providers/codex-orchestration-adapter.d.ts

@@ -0,0 +1,13 @@
+import { type HermesOpenAiCodexBindingStatus } from "./hermes-openai-codex-binding.js";
+import type { OrchestrationProviderBindingStatus } from "./types.js";
+/** How low-cost Codex orchestration authenticates on this host. */
+export type CodexOrchestrationPath = "codex_cli" | "hermes_openai_codex" | "none";
+export interface CodexOrchestrationAdapterStatus extends OrchestrationProviderBindingStatus {
+    path: CodexOrchestrationPath;
+    hermesOpenAiCodex?: HermesOpenAiCodexBindingStatus;
+}
+/**
+ * Resolve the best local Codex/OpenAI orchestration path: standalone `codex` CLI first,
+ * then Hermes-managed `openai-codex` subscription when the CLI is absent or unbound.
+ */
+export declare function resolveCodexOrchestrationAdapter(nowIso?: string): CodexOrchestrationAdapterStatus;

package/dist/orchestration-providers/cost-router.d.ts

@@ -0,0 +1,24 @@
+import type { OrchestrationProviderInventory } from "./inventory.js";
+import type { OrchestrationProviderBindingStatus, OrchestrationProviderId, OrchestrationRiskClass } from "./types.js";
+export declare function providerCapableForRisk(providerId: OrchestrationProviderId, riskClass: OrchestrationRiskClass): boolean;
+export declare function compareProviderCandidates(a: {
+    providerId: OrchestrationProviderId;
+    binding: OrchestrationProviderBindingStatus;
+}, b: {
+    providerId: OrchestrationProviderId;
+    binding: OrchestrationProviderBindingStatus;
+}): number;
+export interface CheapestCapableSelection {
+    providerId: OrchestrationProviderId;
+    binding: OrchestrationProviderBindingStatus;
+    escalatedFrom?: OrchestrationProviderId;
+    escalatedReason?: string;
+}
+/**
+ * Pick the lowest-cost ready provider that can run the given risk class.
+ * Sorts by cost tier, then prefers local OAuth CLI over metered API-key paths.
+ */
+export declare function selectCheapestCapableProvider(input: {
+    inventory: OrchestrationProviderInventory;
+    riskClass: OrchestrationRiskClass;
+}): CheapestCapableSelection | null;

package/dist/orchestration-providers/cursor-oauth-binding.d.ts

@@ -0,0 +1,5 @@
+import type { OrchestrationProviderBindingStatus } from "./types.js";
+/**
+ * Probe Cursor/Composer OAuth on the local runner. Never reads or returns raw OAuth tokens.
+ */
+export declare function probeCursorOAuthBinding(nowIso?: string): OrchestrationProviderBindingStatus;

package/dist/orchestration-providers/hermes-cli-adapter.d.ts

@@ -0,0 +1,15 @@
+import type { OrchestrationAuthSource } from "./types.js";
+export interface HermesCliAdapterStatus {
+    adapterId: "hermes";
+    cliAvailable: boolean;
+    profileBound: boolean;
+    authSource: OrchestrationAuthSource;
+    sessionFingerprint?: string;
+    checkedAt: string;
+    note?: string;
+}
+/**
+ * Best-effort Hermes Forge CLI adapter probe. Cloud/API keys in ~/.hermes/.env are
+ * reported as api_key_env — distinct from harness worker BYO OAuth inventory.
+ */
+export declare function probeHermesCliAdapter(nowIso?: string): HermesCliAdapterStatus;

package/dist/orchestration-providers/hermes-openai-codex-binding.d.ts

@@ -0,0 +1,15 @@
+import type { OrchestrationAuthSource } from "./types.js";
+export type HermesOpenAiCodexPath = "hermes_openai_codex";
+export interface HermesOpenAiCodexBindingStatus {
+    path: HermesOpenAiCodexPath;
+    ready: boolean;
+    authSource: OrchestrationAuthSource;
+    sessionFingerprint?: string;
+    checkedAt: string;
+    note?: string;
+}
+/**
+ * Probe Hermes-managed OpenAI Codex subscription (ChatGPT backend-api/codex).
+ * Uses exit-code-only `hermes auth status` — never reads auth.json token payloads.
+ */
+export declare function probeHermesOpenAiCodexBinding(nowIso?: string): HermesOpenAiCodexBindingStatus;

package/dist/orchestration-providers/index.d.ts

@@ -0,0 +1,13 @@
+export * from "./types.js";
+export * from "./capabilities.js";
+export * from "./oauth-binding-utils.js";
+export * from "./codex-oauth-binding.js";
+export * from "./cursor-oauth-binding.js";
+export * from "./claude-oauth-binding.js";
+export * from "./hermes-cli-adapter.js";
+export * from "./hermes-openai-codex-binding.js";
+export * from "./codex-orchestration-adapter.js";
+export * from "./inventory.js";
+export * from "./cost-router.js";
+export * from "./routing.js";
+export * from "./audit.js";

package/dist/orchestration-providers/inventory.d.ts

@@ -0,0 +1,31 @@
+import { type CodexOrchestrationPath } from "./codex-orchestration-adapter.js";
+import { type HermesCliAdapterStatus } from "./hermes-cli-adapter.js";
+import { type HermesOpenAiCodexBindingStatus } from "./hermes-openai-codex-binding.js";
+import type { OrchestrationProviderBindingStatus, OrchestrationProviderId } from "./types.js";
+export interface OrchestrationCloudApiCredits {
+    /** ANTHROPIC_API_KEY configured on host (cloud billing — not BYO OAuth). */
+    anthropicApiKey: boolean;
+    /** OPENAI_API_KEY configured on host (cloud billing — distinct from Codex OAuth). */
+    openaiApiKey: boolean;
+    /** CODEX_API_KEY configured on host (OpenAI Codex cloud path). */
+    codexApiKey: boolean;
+}
+export interface OrchestrationProviderInventory {
+    generatedAt: string;
+    bindings: Record<OrchestrationProviderId, OrchestrationProviderBindingStatus>;
+    /** API-key cloud paths — separate from local OAuth CLI sessions. */
+    cloudApiCredits: OrchestrationCloudApiCredits;
+    hermes: HermesCliAdapterStatus;
+    hermesOpenAiCodex: HermesOpenAiCodexBindingStatus;
+    codexAdapterPath: CodexOrchestrationPath;
+    readyCount: number;
+}
+export interface BuildOrchestrationProviderInventoryOptions {
+    nowIso?: () => string;
+}
+/**
+ * Probe all harness orchestration CLI providers on this host.
+ * Never reads or returns raw OAuth tokens or API key values.
+ */
+export declare function buildOrchestrationProviderInventory(options?: BuildOrchestrationProviderInventoryOptions): OrchestrationProviderInventory;
+export declare function probeOrchestrationProviderBinding(providerId: OrchestrationProviderId, nowIso?: string): OrchestrationProviderBindingStatus;

package/dist/orchestration-providers/oauth-binding-utils.d.ts

@@ -0,0 +1,21 @@
+/** Fingerprint from file metadata only — never reads token payload. */
+export declare function fingerprintAuthStore(filePath: string): string | undefined;
+export declare function envKeyFingerprint(envKey: string): string;
+export declare function resolveCliBin(defaultBin: string, envKeys: string[]): string;
+export declare function probeCliCommand(bin: string, args: string[], options?: {
+    timeoutMs?: number;
+    okNote?: string;
+    failPrefix?: string;
+}): {
+    ok: boolean;
+    note?: string;
+};
+/** Exit-code-only probe — stdout/stderr are discarded to avoid leaking auth payloads. */
+export declare function probeCliExitCodeOnly(bin: string, args: string[], options?: {
+    timeoutMs?: number;
+    okNote?: string;
+    failNote?: string;
+}): {
+    ok: boolean;
+    note?: string;
+};

package/dist/orchestration-providers/routing.d.ts

@@ -0,0 +1,16 @@
+import type { OrchestrationProviderInventory } from "./inventory.js";
+import type { OrchestrationProviderBindingStatus, OrchestrationRiskClass, OrchestrationRoutingDecision } from "./types.js";
+export declare function classifyOrchestrationRisk(task: Record<string, unknown>): OrchestrationRiskClass;
+export interface ResolveOrchestrationRoutingInput {
+    task?: Record<string, unknown> | null;
+    explicitProvider?: string | null;
+    explicitModel?: string | null;
+    codexBinding?: OrchestrationProviderBindingStatus | null;
+    inventory?: OrchestrationProviderInventory | null;
+    preferLowCost?: boolean;
+}
+/**
+ * Cost-aware harness orchestration routing: cheapest capable provider first,
+ * preferring local OAuth CLI sessions over metered API-key paths; escalate when needed.
+ */
+export declare function resolveOrchestrationRouting(input: ResolveOrchestrationRoutingInput): OrchestrationRoutingDecision;

package/dist/orchestration-providers/types.d.ts

@@ -0,0 +1,45 @@
+/** Harness / orchestration executor identity (distinct from LLM vendor strings). */
+export type OrchestrationProviderId = "cursor" | "codex" | "claude";
+/** How the worker authenticates — never includes secret material. */
+export type OrchestrationAuthSource = "oauth_local" | "api_key_env" | "subscription_hermes" | "runner_token" | "none";
+export type OrchestrationCostTier = "low" | "medium" | "high";
+export type OrchestrationRiskClass = "low" | "elevated" | "privileged";
+export interface OrchestrationProviderCapability {
+    id: OrchestrationProviderId;
+    displayName: string;
+    costTier: OrchestrationCostTier;
+    /** Supported auth modes for this provider on a user runner. */
+    authSources: OrchestrationAuthSource[];
+    /** May run routine orchestration (progress sync, status, low-risk board ops). */
+    supportsLowRiskOrchestration: boolean;
+    /** May run privileged platform actions (DB, deploy, secrets) — always false for BYO Codex. */
+    supportsPrivilegedPlatformActions: boolean;
+}
+/** Non-secret local session marker for audit (fingerprint only). */
+export interface OrchestrationProviderBindingStatus {
+    providerId: OrchestrationProviderId;
+    ready: boolean;
+    authSource: OrchestrationAuthSource;
+    /** sha256 prefix of non-secret binding metadata — never a raw OAuth token. */
+    sessionFingerprint?: string;
+    checkedAt: string;
+    note?: string;
+}
+export interface OrchestrationRoutingAudit {
+    provider: OrchestrationProviderId;
+    model?: string;
+    authSource: OrchestrationAuthSource;
+    costTier: OrchestrationCostTier;
+    riskClass: OrchestrationRiskClass;
+    costRationale: string;
+    routingRule: string;
+    /** When routing escalated away from the preferred low-cost provider. */
+    escalatedFrom?: OrchestrationProviderId;
+    escalatedReason?: string;
+}
+export interface OrchestrationRoutingDecision {
+    provider: OrchestrationProviderId;
+    model?: string;
+    rule: string;
+    audit: OrchestrationRoutingAudit;
+}

package/dist/paths.d.ts

@@ -1,5 +1,13 @@
-/** Canonical harness root for CLI/workers. Server mirror: agent-os.harness-root.ts */
+/**
+ * Canonical harness root: the directory that contains `runs/` and `worktrees/`.
+ * Strips mistaken trailing layout segments (e.g. env set to `.../harness/runs`).
+ * Server mirror: agent-os.harness-root.ts
+ */
+export declare function normalizeHarnessRoot(root: string): string;
+/** Canonical harness root for CLI/workers. */
 export declare function resolveHarnessRoot(): string;
+export declare function harnessRunsDir(harnessRoot: string): string;
+export declare function harnessWorktreesDir(harnessRoot: string): string;
 export declare function getHarnessPaths(): {
     harnessRoot: string;
     runsDir: string;

package/dist/pipeline-tick.d.ts

@@ -6,7 +6,10 @@ export interface PipelineTickResult {
     runId: string;
     agentOsId: string;
     execute: boolean;
+    /** Gate sampled before operator tick (Command Center heartbeat). */
     resourceGate: RunnerResourceGateShape;
+    /** Gate re-sampled after completion replay + board lifecycle sync — used for dispatch. */
+    dispatchResourceGate: RunnerResourceGateShape;
     leaseRenewal?: Awaited<ReturnType<typeof renewActiveTaskLeases>>;
     completedWorkers: Array<{
         worker: string;

package/dist/post-restart-unblock.d.ts

@@ -0,0 +1,24 @@
+export interface UnblockWorkerOutcome {
+    runId: string;
+    worker: string;
+    taskId: string;
+    agentOsId: string;
+    leaseOwner: string;
+    action: "released" | "skipped" | "error";
+    reason: string;
+}
+export interface PostRestartUnblockResult {
+    dryRun: boolean;
+    released: UnblockWorkerOutcome[];
+    skipped: UnblockWorkerOutcome[];
+    errors: UnblockWorkerOutcome[];
+}
+/**
+ * Scan all local run records for dead dispatched workers and release their
+ * server-side leases so the linked AgentTasks are requeued. Safe to run
+ * multiple times — the server `releaseLease` is owner-guarded and idempotent
+ * (a mismatched or already-released owner returns 409 / ok:false, not an
+ * error that breaks the loop).
+ */
+export declare function postRestartUnblock(args: Record<string, string | boolean>): Promise<PostRestartUnblockResult>;
+export declare function postRestartUnblockCli(args: Record<string, string | boolean>): Promise<void>;

package/dist/providers/codex.d.ts

@@ -0,0 +1,9 @@
+import type { WorkerProvider } from "./types.js";
+/** Default Codex model for harness orchestration (override with --model). */
+export declare const CODEX_DEFAULT_MODEL = "gpt-5.4";
+/**
+ * Build argv for `codex exec` headless orchestration.
+ * Uses read-only sandbox + no approval prompts for low-risk harness slices.
+ */
+export declare function buildCodexExecArgv(model: string, prompt: string): string[];
+export declare const codexProvider: WorkerProvider;

package/dist/providers/hermes-codex.d.ts

@@ -0,0 +1,9 @@
+import type { WorkerProvider } from "./types.js";
+/** Default model when routing through Hermes openai-codex subscription. */
+export declare const HERMES_OPENAI_CODEX_DEFAULT_MODEL = "gpt-5.4";
+/**
+ * Non-interactive Hermes chat argv for openai-codex subscription orchestration.
+ * `-Q` suppresses banners; `--accept-hooks` avoids TTY approval prompts.
+ */
+export declare function buildHermesOpenAiCodexChatArgv(model: string, prompt: string): string[];
+export declare const hermesCodexProvider: WorkerProvider;

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

@@ -28,4 +28,6 @@ export declare function preflightClaudeModel(model: string | undefined, defaultM
  * reasoning levels, so suffixed ids pass through; we only flag a Claude-family
  * model that was clearly meant for the `claude` provider.
  */
+/** Preflight for `codex` provider — accepts OpenAI/Codex model ids; rejects Claude-family ids. */
+export declare function preflightCodexModel(model: string | undefined, defaultModel: string): ModelPreflightResult;
 export declare function preflightCursorModel(model: string | undefined, defaultModel: string): ModelPreflightResult;

package/dist/providers/openai-codex-resilience.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Classify transient OpenAI Codex / ChatGPT backend failures and build plain-English
+ * operator notices. Shared by harness orchestration and Hermes cron delivery UX.
+ */
+export declare const OPENAI_CODEX_PROVIDER = "openai-codex";
+export type OpenAiCodexErrorClass = "upstream_503" | "connection_refused" | "connection_reset" | "sse_no_event" | "sse_idle_timeout" | "rate_limit" | "billing" | "auth" | "unknown";
+export declare const TRANSIENT_OPENAI_CODEX_ERROR_CLASSES: ReadonlySet<OpenAiCodexErrorClass>;
+export type ClassifiedOpenAiCodexError = {
+    errorClass: OpenAiCodexErrorClass;
+    summary: string;
+    statusCode?: number;
+    transient: boolean;
+};
+export declare function redactProviderErrorText(text: string, maxLen?: number): string;
+export declare function classifyOpenAiCodexError(error: unknown, statusCode?: number): ClassifiedOpenAiCodexError;
+export declare function resolveOpenAiCodexRetryBudget(input: {
+    platform?: string | null;
+    provider?: string | null;
+    defaultRetries?: number;
+    env?: NodeJS.ProcessEnv;
+}): number;
+export type CodexFailureNoticeInput = {
+    jobName?: string;
+    provider?: string;
+    model?: string;
+    errorClass: OpenAiCodexErrorClass;
+    summary: string;
+    attempts: number;
+    platform?: string;
+    degraded?: boolean;
+};
+export declare function formatOpenAiCodexFailureNotice(input: CodexFailureNoticeInput): string;
+export declare function formatCronJobDeliveryFailure(jobName: string, notice: string): string;

package/dist/retry-limits.d.ts

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

package/dist/stale-reconcile.d.ts

@@ -1,4 +1,5 @@
 import { type RunFinalizeResult } from "./finalize.js";
+import { reconcileWorkerMetadata } from "./worker-metadata-reconcile.js";
 /** No heartbeat this long + dead PID → reconcile as exited. */
 export declare const STALE_RECONCILE_HEARTBEAT_MS: number;
 export interface StaleWorkerReconcileOutcome {
@@ -10,6 +11,7 @@ export interface StaleWorkerReconcileOutcome {
 export interface ReconcileStaleWorkersResult {
     workers: StaleWorkerReconcileOutcome[];
     finalizedRuns: RunFinalizeResult[];
+    metadataReconcile: ReturnType<typeof reconcileWorkerMetadata>;
 }
 /**
  * Reconcile workers that exited without updating worker.json, and optionally

package/dist/status.d.ts

@@ -59,11 +59,15 @@ export interface HarnessWorkerRecord {
     personaSlug?: string;
     personaEvidence?: PersonaContextEvidenceSnapshot;
     leaseOwner?: string;
+    /** Fencing token from claim — sent on renew/completion when set. */
+    leaseToken?: string;
     dispatched?: boolean;
     startedAt?: string;
     /** Routing audit — which rule selected model/provider (dispatch inference). */
     routingRule?: string;
     requestedModel?: string;
+    /** Orchestration provider/model/auth-source/cost audit (no OAuth secrets). */
+    orchestrationAudit?: import("./orchestration-providers/types.js").OrchestrationRoutingAudit;
     /** Board task metadata for landing/PR-handoff gates (set at dispatch). */
     executorRef?: string;
     parentTaskId?: string;
@@ -148,6 +152,8 @@ export interface RawHarnessWorkerStatus {
     headCommit?: string;
     /** Paths removed via `kynver worker discard-disposable` before completion POST. */
     disposableArtifactsRemoved?: string[];
+    /** Fencing token from claim — echoed on completion when set. */
+    leaseToken?: string;
 }
 export interface WorkerStatusOptions {
     /** Branch ref for ancestry when baseCommit is not set. */

package/dist/supervisor.d.ts

@@ -17,6 +17,7 @@ export interface SpawnWorkerOptions {
     personaSlug?: string | null;
     personaEvidence?: PersonaContextEvidenceSnapshot | null;
     leaseOwner?: string;
+    leaseToken?: string;
     dispatched?: boolean;
     provider?: string;
     routingRule?: string;

package/dist/worker-metadata-paths.d.ts

@@ -0,0 +1,26 @@
+/** True when a persisted harness path contains the historical `runs/runs` segment. */
+export declare function hasNestedRunsSegment(filePath: string): boolean;
+/**
+ * Rewrite a nested `.../runs/runs/<runId>/...` path to canonical `.../runs/<runId>/...`.
+ * Returns the input unchanged when no nested segment is present.
+ */
+export declare function repairNestedRunsPath(filePath: string, harnessRoot: string): string;
+export declare function canonicalRunDir(harnessRoot: string, runId: string): string;
+export declare function canonicalWorkerDir(harnessRoot: string, runId: string, workerName: string): string;
+/** Historical mistaken layout when harness root ended in `/runs`. */
+export declare function legacyNestedWorkerDir(harnessRoot: string, runId: string, workerName: string): string;
+export declare function workerArtifactFileNames(): readonly string[];
+export declare function workerArtifactPaths(workerDir: string): {
+    workerJsonPath: string;
+    stdoutPath: string;
+    stderrPath: string;
+    heartbeatPath: string;
+    lastStatusPath: string;
+};
+/** Resolve the best on-disk worker.json path for a run worker entry. */
+export declare function resolveWorkerJsonPath(input: {
+    harnessRoot: string;
+    runId: string;
+    workerName: string;
+    statusPath?: string;
+}): string;

package/dist/worker-metadata-reconcile.d.ts

@@ -0,0 +1,19 @@
+export interface WorkerMetadataReconcileOutcome {
+    runId: string;
+    worker: string;
+    action: "materialized_run_symlink" | "repaired_run_index" | "repaired_worker_paths" | "relocated_artifacts" | "synthesized_worker_json" | "marked_abandoned" | "skipped";
+    reason: string;
+}
+export interface WorkerMetadataReconcileResult {
+    workers: WorkerMetadataReconcileOutcome[];
+}
+/**
+ * Repair historical harness worker metadata:
+ * - fix run.json index paths that still reference nested `runs/runs`
+ * - relocate split artifacts into canonical worker dirs
+ * - synthesize missing worker.json from last-status/heartbeat/stdout when possible
+ * - mark empty abandoned worker dirs truthfully
+ */
+export declare function reconcileWorkerMetadata(): WorkerMetadataReconcileResult;
+/** JSON summary for CLI / verifier scripts. */
+export declare function reconcileWorkerMetadataCli(): void;

package/package.json

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