@kynver-app/runtime 0.1.123 → 0.1.129

package/dist/instruction-bundle/cache.d.ts

@@ -0,0 +1,6 @@
+import { type SignedInstructionBundle } from "./types.js";
+export declare function instructionBundleCachePath(agentOsId: string): string;
+/** Best-effort atomic write (temp + rename). Never throws. */
+export declare function saveInstructionBundleCache(agentOsId: string, signed: SignedInstructionBundle): void;
+/** Load the cached signed payload. Caller MUST verify the signature before use. */
+export declare function loadInstructionBundleCache(agentOsId: string): SignedInstructionBundle | null;

package/dist/instruction-bundle/client.d.ts

@@ -0,0 +1,25 @@
+export declare const INSTRUCTION_BUNDLE_REFRESH_TTL_MS: number;
+export declare function __resetInstructionBundleClientForTest(): void;
+export interface EnsureInstructionBundleOptions {
+    agentOsId: string;
+    /** Kynver API base URL (e.g. from `resolveBaseUrl`). No fetch when absent. */
+    baseUrl?: string | null;
+    /** Runner credential / callback secret for the by-id route. */
+    secret?: string | null;
+    /** Bypass the TTL gate (startup / tests). */
+    force?: boolean;
+    fetchImpl?: typeof fetch;
+    nowMs?: number;
+}
+export interface EnsureInstructionBundleResult {
+    source: "server" | "disk" | "embedded" | "primed";
+    version: string;
+    /** True when this call changed the active bundle. */
+    updated: boolean;
+}
+/**
+ * Ensure the active instruction bundle is fresh. TTL-gated (15 min) so the
+ * daemon can call it every tick; the first call performs the startup fetch.
+ * Never throws.
+ */
+export declare function ensureInstructionBundle(opts: EnsureInstructionBundleOptions): Promise<EnsureInstructionBundleResult>;

package/dist/instruction-bundle/contract.d.ts

@@ -0,0 +1,4 @@
+export * from "./types.js";
+export { PINNED_INSTRUCTION_BUNDLE_PUBLIC_KEYS, resolveInstructionBundlePublicKey, } from "./keys.js";
+export { verifyInstructionBundleSignatureWithKey, verifySignedInstructionBundle, type InstructionBundleVerifyResult, } from "./verify.js";
+export { EMBEDDED_INSTRUCTION_BUNDLE, EMBEDDED_INSTRUCTION_BUNDLE_VERSION, } from "./embedded-bundle.js";

package/dist/instruction-bundle/contract.js

