@kontextmind/kxm 0.7.40 → 0.7.43

package/plugins/kxm/src/{vnext-engine-gate-records.ts → engine-gate-records.ts}

@@ -1,46 +1,46 @@
-import { gateDefinitionHash } from "./vnext-gate-hash.ts";
-import { mintVnextCapabilitySecret, vnextTransitionBudgetFailure } from "./vnext-engine.ts";
-import type { VnextRunPlanEnvelope } from "./vnext-engine-plan.ts";
-import { vnextCanonicalJson, type JsonValue } from "./vnext-config.ts";
+import { gateDefinitionHash } from "./gate-hash.ts";
+import { mintKxmCapabilitySecret, kxmTransitionBudgetFailure } from "./engine.ts";
+import type { KxmRunPlanEnvelope } from "./engine-plan.ts";
+import { kxmCanonicalJson, type JsonValue } from "./project-config.ts";
 import {
-  foldStoredVnextRun,
-  persistVnextRunState,
-  vnextEventBase,
-  vnextIncrementMonotonicNs,
-  vnextMonotonicNs,
-  type VnextRuntimeContext,
-} from "./vnext-runtime.ts";
+  foldStoredKxmRun,
+  persistKxmRunState,
+  kxmEventBase,
+  kxmIncrementMonotonicNs,
+  kxmMonotonicNs,
+  type KxmRuntimeContext,
+} from "./runtime-service.ts";
 import {
   assertClosedGateObservation,
   computeGateEvidenceOutcome,
   gateRowContentHash,
-  newVnextAssignmentId,
-  newVnextAttemptId,
-  newVnextEffectId,
-  newVnextEventId,
-  newVnextEvidenceId,
-  newVnextObservationId,
+  newKxmAssignmentId,
+  newKxmAttemptId,
+  newKxmEffectId,
+  newKxmEventId,
+  newKxmEvidenceId,
+  newKxmObservationId,
   runtimeError,
-  type VnextGateErrorClass,
-  type VnextGateEvidenceOutcome,
-  type VnextGateEvidenceRow,
-  type VnextGateObservationRow,
-  type VnextGateStopCause,
-  type VnextRunEvent,
-  type VnextRunRecord,
-} from "./vnext-runtime-store.ts";
+  type KxmGateErrorClass,
+  type KxmGateEvidenceOutcome,
+  type KxmGateEvidenceRow,
+  type KxmGateObservationRow,
+  type KxmGateStopCause,
+  type KxmRunEvent,
+  type KxmRunRecord,
+} from "./runtime-store.ts";
 
