@kynver-app/runtime 0.2.19 → 0.2.24

package/dist/config.d.ts

@@ -9,7 +9,7 @@ export interface KynverUserConfig {
     harnessRoot?: string;
     /**
      * Operator attestation that the hosted Kynver deployment uses this scheduler provider
-     * (set on user runners after Vercel env cutover — scheduling is deployment-owned).
+     * (set on user runners after the hosted env cutover — scheduling is deployment-owned).
      */
     deploymentSchedulerProvider?: "qstash" | "kynver-cron" | "openclaw-cron";
     /** Default harness run for `kynver daemon` / systemd user unit (set by `kynver cron install`). */

package/dist/cron/cron-install-plan.d.ts

@@ -1,7 +1,9 @@
 import type { KynverUserConfig } from "../config.js";
 export declare const WATCHDOG_DEDUPE_KEY = "watchdog:board-sweep";
 export declare const DEFAULT_WATCHDOG_CRON = "*/5 * * * *";
-export declare const VERCEL_KYNVER_CRON_CUTOVER_STEPS: readonly ["Set KYNVER_SCHEDULER_PROVIDER=kynver-cron on the hosted Kynver deployment (Vercel).", "Set KYNVER_CRON_SECRET to the same value written to ~/.kynver/.env by this installer.", "Unset KYNVER_CRON_STORE_PATH on Vercel — the connected box owns the local store.", "Keep QSTASH_TOKEN only if other non-watchdog schedules still use QStash (analyst/market jobs)."];
+export declare const HOSTED_KYNVER_CRON_CUTOVER_STEPS: readonly ["Set KYNVER_SCHEDULER_PROVIDER=kynver-cron on the hosted Kynver deployment (the Railway production service).", "Set KYNVER_CRON_SECRET to the same value written to ~/.kynver/.env by this installer.", "Unset KYNVER_CRON_STORE_PATH on the Railway service — the connected box owns the local store.", "Keep QSTASH_TOKEN only if other non-watchdog schedules still use QStash (analyst/market jobs)."];
+/** @deprecated Renamed after the 2026-08 Railway cutover — use HOSTED_KYNVER_CRON_CUTOVER_STEPS. */
+export declare const VERCEL_KYNVER_CRON_CUTOVER_STEPS: readonly ["Set KYNVER_SCHEDULER_PROVIDER=kynver-cron on the hosted Kynver deployment (the Railway production service).", "Set KYNVER_CRON_SECRET to the same value written to ~/.kynver/.env by this installer.", "Unset KYNVER_CRON_STORE_PATH on the Railway service — the connected box owns the local store.", "Keep QSTASH_TOKEN only if other non-watchdog schedules still use QStash (analyst/market jobs)."];
 export interface CronInstallPlanInput {
     config: KynverUserConfig;
     apiBaseUrl: string;

package/dist/daemon-keeper.d.ts

@@ -1,3 +1,35 @@
+/**
+ * A child that dies nonzero this fast with a config-shaped error message will
+ * die identically on every respawn — a bad `~/.kynver/config.json` must not
+ * become an infinite keeper crash loop (respawn → same error → backoff → …).
+ */
+export declare const KEEPER_PERMANENT_FAILURE_WINDOW_MS = 10000;
+export interface KeeperChildFailureVerdict {
+    permanent: boolean;
+    /** First stderr line that matched a permanent pattern (for the operator). */
+    matchedLine?: string;
+}
+/**
+ * Decide whether a child exit is a permanent configuration failure (stop
+ * respawning) or transient (keep exponential backoff). Permanent requires ALL
+ * of: a nonzero exit code (signals are transient — OOM killer etc.), death
+ * inside the startup grace window, and stderr matching a known config-error
+ * class. Anything else keeps the resilient default: respawn with backoff.
+ */
+export declare function classifyKeeperChildFailure(input: {
+    exitCode: number | null;
+    exitSignal: NodeJS.Signals | null;
+    uptimeMs: number;
+    stderrTail: string;
+}): KeeperChildFailureVerdict;
+/**
+ * Remediation-formatted error for a missing daemon/keeper argument (modeled
+ * on `formatAgentOsIdValidationError`): what is missing, where it normally
+ * comes from (`~/.kynver/config.json`), and the command that sets it up. The
+ * leading `missing --…` token is load-bearing — the keeper's permanent
+ * config-error classifier and legacy log greps both key on it.
+ */
+export declare function formatMissingDaemonArgError(flag: "--run" | "--agent-os-id"): string;
 export declare function resolveKeeperStallMs(flag: string | boolean | undefined, env?: NodeJS.ProcessEnv): number;
 /**
  * Supervision is the DEFAULT for `kynver daemon`. Opt out only when an

package/dist/doctor/runner-install.d.ts

@@ -1,2 +1,86 @@
-import type { RunnerInstallDoctorReport } from "./doctor.types.js";
-export declare function assessRunnerInstallReadiness(): RunnerInstallDoctorReport;
+import { type KynverUserConfig } from "../config.js";
+import type { DoctorCheck, DoctorSection, RunnerInstallDoctorReport } from "./doctor.types.js";
+/** Repo base-ref probe result: can a new run be cut from this checkout? */
+export interface RepoBaseRefProbe {
+    originMainOk: boolean;
+    /** Remote default branch (e.g. `origin/master`) when origin/main is absent. */
+    remoteHead: string | null;
+    remoteHeadOk: boolean;
+}
+/** Probe `origin/main` (what runs are cut from) with the remote-HEAD fallback. */
+export declare function probeRepoBaseRef(repo: string): RepoBaseRefProbe;
+/** Pure builder so tests can pin all three verdicts without a git fixture. */
+export declare function buildRepoBaseRefCheck(repo: string, probe: RepoBaseRefProbe): DoctorCheck;
+/** What the configured worker provider needs on PATH, plus probe results. */
+export interface ProviderCliProbe {
+    provider: string;
+    /** Acceptable binaries (any one satisfies), in preference order. */
+    binaries: string[];
+    foundBinary: string | null;
+    /** Best-effort `<bin> --version` health probe (warn-only). */
+    versionProbe: {
+        ok: boolean;
+        detail: string;
+    } | null;
+    knownProvider: boolean;
+}
+/** Probe the configured worker provider's CLI on PATH (+ cheap health check). */
+export declare function probeProviderCli(config?: KynverUserConfig): ProviderCliProbe;
+/** Pure builder so tests can pin verdicts without spawning real provider CLIs. */
+export declare function buildProviderCliSection(probe: ProviderCliProbe): DoctorSection;
+export interface ApiLivenessProbe {
+    baseUrl: string | null;
+    version: {
+        kind: "ok";
+        status: number;
+    } | {
+        kind: "http_error";
+        status: number;
+    } | {
+        kind: "network";
+        detail: string;
+    } | {
+        kind: "skipped";
+        reason: string;
+    };
+    credential: {
+        kind: "ok";
+    } | {
+        kind: "unauthorized";
+    } | {
+        kind: "forbidden";
+    } | {
+        kind: "http_error";
+        status: number;
+    } | {
+        kind: "network";
+        detail: string;
+    } | {
+        kind: "skipped";
+        reason: string;
+    };
+}
+export declare const API_LIVENESS_TIMEOUT_MS = 5000;
+/**
+ * Live probes: `GET /api/version` (is the URL a reachable Kynver at all?) and
+ * a credentialed `GET …/runner-credentials` (does this account/key still have
+ * access?). 401 vs 403 get distinct verdicts — revoked key vs gated access.
+ */
+export declare function probeApiLiveness(opts: {
+    baseUrl?: string;
+    agentOsId?: string;
+    apiKey?: string;
+    fetchImpl?: typeof fetch;
+    timeoutMs?: number;
+}): Promise<ApiLivenessProbe>;
+/** Pure builder so tests can pin the 401/403/network verdicts without a server. */
+export declare function buildApiLivenessSection(probe: ApiLivenessProbe): DoctorSection;
+export declare function assessRunnerInstallReadiness(extraSections?: DoctorSection[]): RunnerInstallDoctorReport;
+/**
+ * Full readiness report including the live API probes (`/api/version` + the
+ * credentialed runner-credential route). This is what `kynver doctor
+ * runner-install` runs; the sync `assessRunnerInstallReadiness` remains for
+ * offline/embedded callers.
+ */
+export declare function assessRunnerInstallReadinessAsync(): Promise<RunnerInstallDoctorReport>;
+export declare function runRunnerInstallDoctorCliAsync(): Promise<void>;

package/dist/doctor/runtime-takeover-deploy-evidence.d.ts

@@ -2,8 +2,12 @@ import type { DoctorSection } from "./doctor.types.js";
 import { type GitHubReadinessProbe } from "./github-readiness.js";
 import type { RuntimeTakeoverProbes } from "./runtime-takeover.probes.js";
 /**
- * Optional deploy-evidence checks for merge-gate / PR handoff workflows.
- * Core runtime takeover does not require Vercel CLI or VERCEL_TOKEN when GitHub
- * commit-status evidence is viable.
+ * Optional deploy-evidence checks for merge-gate / PR handoff workflows
+ * (Railway era). Post-cutover (2026-08) production deploy evidence is the
+ * production /api/version probe plus GitHub ancestry/commit-status lookups —
+ * Vercel is decommissioned, so the old Vercel StatusContext and VERCEL_TOKEN
+ * REST fallback no longer exist. This section verifies GitHub auth for those
+ * lookups and flags Vercel leftovers (global CLI, stale VERCEL_TOKEN) as
+ * hygiene warnings.
  */
 export declare function assessDeployEvidence(probes: RuntimeTakeoverProbes, githubProbe: GitHubReadinessProbe): DoctorSection;

package/dist/doctor/runtime-takeover.probes.d.ts

@@ -37,7 +37,7 @@ export interface RuntimeTakeoverProbes {
     pathExists(target: string): boolean;
     pathWritable(target: string): boolean;
     ghAuthToken(): CommandProbeResult;
-    /** When false, GitHub/Vercel deploy-evidence checks are advisory-only skips. */
+    /** When false, GitHub deploy-evidence checks are advisory-only skips. */
     deployEvidenceNeedsGithub?(): boolean;
     /** Injectable systemd active probe for supervision checks. */
     systemdDaemonActive?(): boolean;

package/dist/index.d.ts

@@ -25,14 +25,17 @@ export { MEMORY_LANE_PREVIEW_CHARS, buildChatMemoryShadowPreview, buildLegacyCha
 export { canonicalJsonStringify, computeInstructionBundleVersion, deriveInstructionBundleKeyId, parseRawEd25519Key, isSignedInstructionBundleShape, PINNED_INSTRUCTION_BUNDLE_PUBLIC_KEYS, resolveInstructionBundlePublicKey, verifyInstructionBundleSignatureWithKey, verifySignedInstructionBundle, EMBEDDED_INSTRUCTION_BUNDLE, EMBEDDED_INSTRUCTION_BUNDLE_VERSION, getActiveInstructionBundle, getActiveInstructionBundleSource, getActiveInstructionBundleVersion, setActiveInstructionBundle, resolveInstructionText, resolvePolicyThreshold, resolveBundlePersona, ensureInstructionBundle, instructionBundleCachePath, loadInstructionBundleCache, saveInstructionBundleCache, INSTRUCTION_BUNDLE_REFRESH_TTL_MS, type InstructionBundle, type InstructionBundleContent, type InstructionBundlePersona, type SignedInstructionBundle, type InstructionBundleSource, type InstructionBundleVerifyResult, type EnsureInstructionBundleOptions, type EnsureInstructionBundleResult, } from "./instruction-bundle/index.js";
 export { WORKER_PERSONA_CATALOG, getWorkerPersonaCatalogEntry, getPersonaDispatchLane, getPersonaDefaultRoleLane, isKnownWorkerPersonaSlug, workerPersonaReviewSlugs, workerPersonaLandingSlugs, type WorkerPersonaCatalogEntry, type WorkerPersonaCatalogSlug, type WorkerPersonaDispatchLane, type WorkerPersonaDefaultRoleLane, } from "./worker-persona-catalog.js";
 export { assessPrHandoffRequirement, ensurePrReadyHandoff, extractPrUrlFromText, } from "./pr-handoff/index.js";
-export { normalizeCursorModelAlias, preflightClaudeModel, preflightCodexModel, preflightCursorModel, } from "./providers/model-preflight.js";
+export { normalizeCursorModelAlias, preflightClaudeModel, preflightCodexModel, preflightCursorModel, preflightOpenAiCompatibleModel, } from "./providers/model-preflight.js";
 export { CODEX_DEFAULT_MODEL, codexProvider, buildCodexExecArgv } from "./providers/codex.js";
+export { OPENAI_COMPATIBLE_PROVIDER, OPENAI_COMPATIBLE_SYSTEM_PROMPT, OpenAiCompatibleConfigError, buildOpenAiCompatibleChatRequest, buildOpenAiCompatibleRunnerConfig, openAiCompatibleProvider, resolveOpenAiCompatibleDefaultModel, resolveOpenAiCompatibleEndpoint, type OpenAiCompatibleChatRequest, type OpenAiCompatibleEndpoint, type OpenAiCompatibleRunnerConfig, } from "./providers/openai-compatible.js";
+export { extractOpenAiCompatibleCompletion, type OpenAiCompatibleCompletion, type OpenAiCompatibleUsage, } from "./providers/openai-compatible-response.js";
+export { resolveWorkerUsagePayload, type ResolveWorkerUsageInput, type WorkerUsagePayload, } from "./worker-usage.js";
 export { HERMES_OPENAI_CODEX_DEFAULT_MODEL, hermesCodexProvider, buildHermesOpenAiCodexChatArgv, } from "./providers/hermes-codex.js";
 export { classifyOpenAiCodexError, formatCronJobDeliveryFailure, formatOpenAiCodexFailureNotice, redactProviderErrorText, resolveOpenAiCodexRetryBudget, TRANSIENT_OPENAI_CODEX_ERROR_CLASSES, OPENAI_CODEX_PROVIDER, type ClassifiedOpenAiCodexError, type CodexFailureNoticeInput, type OpenAiCodexErrorClass, } from "./providers/openai-codex-resilience.js";
 export * from "./cron/hermes-provider-notice.js";
 export { buildOrchestrationProviderInventory, classifyOrchestrationRisk, compareProviderCandidates, getOrchestrationProviderCapability, listOrchestrationProviderCapabilities, probeClaudeOAuthBinding, probeCodexOAuthBinding, probeCursorOAuthBinding, probeHermesCliAdapter, probeHermesOpenAiCodexBinding, probeOrchestrationProviderBinding, providerCapableForRisk, resolveCodexOrchestrationAdapter, resolveOrchestrationRouting, selectCheapestCapableProvider, sanitizeOrchestrationAudit, orchestrationAuditForWorkerJson, getAdapterContextContract, listAdapterContextContracts, type AdapterContextCapability, type AdapterContextContract, type AdapterContextContractId, type CodexOrchestrationAdapterStatus, type CodexOrchestrationPath, type HermesCliAdapterStatus, type HermesOpenAiCodexBindingStatus, type OrchestrationAuthSource, type OrchestrationCloudApiCredits, type OrchestrationCostTier, type OrchestrationProviderBindingStatus, type OrchestrationProviderCapability, type OrchestrationProviderId, type OrchestrationProviderInventory, type OrchestrationRiskClass, type OrchestrationRoutingAudit, type OrchestrationRoutingDecision, } from "./orchestration-providers/index.js";
 export { ORCHESTRATION_POLICY_MODES, ORCHESTRATION_ACTION_KINDS, ORCHESTRATION_POLICY_DECISIONS, resolveOrchestrationPolicyMode, isOrchestrationEnforceTasksEnabled, buildForegroundHarnessIdempotencyKey, evaluateOrchestrationPolicy, type OrchestrationPolicyMode, type OrchestrationActionKind, type OrchestrationPolicyDecision, type OrchestrationPolicyEvaluateInput, type OrchestrationPolicyEvaluateResult, } from "./orchestration-enforcement/index.js";
-export { DEFAULT_WORKER_PROVIDER, enforceCursorWorkerProvider, isClaudeFamilyProvider, preferCursorExecutor, resolveConfiguredWorkerProvider, taskAllowsClaudeWorker, type EnforceCursorWorkerProviderInput, } from "./worker-provider-policy.js";
+export { DEFAULT_WORKER_PROVIDER, enforceCursorWorkerProvider, isClaudeFamilyProvider, normalizeWorkerProviderName, preferCursorExecutor, resolveConfiguredWorkerProvider, taskAllowsClaudeWorker, taskExpressesWorkerProviderPreference, type EnforceCursorWorkerProviderInput, } from "./worker-provider-policy.js";
 export { parseExecutorRefRoutingIntent, executorRefRequestsNonCursorWorker, type ExecutorRefRoutingIntent, } from "./executor-ref-routing.js";
 export { assessDispatchModelGuard, type DispatchModelGuardInput, type DispatchModelGuardResult, } from "./dispatch-model-guard.js";
 export { GLOBAL_DEFAULT_MODEL, CURSOR_DEFAULT_MODEL, inferModelRoutingFromTask, resolveGlobalDefaultModel, resolveModelFallback, resolveWorkerLaunch, type ModelRoutingDecision, } from "./model-routing.js";