@kynver-app/runtime 0.2.23 → 0.2.24

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/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";