@@ -0,0 +1,5 @@
+import{createHash as u}from"node:crypto";function o(e){return JSON.stringify(i(e))}function i(e){if(Array.isArray(e))return e.map(i);if(e&&typeof e=="object"){let t={};for(let n of Object.keys(e).sort())t[n]=i(e[n]);return t}return e}function L(e){return`ib1-${u("sha256").update(o(e),"utf8").digest("hex").slice(0,16)}`}function N(e){return`ib-${u("sha256").update(Buffer.from(e)).digest("hex").slice(0,12)}`}function a(e){if(!e)return null;let t=e.trim();if(!t)return null;if(/^[0-9a-fA-F]{64}$/.test(t))return new Uint8Array(t.match(/.{2}/g).map(n=>parseInt(n,16)));try{let n=Buffer.from(t,"base64");if(n.length===32)return new Uint8Array(n)}catch{}return null}function s(e){if(!e||typeof e!="object")return!1;let t=e;if(typeof t.signature!="string"||!t.signature||typeof t.publicKeyId!="string"||!t.publicKeyId)return!1;let n=t.bundle;return!(!n||typeof n!="object"||typeof n.version!="string"||!n.version||typeof n.generatedAt!="string"||!Array.isArray(n.personas)||!n.instructions||typeof n.instructions!="object"||!n.policyThresholds||typeof n.policyThresholds!="object")}var p={"ib-3bab6314f0ba":"53a2040646cd479e1f5f1aea9abf7848ce8b62e32001efb8044dfd90e8ab87ed"};function l(e,t=process.env){let n=a(t.KYNVER_INSTRUCTION_BUNDLE_PUBLIC_KEY);if(n)return n;let r=p[e];return r?a(r):null}import{createPublicKey as f,verify as m}from"node:crypto";var g=Buffer.from("302a300506032b6570032100","hex");function y(e){return f({key:Buffer.concat([g,Buffer.from(e)]),format:"der",type:"spki"})}function d(e,t){if(!s(e))return{ok:!1,reason:"malformed signed bundle payload"};let n;try{n=Buffer.from(e.signature,"base64url")}catch{return{ok:!1,reason:"signature is not base64url"}}if(n.length!==64)return{ok:!1,reason:"signature is not a 64-byte Ed25519 signature"};try{let r=Buffer.from(o(e.bundle),"utf8");return m(null,r,y(t),n)?{ok:!0,bundle:e.bundle}:{ok:!1,reason:"Ed25519 signature mismatch"}}catch(r){return{ok:!1,reason:`signature verification failed: ${r.message}`}}}function h(e,t=process.env){if(!s(e))return{ok:!1,reason:"malformed signed bundle payload"};let n=l(e.publicKeyId,t);return n?d(e,n):{ok:!1,reason:`no verification key for publicKeyId "${e.publicKeyId}" (not pinned; set KYNVER_INSTRUCTION_BUNDLE_PUBLIC_KEY)`}}var c="embedded-1",I=[{slug:"ghost",displayName:"Ghost",description:"Orchestration persona.",dispatchLane:null,defaultRoleLane:"system"},{slug:"astra",displayName:"Astra",description:"Planning persona.",dispatchLane:"implementation",defaultRoleLane:"plan_author"},{slug:"rhea",displayName:"Rhea",description:"Implementation persona.",dispatchLane:"implementation",defaultRoleLane:"implementer"},{slug:"mnemo",displayName:"Mnemo",description:"Implementation persona.",dispatchLane:"implementation",defaultRoleLane:"implementer"},{slug:"sentinel",displayName:"Sentinel",description:"Review persona.",dispatchLane:"review",defaultRoleLane:"deep_reviewer"},{slug:"pixel",displayName:"Pixel",description:"Implementation persona.",dispatchLane:"implementation",defaultRoleLane:"implementer"},{slug:"schema",displayName:"Schema",description:"Implementation persona.",dispatchLane:"implementation",defaultRoleLane:"implementer"},{slug:"atlas",displayName:"Atlas",description:"Implementation persona.",dispatchLane:"implementation",defaultRoleLane:"runtime_verifier"},{slug:"bridge",displayName:"Bridge",description:"Implementation persona.",dispatchLane:"implementation",defaultRoleLane:"implementer"},{slug:"catalyst",displayName:"Catalyst",description:"Implementation persona.",dispatchLane:"implementation",defaultRoleLane:"implementer"},{slug:"lorentz",displayName:"Lorentz",description:"Review persona.",dispatchLane:"review",defaultRoleLane:"report_reviewer"},{slug:"dalton",displayName:"Dalton",description:"Landing persona.",dispatchLane:"landing",defaultRoleLane:"implementer"}],b={"worker.prompt.core_rules":["Structured final result (recommended): record completion as JSON with summary, files, PR URLs, verification, risks, and blockers.","Completion handoff (required): before you stop, summarize the outcome in your last message and append a heartbeat line with phase `complete`. Commit your work cleanly and open a GitHub PR (draft OK) for substantial changes \u2014 never leave uncommitted changes behind without reporting them.","Review-only workers must not open new implementation PRs \u2014 review the existing PR and record a verdict in the final result.","Keep verification targeted to touched paths; avoid full-monorepo verification unless explicitly requested.","Do not run `npm publish`.","If verification fails, append a heartbeat line immediately with the failing command, reason, and next action."].join(`
+`),"worker.prompt.progress.compact":"Plan progress: when planId is set, report progress with `kynver plan progress --plan <planId> --row <rowKey> --role implementer --status in_progress|running|partial|blocked`. Do not mark rows done from the worker CLI.","worker.prompt.progress.full":["Structured plan progress (required when planId is set):","- Report checkpoints with `kynver plan progress --plan <planId> --row <rowKey> --role implementer --status in_progress|running|partial|blocked`.","- When a slice is finished, emit `partial` with evidence (`--evidence pr:<url>`, `--evidence path:<file>`, or `--evidence command:<cmd>`).","- Do not propose or confirm row `done` from the worker CLI."].join(`
+`),"worker.prompt.merge_gate.compact":"Verification cost control: prefer local verification before requesting CI runs; do not push empty commits to re-trigger CI; record verification evidence on the PR.","worker.prompt.merge_gate.full":["Verification cost control:","- Prefer local verification of touched paths before requesting any CI run.","- Do not push empty commits to re-trigger CI.","- Record verification evidence on the PR before requesting review."].join(`
+`),"worker.prompt.plan_artifacts.compact":"Plan artifacts: when authoring or revising plan documents, open a GitHub PR early and iterate from that PR branch; do not leave the canonical plan only in a local worktree.","worker.prompt.plan_artifacts.full":["Plan artifacts (when authoring or revising plan documents):","- Create a feature branch and open a GitHub PR (draft OK) before substantial drafting; commit and push the plan file.","- Iterate on that PR branch and link the PR URL on the related task and progress evidence."].join(`
+`)},R={"harness.maxTaskAttempts":4,"harness.dispatchCooldownMs":5e3,"daemon.idleIntervalMs":5*6e4,"daemon.maxIdleStreak":10},B={version:c,generatedAt:"1970-01-01T00:00:00.000Z",personas:I,instructions:b,policyThresholds:R};export{B as EMBEDDED_INSTRUCTION_BUNDLE,c as EMBEDDED_INSTRUCTION_BUNDLE_VERSION,p as PINNED_INSTRUCTION_BUNDLE_PUBLIC_KEYS,o as canonicalJsonStringify,L as computeInstructionBundleVersion,N as deriveInstructionBundleKeyId,s as isSignedInstructionBundleShape,a as parseRawEd25519Key,l as resolveInstructionBundlePublicKey,d as verifyInstructionBundleSignatureWithKey,h as verifySignedInstructionBundle};

