@holoscript/holoscript-agent 2.0.1 → 2.0.2

package/dist/supervisor.js

@@ -9,9 +9,14 @@ var HolomeshClient = class {
     this.bearer = opts.bearer;
     this.teamId = opts.teamId;
     this.fetchImpl = opts.fetchImpl ?? fetch;
+    this.signer = opts.signer;
+  }
+  /** Wrap body in a signed envelope when a signer is available (strict-mode endpoints). */
+  async signBody(body) {
+    return this.signer ? await this.signer(body) : body;
   }
   async heartbeat(payload) {
-    await this.req("POST", `/team/${this.teamId}/presence`, payload);
+    await this.req("POST", `/team/${this.teamId}/presence`, await this.signBody(payload));
   }
   async getOpenTasks() {
     const data = await this.req(
@@ -21,28 +26,33 @@ var HolomeshClient = class {
     return data.tasks ?? data.open ?? [];
   }
   async claim(taskId) {
-    return this.req("PATCH", `/team/${this.teamId}/board/${taskId}`, { action: "claim" });
+    return this.req("PATCH", `/team/${this.teamId}/board/${taskId}`, await this.signBody({ action: "claim" }));
   }
   async joinTeam() {
     return this.req(
       "POST",
       `/team/${this.teamId}/join`,
-      {}
+      await this.signBody({})
     );
   }
   async sendMessageOnTask(taskId, body) {
-    await this.req("POST", `/team/${this.teamId}/message`, {
+    await this.req("POST", `/team/${this.teamId}/message`, await this.signBody({
       to: "team",
       subject: `task:${taskId}`,
       content: body
-    });
+    }));
   }
   async markDone(taskId, summary, commitHash) {
-    await this.req("PATCH", `/team/${this.teamId}/board/${taskId}`, {
+    await this.req("PATCH", `/team/${this.teamId}/board/${taskId}`, await this.signBody({
       action: "done",
       summary,
-      commitHash
-    });
+      // verification_evidence required by server before task can be closed.
+      verification_evidence: summary,
+      // Exclude commitHash when undefined — JSON.stringify drops undefined but
+      // canonicalizeSigning preserves it as the literal string "undefined",
+      // causing a signature-mismatch vs what the server sees after JSON.parse.
+      ...commitHash !== void 0 ? { commitHash } : {}
+    }));
   }
   // POST CAEL audit records for this agent. Server validator at
   // packages/mcp-server/src/holomesh/routes/core-routes.ts:472-533 requires
@@ -76,39 +86,28 @@ var HolomeshClient = class {
   }
   /** Post a message to the team feed. */
   async sendTeamMessage(content, messageType = "text") {
-    await this.req("POST", `/team/${this.teamId}/message`, {
-      content,
-      type: messageType
-    });
+    await this.req("POST", `/team/${this.teamId}/message`, await this.signBody({ content, type: messageType }));
   }
   // ── Owner-op API wrappers (E4) ─────────────────────────────────────────────
   /** Switch team mode. Requires owner or founder role. */
   async setTeamMode(mode, reason) {
-    return this.req("POST", `/team/${this.teamId}/mode`, { mode, reason });
+    return this.req("POST", `/team/${this.teamId}/mode`, await this.signBody({ mode, reason }));
   }
   /** Update room preferences. Requires config:write permission. */
   async patchRoomPrefs(prefs) {
-    return this.req("PATCH", `/team/${this.teamId}/room`, prefs);
+    return this.req("PATCH", `/team/${this.teamId}/room`, await this.signBody(prefs));
   }
   /** Update a board task. */
   async updateTask(taskId, updates) {
-    return this.req("PATCH", `/team/${this.teamId}/board/${taskId}`, {
-      action: "update",
-      ...updates
-    });
+    return this.req("PATCH", `/team/${this.teamId}/board/${taskId}`, await this.signBody({ action: "update", ...updates }));
   }
   /** Delete a board task. */
   async deleteTask(taskId) {
-    return this.req("PATCH", `/team/${this.teamId}/board/${taskId}`, {
-      action: "delete"
-    });
+    return this.req("PATCH", `/team/${this.teamId}/board/${taskId}`, await this.signBody({ action: "delete" }));
   }
   /** Delegate a board task to another agent. */
   async delegateTask(taskId, toAgentId) {
-    return this.req("PATCH", `/team/${this.teamId}/board/${taskId}`, {
-      action: "delegate",
-      toAgentId
-    });
+    return this.req("PATCH", `/team/${this.teamId}/board/${taskId}`, await this.signBody({ action: "delegate", toAgentId }));
   }
   async req(method, path, body) {
     const url = `${this.apiBase}${path}`;
@@ -177,7 +176,18 @@ function brainClassOf(brain) {
   return "unknown";
 }
 function buildCaelRecord(input) {
-  const { identity, brain, task, messages, finalText, usage, costUsd, spentUsd, prevChain, runtimeVersion } = input;
+  const {
+    identity,
+    brain,
+    task,
+    messages,
+    finalText,
+    usage,
+    costUsd,
+    spentUsd,
+    prevChain,
+    runtimeVersion
+  } = input;
   const l0 = sha(brain.systemPrompt);
   const l1 = sha(`${task.id}|${task.title}|${task.description ?? ""}`);
   const l2 = sha(JSON.stringify(messages));
@@ -200,9 +210,9 @@ function buildCaelRecord(input) {
 
 // src/tools.ts
 import { readFile, writeFile, readdir, mkdir, stat } from "fs/promises";
-import { resolve, dirname } from "path";
+import { resolve, dirname, delimiter, isAbsolute, sep } from "path";
 import { spawn } from "child_process";
-var ALLOWED_READ_ROOTS = [
+var FLEET_READ_ROOTS = [
   "/root/msc-paper-22",
   // Paper 22 mechanization inputs (scp'd by deploy)
   "/root/holoscript-mesh",
@@ -210,10 +220,23 @@ var ALLOWED_READ_ROOTS = [
   "/root/agent-output"
   // Read back what we wrote
 ];
-var ALLOWED_WRITE_ROOTS = [
+var FLEET_WRITE_ROOTS = [
   "/root/agent-output"
   // Single write sink — keeps deliverables in one place
 ];
+function parseRootsEnv(raw, fallback) {
+  if (!raw) return fallback;
+  const roots = raw.split(delimiter).map((r) => r.trim()).filter((r) => r.length > 0 && isAbsolute(r));
+  return roots.length > 0 ? roots : fallback;
+}
+var ALLOWED_READ_ROOTS = parseRootsEnv(
+  process.env.HOLOSCRIPT_AGENT_READ_ROOTS,
+  FLEET_READ_ROOTS
+);
+var ALLOWED_WRITE_ROOTS = parseRootsEnv(
+  process.env.HOLOSCRIPT_AGENT_WRITE_ROOTS,
+  FLEET_WRITE_ROOTS
+);
 var BASH_READ_ONLY_PREFIXES = [
   "ls ",
   "ls\n",
@@ -239,7 +262,15 @@ var BASH_PRODUCTIVE_PREFIXES = [
   "lean ",
   "pnpm --filter",
   "pnpm vitest",
-  "vitest run"
+  "vitest run",
+  // Robotics / edge-node (Jetson) productive commands — without these, every
+  // ros2/colcon/tegrastats task fails the W.107 artifact gate and is abandoned
+  // as no-artifact. (jetson-orin-01 lane.)
+  "ros2 launch",
+  "ros2 topic pub",
+  "ros2 service call",
+  "colcon build",
+  "tegrastats"
 ];
 var BASH_WHITELIST = [...BASH_READ_ONLY_PREFIXES, ...BASH_PRODUCTIVE_PREFIXES];
 function isProductiveBashCommand(cmd) {
@@ -250,7 +281,7 @@ function isProductiveBashCommand(cmd) {
 var MESH_TOOLS = [
   {
     name: "read_file",
-    description: "Read a file from the agent sandbox. Allowed roots: /root/msc-paper-22, /root/holoscript-mesh, /root/agent-output. Returns the file content as text. Use this to inspect inputs scp'd to the instance (e.g. MSC/Invariants.lean).",
+    description: `Read a file from the agent sandbox. Allowed roots: ${ALLOWED_READ_ROOTS.join(", ")}. Returns the file content as text. Use this to inspect task inputs and the read-only repo view.`,
     input_schema: {
       type: "object",
       properties: {
@@ -272,11 +303,11 @@ var MESH_TOOLS = [
   },
   {
     name: "write_file",
-    description: "Write a file to /root/agent-output/. This is the deliverable sink \u2014 anything you want to emit as task output (a Lean proof, a markdown report, a JSON dataset) goes here. Creates parent directories. Will refuse paths outside the write root.",
+    description: `Write a file to the deliverable sink (write roots: ${ALLOWED_WRITE_ROOTS.join(", ")}). Anything you want to emit as task output (a Lean proof, a markdown report, a JSON dataset, a .holo scene) goes here. Creates parent directories. Will refuse paths outside the write root(s).`,
     input_schema: {
       type: "object",
       properties: {
-        path: { type: "string", description: "Absolute path under /root/agent-output/" },
+        path: { type: "string", description: `Absolute path under a write root: ${ALLOWED_WRITE_ROOTS.join(", ")}` },
         content: { type: "string", description: "File content to write (UTF-8)" }
       },
       required: ["path", "content"]
@@ -284,7 +315,7 @@ var MESH_TOOLS = [
   },
   {
     name: "bash",
-    description: "Run a shell command. Whitelisted prefixes only: lake build, lean, ls, cat, grep, find, wc, head, tail, git status/log/diff/show, pnpm --filter, vitest run, pwd, echo. Hard 60s wall timeout, 1MB stdout cap. Use for lake build / lean kernel-checks, git inspection, repo greps. Refuses rm, curl, ssh, sudo, eval.",
+    description: "Run a shell command. Whitelisted prefixes only: lake build, lean, ls, cat, grep, find, wc, head, tail, git status/log/diff/show, pnpm --filter, vitest run, pwd, echo, ros2 launch/topic/service, colcon build, tegrastats. Hard 60s wall timeout, 1MB stdout cap. Use for builds, tests, hardware probes. Refuses rm, curl, ssh, sudo, eval.",
     input_schema: {
       type: "object",
       properties: {
@@ -293,22 +324,52 @@ var MESH_TOOLS = [
       },
       required: ["cmd"]
     }
+  },
+  {
+    name: "emit_hardware_receipt",
+    description: "Emit a portable hardware receipt (PortableHardwareReceiptMetadata v1) capturing device identity, runtime, and measured performance. Writes a JSON receipt to the agent output dir. Use after running tegrastats or colcon build to record hardware evidence for the CAEL audit chain. Accepts either pre-parsed measurements or raw tegrastats output (the tool parses it automatically).",
+    input_schema: {
+      type: "object",
+      properties: {
+        device_kind: {
+          type: "string",
+          description: 'Device identifier, e.g. "jetson-orin-nano-super", "raspberry-pi-5"'
+        },
+        accelerator: {
+          description: 'Accelerator string, e.g. "NVIDIA CUDA 8.7", or null for CPU-only'
+        },
+        runtime_name: { type: "string", description: 'Inference runtime, e.g. "Ollama", "llama.cpp"' },
+        runtime_version: { type: "string", description: 'Runtime version, e.g. "0.30.8"' },
+        host_os: { type: "string", description: 'OS + firmware, e.g. "JetPack 6.2.1 / Ubuntu 22.04"' },
+        composition_id: { type: "string", description: 'Brain composition reference, e.g. "jetson-orin-brain"' },
+        measurements: {
+          type: "array",
+          description: "Pre-parsed measurements. Each item: {metric: string, value: number, unit: string}",
+          items: { type: "object" }
+        },
+        tegrastats_output: {
+          type: "string",
+          description: "Raw tegrastats output line(s) \u2014 tool auto-parses GPU%, RAM, temp, power"
+        }
+      },
+      required: ["device_kind", "runtime_name", "runtime_version", "host_os"]
+    }
   }
 ];
 function isUnderRoot(absPath, root) {
   const resolved = resolve(absPath);
   const rootResolved = resolve(root);
-  return resolved === rootResolved || resolved.startsWith(rootResolved + "/");
+  return resolved === rootResolved || resolved.startsWith(rootResolved + sep);
 }
 function checkReadAllowed(path) {
-  if (!path.startsWith("/")) return `path must be absolute, got "${path}"`;
+  if (!isAbsolute(path)) return `path must be absolute, got "${path}"`;
   for (const root of ALLOWED_READ_ROOTS) {
     if (isUnderRoot(path, root)) return null;
   }
   return `read denied \u2014 path "${path}" not under allowed roots: ${ALLOWED_READ_ROOTS.join(", ")}`;
 }
 function checkWriteAllowed(path) {
-  if (!path.startsWith("/")) return `path must be absolute, got "${path}"`;
+  if (!isAbsolute(path)) return `path must be absolute, got "${path}"`;
   for (const root of ALLOWED_WRITE_ROOTS) {
     if (isUnderRoot(path, root)) return null;
   }
@@ -363,11 +424,105 @@ async function runTool(use) {
       return result.code === 0 ? okResult(use.id, result.stdout) : errResult(use.id, `exit=${result.code}
 ${result.stderr || result.stdout}`);
     }
+    if (use.name === "emit_hardware_receipt") {
+      const deviceKind = String(use.input.device_kind ?? "unknown-device");
+      const accelerator = use.input.accelerator === null || use.input.accelerator === "null" ? null : String(use.input.accelerator ?? "").trim() || null;
+      const runtimeName = String(use.input.runtime_name ?? "Ollama");
+      const runtimeVersion = String(use.input.runtime_version ?? "unknown");
+      const hostOs = String(use.input.host_os ?? "unknown");
+      const compositionId = String(use.input.composition_id ?? "unknown");
+      let measurements = [];
+      if (Array.isArray(use.input.measurements)) {
+        for (const m of use.input.measurements) {
+          const metric = String(m.metric ?? "");
+          const value = Number(m.value ?? 0);
+          const unit = String(m.unit ?? "");
+          if (metric && Number.isFinite(value)) {
+            measurements.push({ metric, value, unit, method: "measured" });
+          }
+        }
+      }
+      if (typeof use.input.tegrastats_output === "string" && use.input.tegrastats_output.length > 0) {
+        measurements = [...measurements, ...parseTegrastats(use.input.tegrastats_output)];
+      }
+      if (measurements.length === 0) {
+        measurements.push({ metric: "agent-tick", value: 1, unit: "count", method: "presence" });
+      }
+      const capturedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const receipt = {
+        schemaVersion: "holoscript.hardware-receipt-metadata.v1",
+        target: {
+          id: `${deviceKind}-${Date.now()}`,
+          kind: deviceKind,
+          architecture: /jetson|orin|nano|agx|xavier/i.test(deviceKind) ? "arm64" : "unknown",
+          artifactKind: "measurement-trace"
+        },
+        device: {
+          vendor: /jetson|orin|nvidia/i.test(deviceKind) ? "nvidia" : "unknown",
+          model: deviceKind,
+          accelerator
+        },
+        runtime: { name: runtimeName, version: runtimeVersion, hostOS: hostOs },
+        compilerVersion: "holoscript-agent-1.0.0",
+        constraints: [],
+        measuredResults: measurements,
+        replayInputs: [
+          { kind: "composition-ref", uri: `compositions/${compositionId}`, sha256: "unknown" }
+        ],
+        provenance: {
+          capturedAt,
+          sourceCompositionHash: compositionId
+        },
+        owner: {
+          agent: process.env.HOLOSCRIPT_AGENT_HANDLE ?? "unknown",
+          ...process.env.HOLOMESH_TEAM_ID ? { team: process.env.HOLOMESH_TEAM_ID } : {}
+        }
+      };
+      const ts = capturedAt.replace(/[:.]/g, "-");
+      const outPath = resolve(ALLOWED_WRITE_ROOTS[0], `hardware-receipt-${ts}.json`);
+      const denied = checkWriteAllowed(outPath);
+      if (denied) return errResult(use.id, `Cannot write receipt: ${denied}`);
+      await mkdir(dirname(outPath), { recursive: true });
+      await writeFile(outPath, JSON.stringify(receipt, null, 2), "utf8");
+      return okResult(
+        use.id,
+        `Hardware receipt written to ${outPath} \u2014 ${measurements.length} measurements, accelerator=${accelerator ?? "none"}`
+      );
+    }
     return errResult(use.id, `unknown tool: ${use.name}`);
   } catch (err) {
     return errResult(use.id, err instanceof Error ? err.message : String(err));
   }
 }
+function parseTegrastats(raw) {
+  const results = [];
+  const m = (pattern, metric, unit, transform) => {
+    const match = raw.match(pattern);
+    if (match?.[1]) {
+      const value = transform ? transform(match[1]) : Number(match[1]);
+      if (Number.isFinite(value)) results.push({ metric, value, unit, method: "tegrastats" });
+    }
+  };
+  const ram = raw.match(/RAM\s+(\d+)\/(\d+)MB/);
+  if (ram) {
+    const used = Number(ram[1]);
+    const total = Number(ram[2]);
+    results.push({ metric: "ram-used", value: used, unit: "MB", method: "tegrastats" });
+    results.push({ metric: "ram-total", value: total, unit: "MB", method: "tegrastats" });
+    if (total > 0)
+      results.push({ metric: "ram-pct", value: Math.round(used / total * 100), unit: "%", method: "tegrastats" });
+  }
+  m(/GR3D_FREQ\s+(\d+)%/, "gpu-util", "%");
+  m(/EMC_FREQ\s+(\d+)%/, "emc-freq-pct", "%");
+  m(/tj@([\d.]+)C/, "temp-tj", "C", parseFloat);
+  m(/cpu@([\d.]+)C/, "temp-cpu", "C", parseFloat);
+  m(/gpu@([\d.]+)C/, "temp-gpu", "C", parseFloat);
+  m(/VDD_SOC\s+(\d+)mW/, "power-soc", "mW");
+  m(/VDD_CPU_CV\s+(\d+)mW/, "power-cpu-cv", "mW");
+  m(/VDD_IN\s+(\d+)mW/, "power-total", "mW");
+  m(/CPU\s+\[(\d+)%/, "cpu-util-core0", "%");
+  return results;
+}
 function runBash(cmd, cwd) {
   if (process.env.VITEST === "true" || process.env.NODE_ENV === "test") {
     return Promise.resolve({
@@ -515,12 +670,16 @@ var AgentRunner = class {
         finalText = finalText || `[tool-loop hit ${MAX_TOOL_ITERS}-iter cap before final text]`;
         break;
       }
+      const activeTools = brain.requires.includes("local-llm") ? MESH_TOOLS.filter((t) => t.name === "write_file") : MESH_TOOLS;
       const resp = await provider.complete(
         {
           messages,
-          maxTokens: 4096,
+          // 8192 for local thinking models (qwen3:4b uses ~3800 tokens on thinking
+          // before the tool-call JSON; 4096 cuts off mid-generation). Frontier
+          // models ignore this ceiling and stop naturally earlier.
+          maxTokens: 8192,
           temperature: 0.4,
-          tools: MESH_TOOLS
+          tools: activeTools
         },
         identity.llmModel
       );
@@ -531,7 +690,12 @@ var AgentRunner = class {
         totalTokens: aggUsage.totalTokens + resp.usage.totalTokens
       };
       if (resp.finishReason === "tool_use" && resp.toolUses && resp.toolUses.length > 0) {
-        log({ ev: "tool-call", taskId: target.id, iter: iters, tools: resp.toolUses.map((t) => t.name) });
+        log({
+          ev: "tool-call",
+          taskId: target.id,
+          iter: iters,
+          tools: resp.toolUses.map((t) => t.name)
+        });
         for (const u of resp.toolUses) {
           toolsCalled.add(u.name);
           if (u.name === "write_file") {
@@ -540,6 +704,8 @@ var AgentRunner = class {
           } else if (u.name === "bash") {
             const cmd = String(u.input?.cmd ?? "");
             if (isProductiveBashCommand(cmd)) productiveCallCount++;
+          } else if (u.name === "emit_hardware_receipt") {
+            productiveCallCount++;
           }
         }
         messages.push({
@@ -584,6 +750,58 @@ var AgentRunner = class {
         message: `no productive tool call observed (toolsCalled=[${[...toolsCalled].join(",")}], productiveCallCount=${productiveCallCount}, iters=${iters})`
       };
     }
+    let reflectVerdict;
+    if (brain.reflect) {
+      try {
+        const reflectResp = await provider.complete(
+          {
+            messages: [
+              {
+                role: "system",
+                content: "You are a strict reviewer. Evaluate the work against the criteria; do not rewrite it."
+              },
+              {
+                role: "user",
+                content: `Reflect on the artifact produced for this task. Evaluate it for: ${brain.reflect.criteria}.
+
+--- artifact / final response ---
+${finalText.slice(0, 4e3)}
+--- end ---
+
+Give a one-line reason, then end with exactly "VERDICT: PASS" or "VERDICT: FAIL".`
+              }
+            ],
+            maxTokens: 512,
+            temperature: 0.1
+          },
+          identity.llmModel
+        );
+        aggUsage = {
+          promptTokens: aggUsage.promptTokens + reflectResp.usage.promptTokens,
+          completionTokens: aggUsage.completionTokens + reflectResp.usage.completionTokens,
+          totalTokens: aggUsage.totalTokens + reflectResp.usage.totalTokens
+        };
+        const verdictMatch = /VERDICT:\s*(PASS|FAIL)/i.exec(reflectResp.content);
+        const pass = verdictMatch ? verdictMatch[1].toUpperCase() === "PASS" : true;
+        reflectVerdict = {
+          pass,
+          reason: reflectResp.content.replace(/VERDICT:\s*(PASS|FAIL)/i, "").trim().slice(0, 300)
+        };
+        log({
+          ev: "reflect",
+          taskId: target.id,
+          pass,
+          escalateOnFail: brain.reflect.escalateOnFail,
+          reason: reflectVerdict.reason.slice(0, 120)
+        });
+      } catch (err) {
+        log({
+          ev: "reflect-error",
+          taskId: target.id,
+          message: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
     const cost = costGuard.recordUsage(identity.llmModel, aggUsage);
     log({
       ev: "executed",
@@ -593,7 +811,11 @@ var AgentRunner = class {
       tokens: aggUsage.totalTokens,
       tool_iters: iters
     });
-    const response = { ...lastResponse ?? { content: finalText, usage: aggUsage }, content: finalText, usage: aggUsage };
+    const response = {
+      ...lastResponse ?? { content: finalText, usage: aggUsage },
+      content: finalText,
+      usage: aggUsage
+    };
     const execResult = {
       taskId: target.id,
       responseText: response.content,
@@ -627,10 +849,32 @@ var AgentRunner = class {
       });
       const posted = await mesh.postAuditRecords(identity.handle, [caelRecord]);
       this.prevCaelChain = caelRecord.fnv1a_chain;
-      log({ ev: "cael-posted", taskId: target.id, appended: posted.appended, rejected: posted.rejected });
+      log({
+        ev: "cael-posted",
+        taskId: target.id,
+        appended: posted.appended,
+        rejected: posted.rejected
+      });
     } catch (err) {
       log({ ev: "cael-post-error", message: err instanceof Error ? err.message : String(err) });
     }
+    if (reflectVerdict && !reflectVerdict.pass && brain.reflect?.escalateOnFail) {
+      try {
+        await mesh.sendMessageOnTask(
+          target.id,
+          `[${identity.handle}] reflect gate FAILED \u2014 escalating to the fleet instead of marking done. Reason: ${reflectVerdict.reason}`
+        );
+      } catch {
+      }
+      log({ ev: "reflect-escalate", taskId: target.id, reason: reflectVerdict.reason.slice(0, 120) });
+      return {
+        action: "reflect-escalate",
+        taskId: target.id,
+        spentUsd: costGuard.getState().spentUsd,
+        remainingUsd: costGuard.getRemainingUsd(),
+        message: `reflect self-evaluation failed; escalated to fleet (reason: ${reflectVerdict.reason.slice(0, 120)})`
+      };
+    }
     if (this.opts.onTaskExecuted) {
       await this.opts.onTaskExecuted(execResult, target);
     } else {
@@ -645,7 +889,11 @@ ${response.content}`
       await mesh.markDone(target.id, finalText.slice(0, 500), lastCommitHash);
       log({ ev: "mark-done", taskId: target.id, commitHash: lastCommitHash });
     } catch (err) {
-      log({ ev: "mark-done-error", taskId: target.id, message: err instanceof Error ? err.message : String(err) });
+      log({
+        ev: "mark-done-error",
+        taskId: target.id,
+        message: err instanceof Error ? err.message : String(err)
+      });
     }
     return {
       action: "executed",
@@ -739,7 +987,7 @@ function buildTaskPrompt(task) {
     "Description:",
     task.description ?? "(no description)",
     "",
-    "Produce the deliverable described in the task. Apply your brain composition rules \u2014 anti-patterns, decision loop, and scope tier all bind. Return the response as plain text suitable for posting to /room as a message on this task."
+    "Produce the deliverable: call write_file (or bash with a build command) to create all required output files FIRST. Apply your brain composition rules \u2014 anti-patterns, decision loop, and scope tier all bind. After calling the tool(s), return a short plain-text summary of what you did for posting to /room."
   ].join("\n");
 }
 function sleep(ms) {
@@ -753,6 +1001,8 @@ function jitter(base) {
 import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
 import { dirname as dirname2 } from "path";
 var ANTHROPIC_PRICING_USD_PER_MTOK = {
+  "claude-opus-4-8": { input: 10, output: 50 },
+  // 3× cheaper than 4.7 on total cost; A-020 2026-06-08
   "claude-opus-4-7": { input: 5, output: 25 },
   "claude-opus-4-6": { input: 5, output: 25 },
   "claude-sonnet-4-6": { input: 3, output: 15 },
@@ -830,8 +1080,9 @@ function todayUtc() {
 // src/brain.ts
 import { readFile as readFile2 } from "fs/promises";
 async function loadBrain(brainPath, scopeTier = "warm") {
-  const systemPrompt = await readFile2(brainPath, "utf8");
-  const { domain, capabilityTags, requires, prefers, avoids } = extractIdentity(systemPrompt);
+  const raw = await readFile2(brainPath, "utf8");
+  const { domain, capabilityTags, requires, prefers, avoids } = extractIdentity(raw);
+  const systemPrompt = extractSystemPromptPreamble(raw);
   return {
     brainPath,
     systemPrompt,
@@ -840,9 +1091,30 @@ async function loadBrain(brainPath, scopeTier = "warm") {
     scopeTier,
     requires,
     prefers,
-    avoids
+    avoids,
+    reflect: extractReflect(raw)
   };
 }
+function extractReflect(brain) {
+  const block = sliceNamedBlock(brain, "reflect");
+  if (block === void 0) return void 0;
+  const criteria = scalarField(block, "criteria") ?? scalarField(block, "scorer") ?? scalarField(block, "of") ?? "correctness, completeness, and valid HoloScript syntax";
+  const escRaw = scalarField(block, "escalate_on_fail") ?? scalarField(block, "escalateOnFail") ?? scalarField(block, "escalate");
+  return { criteria, escalateOnFail: (escRaw ?? "").split(",")[0].trim().toLowerCase() === "true" };
+}
+function extractSystemPromptPreamble(src) {
+  const lines = src.split("\n");
+  const BLOCK_START = /^(#version|#target|#mode|identity\s*\{|state\s*\{|computed\s*\{|traits\s*\[|capabilities\s*\{|directives\s*\{|behavior\s)/;
+  let cutLine = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (BLOCK_START.test(lines[i].trim())) {
+      cutLine = i;
+      break;
+    }
+  }
+  if (cutLine <= 0) return src;
+  return lines.slice(0, cutLine).join("\n").trimEnd();
+}
 function extractIdentity(brain) {
   const identityBlock = sliceNamedBlock(brain, "identity");
   if (!identityBlock) {
@@ -931,7 +1203,9 @@ function makeCommitHook(opts) {
     const relPath = relativeTo(cwd, filePath);
     const addRes = spawn2("git", ["add", relPath], { cwd, encoding: "utf8" });
     if (addRes.status !== 0) {
-      throw new Error(`git add failed: ${addRes.stderr || addRes.stdout || `exit ${addRes.status}`}`);
+      throw new Error(
+        `git add failed: ${addRes.stderr || addRes.stdout || `exit ${addRes.status}`}`
+      );
     }
     const message = renderCommitMessage({ scope, task, identity, result });
     const commitArgs = ["commit", "-m", message];
@@ -940,7 +1214,9 @@ function makeCommitHook(opts) {
     }
     const commitRes = spawn2("git", commitArgs, { cwd, encoding: "utf8" });
     if (commitRes.status !== 0) {
-      throw new Error(`git commit failed: ${commitRes.stderr || commitRes.stdout || `exit ${commitRes.status}`}`);
+      throw new Error(
+        `git commit failed: ${commitRes.stderr || commitRes.stdout || `exit ${commitRes.status}`}`
+      );
     }
     const hashRes = spawn2("git", ["rev-parse", "HEAD"], { cwd, encoding: "utf8" });
     const commitHash = hashRes.status === 0 ? hashRes.stdout.trim() : void 0;
@@ -1198,9 +1474,7 @@ function pickProvider(opts) {
         picked: candidates[0].name,
         reason: "open-routing-default",
         unsatisfiedRequires: [],
-        matchedPrefers: brain.prefers.filter(
-          (p) => satisfies(candidates[0].capabilities, p)
-        ),
+        matchedPrefers: brain.prefers.filter((p) => satisfies(candidates[0].capabilities, p)),
         excludedByAvoids,
         alternatives: candidates.slice(1).map((c) => c.name)
       };
@@ -1214,7 +1488,9 @@ function pickProvider(opts) {
       alternatives: ordered.slice(1).map((c) => c.name)
     };
   }
-  const eligible = notAvoided.filter((c) => unsatisfiedKeys(c.capabilities, brain.requires).length === 0);
+  const eligible = notAvoided.filter(
+    (c) => unsatisfiedKeys(c.capabilities, brain.requires).length === 0
+  );
   if (eligible.length === 0) {
     if (envOverride !== void 0) {
       const envCandidate = candidates.find((c) => c.name === envOverride);
@@ -1413,7 +1689,9 @@ var Supervisor = class {
     }
     const wallet = process.env[spec.walletEnvKey];
     if (!wallet || !/^0x[0-9a-fA-F]{40}$/.test(wallet)) {
-      throw new Error(`Missing or malformed wallet env var "${spec.walletEnvKey}" for agent "${spec.handle}"`);
+      throw new Error(
+        `Missing or malformed wallet env var "${spec.walletEnvKey}" for agent "${spec.handle}"`
+      );
     }
     return {
       handle: spec.handle,