-export interface VnextGateObservationInput {
-  completeness: VnextGateObservationRow["completeness"];
+export interface KxmGateObservationInput {
+  completeness: KxmGateObservationRow["completeness"];
   spawned: 0 | 1;
   pid: number | null;
   exitCode: number | null;
   signal: string | null;
   exitObserved: 0 | 1;
   closeObserved: 0 | 1;
-  stopCause: VnextGateStopCause;
-  signalsAttempted: VnextGateObservationRow["signalsAttempted"];
-  errorClass: VnextGateErrorClass | null;
+  stopCause: KxmGateStopCause;
+  signalsAttempted: KxmGateObservationRow["signalsAttempted"];
+  errorClass: KxmGateErrorClass | null;
   stdoutSha256: string | null;
   stdoutBytes: number | null;
   stdoutComplete: 0 | 1 | null;
@@ -54,23 +54,23 @@ export interface VnextGateObservationInput {
   finishedAt: string | null;
 }
 
-export function recordGateIntent(context: VnextRuntimeContext, run: VnextRunRecord, envelope: VnextRunPlanEnvelope, stepId: string) {
+export function recordGateIntent(context: KxmRuntimeContext, run: KxmRunRecord, envelope: KxmRunPlanEnvelope, stepId: string) {
   return context.eventStore.transaction(() => recordGateIntentInTransaction(context, run, envelope, stepId));
 }
 
-export function recordGateIntentInTransaction(context: VnextRuntimeContext, run: VnextRunRecord, envelope: VnextRunPlanEnvelope, stepId: string) {
+export function recordGateIntentInTransaction(context: KxmRuntimeContext, run: KxmRunRecord, envelope: KxmRunPlanEnvelope, stepId: string) {
   const step = requireGateStep(envelope, stepId, run.runId);
   const definition = envelope.gates.definitions[step.gate];
   if (!definition || definition.kind === "reserved") {
     throw runtimeError("gate_row_invalid", run.runId, "reserved gates cannot record intent in this slice");
   }
-  const folded = foldStoredVnextRun(context, run);
+  const folded = foldStoredKxmRun(context, run);
   const used = folded.stepAttempts[stepId] ?? 0;
   const stepAttempt = used + 1;
-  const assignmentId = newVnextAssignmentId();
-  const attemptId = newVnextAttemptId();
-  const effectId = newVnextEffectId();
-  const minted = mintVnextCapabilitySecret();
+  const assignmentId = newKxmAssignmentId();
+  const attemptId = newKxmAttemptId();
+  const effectId = newKxmEffectId();
+  const minted = mintKxmCapabilitySecret();
   const now = new Date().toISOString();
   const seq = sequencer(context, run, now);
   seq.push("step.entered", { stepId, stepAttempt, status: "pending" });
@@ -126,11 +126,11 @@ export function recordGateIntentInTransaction(context: VnextRuntimeContext, run:
   return persist(context, run, now, seq.events.at(-1)!.sequence);
 }
 
-export function recordGateSpawned(context: VnextRuntimeContext, run: VnextRunRecord, envelope: VnextRunPlanEnvelope, stepId: string) {
+export function recordGateSpawned(context: KxmRuntimeContext, run: KxmRunRecord, envelope: KxmRunPlanEnvelope, stepId: string) {
   return context.eventStore.transaction(() => recordGateSpawnedInTransaction(context, run, envelope, stepId));
 }
 
-export function recordGateSpawnedInTransaction(context: VnextRuntimeContext, run: VnextRunRecord, envelope: VnextRunPlanEnvelope, stepId: string) {
+export function recordGateSpawnedInTransaction(context: KxmRuntimeContext, run: KxmRunRecord, envelope: KxmRunPlanEnvelope, stepId: string) {
   const ids = requireIntent(context, run, envelope, stepId);
   if (ids.gateKind !== "command") throw runtimeError("gate_row_invalid", run.runId, "effect.dispatched is command-only");
   const now = new Date().toISOString();
@@ -149,21 +149,21 @@ export function recordGateSpawnedInTransaction(context: VnextRuntimeContext, run
 }
 
 export function recordGateSettlement(
-  context: VnextRuntimeContext,
-  run: VnextRunRecord,
-  envelope: VnextRunPlanEnvelope,
+  context: KxmRuntimeContext,
+  run: KxmRunRecord,
+  envelope: KxmRunPlanEnvelope,
   stepId: string,
-  observation: VnextGateObservationInput,
+  observation: KxmGateObservationInput,
 ) {
   return context.eventStore.transaction(() => recordGateSettlementInTransaction(context, run, envelope, stepId, observation));
 }
 
 export function recordGateSettlementInTransaction(
-  context: VnextRuntimeContext,
-  run: VnextRunRecord,
-  envelope: VnextRunPlanEnvelope,
+  context: KxmRuntimeContext,
+  run: KxmRunRecord,
+  envelope: KxmRunPlanEnvelope,
   stepId: string,
-  observation: VnextGateObservationInput,
+  observation: KxmGateObservationInput,
 ) {
   const ids = requireIntent(context, run, envelope, stepId);
   assertClosedGateObservation(ids.gateKind, observation);
@@ -182,7 +182,7 @@ export function recordGateSettlementInTransaction(
     });
   }
   seq.push("attempt.status_changed", { attemptId: ids.attemptId, assignmentId: ids.assignmentId, stepId, stepAttempt: ids.stepAttempt, status: "settling" });
-  const observationId = newVnextObservationId();
+  const observationId = newKxmObservationId();
   const observed = seq.push("effect.observed", {
     effect: { id: ids.effectId, policy: { class: ids.gateKind === "artifacts-exist" ? "read-only" : "unknown", sharedMutable: false } },
     stepId,
@@ -193,8 +193,8 @@ export function recordGateSettlementInTransaction(
   });
   const observationRow = buildObservation(ids, observation, observationId, observed.eventId);
   patchReceipt(observed, observationRow);
-  const evidenceId = newVnextEvidenceId();
-  const evidenceDraft: VnextGateEvidenceRow = {
+  const evidenceId = newKxmEvidenceId();
+  const evidenceDraft: KxmGateEvidenceRow = {
     evidenceId,
     attemptId: ids.attemptId,
     observationId,
@@ -233,21 +233,21 @@ export function recordGateSettlementInTransaction(
 }
 
 export function recordGateNoStart(
-  context: VnextRuntimeContext,
-  run: VnextRunRecord,
-  envelope: VnextRunPlanEnvelope,
+  context: KxmRuntimeContext,
+  run: KxmRunRecord,
+  envelope: KxmRunPlanEnvelope,
   stepId: string,
-  observation: VnextGateObservationInput,
+  observation: KxmGateObservationInput,
 ) {
   return context.eventStore.transaction(() => recordGateNoStartInTransaction(context, run, envelope, stepId, observation));
 }
 
 export function recordGateNoStartInTransaction(
-  context: VnextRuntimeContext,
-  run: VnextRunRecord,
-  envelope: VnextRunPlanEnvelope,
+  context: KxmRuntimeContext,
+  run: KxmRunRecord,
+  envelope: KxmRunPlanEnvelope,
   stepId: string,
-  observation: VnextGateObservationInput,
+  observation: KxmGateObservationInput,
 ) {
   const ids = requireIntent(context, run, envelope, stepId);
   assertClosedGateObservation(ids.gateKind, observation);
@@ -258,7 +258,7 @@ export function recordGateNoStartInTransaction(
   const now = new Date().toISOString();
   const seq = sequencer(context, run, now);
   const cancelReason = cancelled ? ensureOperatorCancel(seq, ids.state, run, context) : undefined;
-  const observationId = newVnextObservationId();
+  const observationId = newKxmObservationId();
   const observed = seq.push("effect.observed", {
     effect: { id: ids.effectId, policy: { class: ids.gateKind === "artifacts-exist" ? "read-only" : "unknown", sharedMutable: false } },
     stepId,
@@ -304,23 +304,23 @@ export function recordGateNoStartInTransaction(
 }
 
 export function recordGateUncertain(
-  context: VnextRuntimeContext,
-  run: VnextRunRecord,
-  envelope: VnextRunPlanEnvelope,
+  context: KxmRuntimeContext,
+  run: KxmRunRecord,
+  envelope: KxmRunPlanEnvelope,
   stepId: string,
   reason: string,
-  observation: VnextGateObservationInput,
+  observation: KxmGateObservationInput,
 ) {
   return context.eventStore.transaction(() => recordGateUncertainInTransaction(context, run, envelope, stepId, reason, observation));
 }
 
 export function recordGateUncertainInTransaction(
-  context: VnextRuntimeContext,
-  run: VnextRunRecord,
-  envelope: VnextRunPlanEnvelope,
+  context: KxmRuntimeContext,
+  run: KxmRunRecord,
+  envelope: KxmRunPlanEnvelope,
   stepId: string,
   reason: string,
-  observation: VnextGateObservationInput,
+  observation: KxmGateObservationInput,
 ) {
   const ids = requireIntent(context, run, envelope, stepId);
   if (observation.completeness !== "incomplete") {
@@ -341,7 +341,7 @@ export function recordGateUncertainInTransaction(
   }
   const now = new Date().toISOString();
   const seq = sequencer(context, run, now);
-  const observationId = newVnextObservationId();
+  const observationId = newKxmObservationId();
   const blocked = seq.push("effect.blocked_uncertain", {
     effect: { id: ids.effectId, policy: { class: ids.gateKind === "artifacts-exist" ? "read-only" : "unknown", sharedMutable: false } },
     stepId,
@@ -359,21 +359,21 @@ export function recordGateUncertainInTransaction(
 }
 
 export function recordGateCancelObserved(
-  context: VnextRuntimeContext,
-  run: VnextRunRecord,
-  envelope: VnextRunPlanEnvelope,
+  context: KxmRuntimeContext,
+  run: KxmRunRecord,
+  envelope: KxmRunPlanEnvelope,
   stepId: string,
-  observation: VnextGateObservationInput,
+  observation: KxmGateObservationInput,
 ) {
   return context.eventStore.transaction(() => recordGateCancelObservedInTransaction(context, run, envelope, stepId, observation));
 }
 
 export function recordGateCancelObservedInTransaction(
-  context: VnextRuntimeContext,
-  run: VnextRunRecord,
-  envelope: VnextRunPlanEnvelope,
+  context: KxmRuntimeContext,
+  run: KxmRunRecord,
+  envelope: KxmRunPlanEnvelope,
   stepId: string,
-  observation: VnextGateObservationInput,
+  observation: KxmGateObservationInput,
 ) {
   const ids = requireIntent(context, run, envelope, stepId);
   assertClosedGateObservation(ids.gateKind, observation);
@@ -398,7 +398,7 @@ export function recordGateCancelObservedInTransaction(
     });
   }
   seq.push("attempt.status_changed", { attemptId: ids.attemptId, assignmentId: ids.assignmentId, stepId, stepAttempt: ids.stepAttempt, status: "settling" });
-  const observationId = newVnextObservationId();
+  const observationId = newKxmObservationId();
   const policyClass = ids.gateKind === "artifacts-exist" ? "read-only" : "unknown";
   const observed = seq.push("effect.observed", {
     effect: { id: ids.effectId, policy: { class: policyClass, sharedMutable: false } },
@@ -437,10 +437,10 @@ export function recordGateCancelObservedInTransaction(
 
 function appendEvaluatedTail(
   seq: ReturnType<typeof sequencer>,
-  envelope: VnextRunPlanEnvelope,
+  envelope: KxmRunPlanEnvelope,
   ids: ReturnType<typeof requireIntent>,
   stepId: string,
-  outcome: VnextGateEvidenceOutcome,
+  outcome: KxmGateEvidenceOutcome,
 ) {
   const mapped = outcome === "passed" ? "passed" : outcome === "repro-missing" ? "failed" : "failed";
   seq.push("assignment.result_recorded", { assignmentId: ids.assignmentId, resultClass: "outcome", outcome, status: "result_recorded" });
@@ -453,7 +453,7 @@ function appendEvaluatedTail(
     seq.push("run.status_changed", { status: "failed", reason: "outcome_unknown", stepId, outcome });
     return;
   }
-  const budget = vnextTransitionBudgetFailure(envelope.plan, ids.state, stepId, outcome);
+  const budget = kxmTransitionBudgetFailure(envelope.plan, ids.state, stepId, outcome);
   if (budget) {
     seq.push("run.status_changed", { status: "failed", reason: budget, stepId, outcome });
     return;
@@ -466,7 +466,7 @@ function appendEvaluatedTail(
   }
 }
 
-function evidenceKeyFor(envelope: VnextRunPlanEnvelope, stepId: string): string | null {
+function evidenceKeyFor(envelope: KxmRunPlanEnvelope, stepId: string): string | null {
   const required = envelope.plan.steps[stepId]?.requiredEvidence.filter((item) => item.kind === "gate") ?? [];
   return required.length === 1 ? required[0]!.key : null;
 }
@@ -481,18 +481,18 @@ function placeholderReceipt(observationId: string, kind: string, now: string) {
   };
 }
 
-function patchReceipt(event: VnextRunEvent, row: VnextGateObservationRow): void {
+function patchReceipt(event: KxmRunEvent, row: KxmGateObservationRow): void {
   const receipt = event.payload.receipt as { hash: string };
   receipt.hash = row.contentHash;
 }
 
 function buildObservation(
   ids: ReturnType<typeof requireIntent>,
-  observation: VnextGateObservationInput,
+  observation: KxmGateObservationInput,
   observationId: string,
   recordedEventId: string,
-): VnextGateObservationRow {
-  const row: VnextGateObservationRow = {
+): KxmGateObservationRow {
+  const row: KxmGateObservationRow = {
     observationId,
     attemptId: ids.attemptId,
     runId: ids.runId,
@@ -509,15 +509,15 @@ function buildObservation(
   return { ...row, contentHash: gateRowContentHash("gate_observations", { ...row, contentHash: "" }) };
 }
 
-function requireGateStep(envelope: VnextRunPlanEnvelope, stepId: string, runId: string) {
+function requireGateStep(envelope: KxmRunPlanEnvelope, stepId: string, runId: string) {
   const step = envelope.plan.steps[stepId];
   if (!step || step.kind !== "gate") throw runtimeError("run_events_illegal", runId, `step ${stepId} is not a gate`);
   return step;
 }
 
-function requireIntent(context: VnextRuntimeContext, run: VnextRunRecord, envelope: VnextRunPlanEnvelope, stepId: string) {
+function requireIntent(context: KxmRuntimeContext, run: KxmRunRecord, envelope: KxmRunPlanEnvelope, stepId: string) {
   const step = requireGateStep(envelope, stepId, run.runId);
-  const folded = foldStoredVnextRun(context, run);
+  const folded = foldStoredKxmRun(context, run);
   const attemptId = folded.currentStep?.attemptId;
   if (!attemptId || folded.currentStep?.stepId !== stepId) {
     throw runtimeError("run_events_illegal", run.runId, "gate intent has not been recorded");
@@ -534,9 +534,9 @@ function requireIntent(context: VnextRuntimeContext, run: VnextRunRecord, envelo
 
 function ensureOperatorCancel(
   seq: ReturnType<typeof sequencer>,
-  state: ReturnType<typeof foldStoredVnextRun>,
-  run: VnextRunRecord,
-  context: VnextRuntimeContext,
+  state: ReturnType<typeof foldStoredKxmRun>,
+  run: KxmRunRecord,
+  context: KxmRuntimeContext,
 ): string {
   if (state.status === "cancelling") return cancelReasonFromLog(context, run.runId);
   if (state.status !== "running") {
@@ -550,7 +550,7 @@ function ensureOperatorCancel(
   return "operator_cancel";
 }
 
-function cancelReasonFromLog(context: VnextRuntimeContext, runId: string): string {
+function cancelReasonFromLog(context: KxmRuntimeContext, runId: string): string {
   const events = context.eventStore.events(runId, 0, 1_000_000);
   for (let index = events.length - 1; index >= 0; index -= 1) {
     const event = events[index]!;
@@ -561,36 +561,36 @@ function cancelReasonFromLog(context: VnextRuntimeContext, runId: string): strin
   return "operator_cancel";
 }
 
-function sequencer(context: VnextRuntimeContext, run: VnextRunRecord, now: string) {
+function sequencer(context: KxmRuntimeContext, run: KxmRunRecord, now: string) {
   let sequence = context.eventStore.nextSequence(run.runId);
-  let mono = vnextMonotonicNs();
-  const events: VnextRunEvent[] = [];
+  let mono = kxmMonotonicNs();
+  const events: KxmRunEvent[] = [];
   return {
     events,
-    push(eventType: string, payload: Record<string, unknown>): VnextRunEvent {
-      const event: VnextRunEvent = {
-        ...vnextEventBase(context, run, now, mono),
-        eventId: newVnextEventId(),
+    push(eventType: string, payload: Record<string, unknown>): KxmRunEvent {
+      const event: KxmRunEvent = {
+        ...kxmEventBase(context, run, now, mono),
+        eventId: newKxmEventId(),
         eventType,
         sequence: sequence++,
         payload,
       };
-      mono = vnextIncrementMonotonicNs(mono);
+      mono = kxmIncrementMonotonicNs(mono);
       events.push(event);
       return event;
     },
   };
 }
 
-function persist(context: VnextRuntimeContext, run: VnextRunRecord, now: string, lastSequence: number) {
-  const next = foldStoredVnextRun(context, run);
-  persistVnextRunState(context, run.runId, next, lastSequence);
+function persist(context: KxmRuntimeContext, run: KxmRunRecord, now: string, lastSequence: number) {
+  const next = foldStoredKxmRun(context, run);
+  persistKxmRunState(context, run.runId, next, lastSequence);
   context.eventStore.updateRunStatus(run.runId, next.status, now);
   return { state: next, run: { ...run, status: next.status, updatedAt: now } };
 }
 
-function hashFromStore(context: VnextRuntimeContext, runId: string): string {
+function hashFromStore(context: KxmRuntimeContext, runId: string): string {
   return context.eventStore.runPlan(runId)!.runPlanHash;
 }
 
-void vnextCanonicalJson;
+void kxmCanonicalJson;