package/dist/instruction-bundle/embedded-bundle.d.ts

@@ -0,0 +1,3 @@
+import type { InstructionBundle } from "./types.js";
+export declare const EMBEDDED_INSTRUCTION_BUNDLE_VERSION = "embedded-1";
+export declare const EMBEDDED_INSTRUCTION_BUNDLE: InstructionBundle;

package/dist/instruction-bundle/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./types.js";
+export * from "./keys.js";
+export * from "./verify.js";
+export * from "./embedded-bundle.js";
+export * from "./state.js";
+export * from "./cache.js";
+export * from "./client.js";

package/dist/instruction-bundle/keys.d.ts

@@ -0,0 +1,14 @@
+/**
+ * keyId → raw Ed25519 public key (hex). `ib-3bab6314f0ba` is the committed
+ * DEV fallback pair the server uses when `KYNVER_INSTRUCTION_BUNDLE_KEY` is
+ * unset — fine for dev/first-boot, NOT a production trust root (its private
+ * half is committed server-side). Production deployments set a real private
+ * key on the server and `KYNVER_INSTRUCTION_BUNDLE_PUBLIC_KEY` on daemon
+ * hosts until the prod public key is pinned here in a republish.
+ */
+export declare const PINNED_INSTRUCTION_BUNDLE_PUBLIC_KEYS: Readonly<Record<string, string>>;
+/**
+ * Resolve the raw public key for a `publicKeyId`. The env override wins (key
+ * rotation without a package republish); otherwise the pinned set by id.
+ */
+export declare function resolveInstructionBundlePublicKey(publicKeyId: string, env?: Record<string, string | undefined>): Uint8Array | null;

package/dist/instruction-bundle/state.d.ts

@@ -0,0 +1,24 @@
+import type { InstructionBundle, InstructionBundlePersona } from "./types.js";
+export type InstructionBundleSource = "embedded" | "disk" | "server" | "primed";
+export declare function getActiveInstructionBundle(): InstructionBundle;
+export declare function getActiveInstructionBundleVersion(): string;
+export declare function getActiveInstructionBundleSource(): InstructionBundleSource;
+/**
+ * Install a bundle as the active one. The fetch client calls this ONLY after
+ * signature verification; `primed` is for in-process callers that already
+ * hold canonical content (e.g. the Kynver server seeding its own runtime
+ * imports) and for tests.
+ */
+export declare function setActiveInstructionBundle(bundle: InstructionBundle, source: InstructionBundleSource): void;
+/** Reset to the embedded fallback (tests). */
+export declare function __resetActiveInstructionBundleForTest(): void;
+/**
+ * Resolve a keyed instruction literal: active bundle first, then the embedded
+ * fallback for that key, then empty string (never throws — a missing key must
+ * never take a worker down).
+ */
+export declare function resolveInstructionText(key: string): string;
+/** Resolve a numeric policy threshold: active bundle → embedded → fallback. */
+export declare function resolvePolicyThreshold(key: string, fallback: number): number;
+/** Persona entry from the active bundle (null when the slug is not present). */
+export declare function resolveBundlePersona(slug: string | null | undefined): InstructionBundlePersona | null;

