@odla-ai/harness 0.2.0 → 0.4.0

package/dist/{chunk-5FFR7U4L.js → chunk-ANNX7VGK.js}

@@ -205,6 +205,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 });
@@ -1996,6 +2006,55 @@ function validateOptions(options) {
   }
 }
 
+// src/code-memory.ts
+import { closure } from "@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 ? [...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);
@@ -2192,6 +2251,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,
@@ -2202,6 +2264,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.`;
@@ -2562,7 +2643,12 @@ export {
   createCodeRuntimeInference,
   registeredFiles,
   createCodeToolBroker,
+  MAX_MEMORY_BODY,
+  validateMemory,
+  recallAbout,
+  renderMemories,
+  hazardFromAttempt,
   runGoal,
   CodePiRuntimeEngine
 };
-//# sourceMappingURL=chunk-5FFR7U4L.js.map
+//# sourceMappingURL=chunk-ANNX7VGK.js.map