@odla-ai/harness 0.2.0 → 0.4.0

package/dist/code-runtime-cli.js

@@ -6,7 +6,7 @@ import {
   assertCodeBuildRecipe,
   createCodeRuntimeControlClient,
   runCodeRuntimeHeartbeatLoop
-} from "./chunk-5FFR7U4L.js";
+} from "./chunk-ANNX7VGK.js";
 import {
   assertPinnedImage,
   selectContainerEngine

package/dist/node.cjs

@@ -26,6 +26,7 @@ __export(node_exports, {
   CodeRuntimeControlError: () => CodeRuntimeControlError,
   CodeRuntimeReconciler: () => CodeRuntimeReconciler,
   DecompositionError: () => DecompositionError,
+  MAX_MEMORY_BODY: () => MAX_MEMORY_BODY,
   MEASURED_PREMIUM: () => MEASURED_PREMIUM,
   SYSTEM_PROMPT_FOR: () => SYSTEM_PROMPT_FOR,
   V1_SYSTEM_PROMPT: () => V1_SYSTEM_PROMPT,
@@ -48,17 +49,23 @@ __export(node_exports, {
   describePatchFailure: () => describePatchFailure,
   digestStagedWorkspace: () => digestStagedWorkspace,
   feedbackIsActionable: () => feedbackIsActionable,
+  hazardFromAttempt: () => hazardFromAttempt,
   installedDependencies: () => installedDependencies,
   integrateSubGoals: () => integrateSubGoals,
   isCheckpointEffectCompleted: () => isCheckpointEffectCompleted,
   materializeCodeRuntimeSource: () => materializeCodeRuntimeSource,
   materializeCommandWorkspace: () => materializeCommandWorkspace,
   materializeGitTree: () => materializeGitTree,
+  outcomeCloses: () => outcomeCloses,
+  outcomeMemory: () => outcomeMemory,
   patchPaths: () => patchPaths,
   planReachCollisions: () => planReachCollisions,
   prepareRuntimeCheckpoint: () => prepareRuntimeCheckpoint,
   racedAttempt: () => racedAttempt,
+  recallAbout: () => recallAbout,
   registeredFiles: () => registeredFiles,
+  renderMemories: () => renderMemories,
+  renderOutcome: () => renderOutcome,
   resolveCodePath: () => resolveCodePath,
   restoreCodeWorkspaceCheckpoint: () => restoreCodeWorkspaceCheckpoint,
   runCodeAgent: () => runCodeAgent,
@@ -68,6 +75,7 @@ __export(node_exports, {
   runGoal: () => runGoal,
   runHarnessRunner: () => runHarnessRunner,
   runLeasedAttempt: () => runLeasedAttempt,
+  runtimeMemoryStore: () => runtimeMemoryStore,
   safeWorkspaceLabel: () => safeWorkspaceLabel,
   selectContainerEngine: () => selectContainerEngine,
   selectWinner: () => selectWinner,
@@ -76,6 +84,7 @@ __export(node_exports, {
   straySubGoalFiles: () => straySubGoalFiles,
   stripPatchEnvelope: () => stripPatchEnvelope,
   validateCodePatch: () => validateCodePatch,
+  validateMemory: () => validateMemory,
   validateRelativePath: () => validateRelativePath,
   verifyCodeCandidate: () => verifyCodeCandidate,
   verifyContainerEngineBoundary: () => verifyContainerEngineBoundary,
@@ -974,6 +983,16 @@ function createCodeRuntimeControlClient(options) {
       }
       await call(`/registry/code/runtime/sessions/${validSessionId(sessionId)}/chat/events`, { eventId, event });
     },
+    recallMemories: async (sessionId, subjects, limit) => {
+      const response2 = await call(
+        `/registry/code/runtime/sessions/${validSessionId(sessionId)}/recall`,
+        { subjects: [...subjects], limit }
+      );
+      return Array.isArray(response2.memories) ? response2.memories : [];
+    },
+    rememberMemory: async (sessionId, memory) => {
+      await call(`/registry/code/runtime/sessions/${validSessionId(sessionId)}/remember`, memory);
+    },
     reportSessionFailure: async (sessionId, message2) => {
       if (!message2.trim() || message2.length > 2e3) throw new TypeError("invalid Code session failure");
       await call(`/registry/code/runtime/sessions/${validSessionId(sessionId)}/failure`, { message: message2 });
@@ -2832,6 +2851,55 @@ function createCodeRuntimeToolBroker(input, lease, role) {
   return role === "coding" ? broker : { execute: (context, request) => request.tool === "sandbox.read" ? broker.execute(context, request) : Promise.resolve({ requestId: request.requestId, ok: false, content: "review sessions are read-only" }) };
 }
 
+// src/code-memory.ts
+var import_graph2 = require("@odla-ai/graph");
+var MAX_MEMORY_BODY = 4e3;
+function validateMemory(memory) {
+  if (!memory.subject.includes(":")) {
+    throw new TypeError(`memory subject must be a graph node id, got "${memory.subject}"`);
+  }
+  const body = memory.body.trim();
+  if (!body) throw new TypeError("a memory needs a body");
+  if (body.length > MAX_MEMORY_BODY) throw new TypeError("memory body exceeds its bound");
+  if (!memory.authorId.trim()) throw new TypeError("a memory needs an author");
+}
+async function recallAbout(store, subjects, options = {}) {
+  const limit = options.limit ?? 20;
+  const wanted = options.graph ? [...(0, import_graph2.closure)(options.graph, subjects, {
+    direction: "out",
+    maxDepth: options.depth ?? 1,
+    ...options.kinds ? { kinds: options.kinds } : {}
+  })] : [...subjects];
+  const found = await store.recall(wanted, limit * 2);
+  return found.filter((memory) => !memory.supersededBy).slice(0, limit);
+}
+function renderMemories(memories) {
+  if (memories.length === 0) return "";
+  const lines = memories.map((memory) => {
+    const source = memory.evidence ? ` [${memory.evidence.kind}:${memory.evidence.ref}]` : " [unverified]";
+    return `- (${memory.kind}) ${memory.subject}${source}
+  ${memory.body.replace(/\s+/g, " ").slice(0, 400)}`;
+  });
+  return [
+    "What previous runs learned about this code. A hazard cost an attempt to find;",
+    "an unverified note is one agent's opinion. Treat them accordingly.",
+    ...lines
+  ].join("\n");
+}
+function hazardFromAttempt(input) {
+  const body = [
+    `Attempt ${input.attempt} at "${input.goal.slice(0, 200)}" failed its proof.`,
+    input.feedback.replace(/\s+/g, " ").slice(0, MAX_MEMORY_BODY - 300)
+  ].join(" ");
+  return input.touched.slice(0, 10).map((path) => ({
+    subject: path.includes(":") ? path : `file:${path}`,
+    kind: "hazard",
+    body,
+    evidence: { kind: "gate", ref: input.verificationId },
+    authorId: input.authorId
+  }));
+}
+
 // src/code-goal-runner.ts
 async function runGoal(spec, attempt) {
   assertBudget(spec.budget);
@@ -3016,6 +3084,9 @@ function pursueRuntimeGoal(input) {
         return { gatePassed: false, feedback: "", tokens: outcome.tokens, error: outcome.error };
       }
       const verdict = await input.gate(attempt);
+      if (!verdict.passed && input.memory) {
+        await rememberFailure(input, attempt, verdict.feedback);
+      }
       return {
         gatePassed: verdict.passed,
         feedback: verdict.feedback,
@@ -3026,6 +3097,25 @@ function pursueRuntimeGoal(input) {
     }
   );
 }
+async function rememberFailure(input, attempt, feedback) {
+  if (!input.memory || !feedback.trim()) return;
+  try {
+    const touched = await input.touched?.(attempt) ?? [];
+    if (touched.length === 0) return;
+    for (const memory of hazardFromAttempt({
+      goal: input.spec.goal,
+      attempt,
+      feedback,
+      touched,
+      verificationId: `goal-${attempt}`,
+      authorId: input.memory.authorId
+    })) {
+      validateMemory(memory);
+      await input.memory.store.remember(memory);
+    }
+  } catch {
+  }
+}
 function goalEventLine(event) {
   if (event.type === "attempt_started") return `Goal attempt ${event.attempt} starting.`;
   if (event.type === "attempt_failed") return `Attempt ${event.attempt} did not satisfy the proof.`;
@@ -3351,6 +3441,56 @@ var CodePiRuntimeEngine = class {
   }
 };
 
+// src/code-runtime-memory.ts
+async function mutationId(memory) {
+  const source = `${memory.subject} ${memory.kind} ${memory.body}`;
+  const bytes = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(source));
+  return Array.from(new Uint8Array(bytes), (byte) => byte.toString(16).padStart(2, "0")).join("").slice(0, 40);
+}
+function runtimeMemoryStore(control, sessionId) {
+  const recall = control.recallMemories;
+  const remember = control.rememberMemory;
+  if (!recall || !remember) return null;
+  return {
+    recall: async (subjects, limit) => await recall.call(control, sessionId, subjects, limit),
+    remember: async (memory) => {
+      await remember.call(control, sessionId, {
+        subject: memory.subject,
+        kind: memory.kind,
+        body: memory.body,
+        ...memory.evidence ? { evidence: memory.evidence } : {},
+        mutationId: await mutationId(memory)
+      });
+      return { ...memory, id: "", createdAt: Date.now() };
+    }
+  };
+}
+
+// src/code-goal-outcome.ts
+function outcomeCloses(outcome) {
+  return outcome.met && outcome.evidence !== void 0;
+}
+function renderOutcome(outcome) {
+  const spend = outcome.costUsd === void 0 ? "cost unknown" : `$${outcome.costUsd.toFixed(4)}`;
+  const scale = `${outcome.attempts} attempt(s), ${outcome.tokens.toLocaleString()} tokens, ${spend}`;
+  if (!outcome.met) {
+    return `Goal not met (${outcome.stoppedReason}) after ${scale}. Proof: ${outcome.proof}`;
+  }
+  if (!outcome.evidence) {
+    return `Goal reported met after ${scale}, but no verification receipt was produced. Treat as unverified. Proof: ${outcome.proof}`;
+  }
+  return `Goal met after ${scale}. Verified by ${outcome.evidence.kind}:${outcome.evidence.ref}. Proof: ${outcome.proof}`;
+}
+function outcomeMemory(outcome, subject, authorId) {
+  return {
+    subject,
+    kind: "outcome",
+    body: renderOutcome(outcome),
+    ...outcome.evidence ? { evidence: outcome.evidence } : {},
+    authorId
+  };
+}
+
 // src/code-goal-race.ts
 function selectWinner(outcomes) {
   const ranked = [...outcomes].sort((left, right) => {
@@ -3411,7 +3551,7 @@ function racedAttempt(options) {
 }
 
 // src/code-goal-decompose.ts
-var import_graph2 = require("@odla-ai/graph");
+var import_graph3 = require("@odla-ai/graph");
 var import_code5 = require("@odla-ai/graph/code");
 var DecompositionError = class extends Error {
   constructor(message2) {
@@ -3499,7 +3639,7 @@ async function integrateSubGoals(options) {
 }
 async function planReachCollisions(plan, workspace) {
   const graph = await (0, import_code5.buildCodeGraph)({ paths: workspace.paths, read: workspace.read });
-  return (0, import_graph2.partition)(graph, plan.map((sub) => sub.files.map((file) => `${import_code5.FILE}:${file}`)), {
+  return (0, import_graph3.partition)(graph, plan.map((sub) => sub.files.map((file) => `${import_code5.FILE}:${file}`)), {
     kinds: [import_code5.IMPORTS, import_code5.READS, import_code5.WRITES],
     direction: "out"
   });
@@ -3609,6 +3749,7 @@ async function installedDependencies(repoRoot) {
   CodeRuntimeControlError,
   CodeRuntimeReconciler,
   DecompositionError,
+  MAX_MEMORY_BODY,
   MEASURED_PREMIUM,
   SYSTEM_PROMPT_FOR,
   V1_SYSTEM_PROMPT,
@@ -3631,17 +3772,23 @@ async function installedDependencies(repoRoot) {
   describePatchFailure,
   digestStagedWorkspace,
   feedbackIsActionable,
+  hazardFromAttempt,
   installedDependencies,
   integrateSubGoals,
   isCheckpointEffectCompleted,
   materializeCodeRuntimeSource,
   materializeCommandWorkspace,
   materializeGitTree,
+  outcomeCloses,
+  outcomeMemory,
   patchPaths,
   planReachCollisions,
   prepareRuntimeCheckpoint,
   racedAttempt,
+  recallAbout,
   registeredFiles,
+  renderMemories,
+  renderOutcome,
   resolveCodePath,
   restoreCodeWorkspaceCheckpoint,
   runCodeAgent,
@@ -3651,6 +3798,7 @@ async function installedDependencies(repoRoot) {
   runGoal,
   runHarnessRunner,
   runLeasedAttempt,
+  runtimeMemoryStore,
   safeWorkspaceLabel,
   selectContainerEngine,
   selectWinner,
@@ -3659,6 +3807,7 @@ async function installedDependencies(repoRoot) {
   straySubGoalFiles,
   stripPatchEnvelope,
   validateCodePatch,
+  validateMemory,
   validateRelativePath,
   verifyCodeCandidate,
   verifyContainerEngineBoundary,