package/dist/instruction-bundle/types.d.ts

@@ -0,0 +1,42 @@
+export type InstructionBundleDispatchLane = "implementation" | "review" | "landing";
+export type InstructionBundleRoleLane = "plan_author" | "implementer" | "report_reviewer" | "deep_reviewer" | "runtime_verifier" | "system";
+export interface InstructionBundlePersona {
+    slug: string;
+    displayName: string;
+    description: string;
+    dispatchLane: InstructionBundleDispatchLane | null;
+    defaultRoleLane: InstructionBundleRoleLane;
+}
+/** Content payload — everything the version hash covers. */
+export interface InstructionBundleContent {
+    personas: InstructionBundlePersona[];
+    /** Keyed instruction literals (e.g. `worker.prompt.core_rules`). */
+    instructions: Record<string, string>;
+    /** Keyed numeric policy thresholds (e.g. `harness.maxTaskAttempts`). */
+    policyThresholds: Record<string, number>;
+}
+export interface InstructionBundle extends InstructionBundleContent {
+    /** Content hash (`ib1-<sha256 prefix>`) — stable per content, used as ETag. */
+    version: string;
+    generatedAt: string;
+}
+export interface SignedInstructionBundle {
+    bundle: InstructionBundle;
+    /** base64url Ed25519 signature over `canonicalJsonStringify(bundle)`. */
+    signature: string;
+    /** Identifies the signing key (`ib-<sha256(publicKey) prefix>`). */
+    publicKeyId: string;
+}
+/**
+ * Deterministic JSON: recursively sorted object keys so signer and verifier
+ * agree on the signed bytes regardless of construction/parse order.
+ */
+export declare function canonicalJsonStringify(value: unknown): string;
+/** Stable content-hash version: `ib1-` + first 16 hex of sha256(canonical content). */
+export declare function computeInstructionBundleVersion(content: InstructionBundleContent): string;
+/** Derive the key id used as `publicKeyId` from a raw 32-byte Ed25519 public key. */
+export declare function deriveInstructionBundleKeyId(rawPublicKey: Uint8Array): string;
+/** Parse a raw 32-byte key from hex (64 chars) or base64. Returns null when malformed. */
+export declare function parseRawEd25519Key(raw: string | null | undefined): Uint8Array | null;
+/** Structural validation of a parsed wire payload. */
+export declare function isSignedInstructionBundleShape(value: unknown): value is SignedInstructionBundle;

package/dist/instruction-bundle/verify.d.ts

@@ -0,0 +1,15 @@
+import { type InstructionBundle } from "./types.js";
+export type InstructionBundleVerifyResult = {
+    ok: true;
+    bundle: InstructionBundle;
+} | {
+    ok: false;
+    reason: string;
+};
+/** Verify a signed bundle against an explicit raw 32-byte public key. */
+export declare function verifyInstructionBundleSignatureWithKey(signed: unknown, rawPublicKey: Uint8Array): InstructionBundleVerifyResult;
+/**
+ * Verify a signed bundle resolving the key from the env override / pinned set.
+ * This is the daemon's trust gate — a bundle that fails here is never used.
+ */
+export declare function verifySignedInstructionBundle(signed: unknown, env?: Record<string, string | undefined>): InstructionBundleVerifyResult;

package/dist/mesh-liveness/mesh-cron-lease-store.d.ts

@@ -0,0 +1,9 @@
+export interface PersistedMeshCronLease {
+    leaseToken: string | null;
+    holderBoxId: string | null;
+    authorized: boolean;
+    updatedAt: string;
+}
+export declare function loadPersistedMeshCronLease(runId: string): PersistedMeshCronLease | null;
+export declare function persistMeshCronLease(runId: string, input: Pick<PersistedMeshCronLease, "leaseToken" | "holderBoxId" | "authorized">): void;
+export declare function extractMeshLivenessFromOperatorTickResponse(operatorTick: unknown): PersistedMeshCronLease | null;

package/dist/retry-limits.d.ts

@@ -5,4 +5,8 @@ export interface HarnessRetryLimits {
     /** Minimum ms between dispatch starts for the same run (default 5s). */
     dispatchCooldownMs: number;
 }
+/**
+ * Precedence: env override → server-delivered instruction bundle threshold →
+ * embedded default (M6 — policy values iterate via bundle push, no republish).
+ */
 export declare function readHarnessRetryLimits(): HarnessRetryLimits;