@holoscript/holoscript-agent 2.0.0 → 2.0.1

package/dist/supervisor.js

@@ -65,6 +65,51 @@ var HolomeshClient = class {
       wallet: raw.wallet
     };
   }
+  // ── Team Message Surface (E4 delegated-authority protocol) ───────────────────
+  /** Read recent team messages. */
+  async getTeamMessages(limit = 20) {
+    const data = await this.req(
+      "GET",
+      `/team/${this.teamId}/messages?limit=${limit}`
+    );
+    return data.messages ?? [];
+  }
+  /** Post a message to the team feed. */
+  async sendTeamMessage(content, messageType = "text") {
+    await this.req("POST", `/team/${this.teamId}/message`, {
+      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 });
+  }
+  /** Update room preferences. Requires config:write permission. */
+  async patchRoomPrefs(prefs) {
+    return this.req("PATCH", `/team/${this.teamId}/room`, prefs);
+  }
+  /** Update a board task. */
+  async updateTask(taskId, updates) {
+    return this.req("PATCH", `/team/${this.teamId}/board/${taskId}`, {
+      action: "update",
+      ...updates
+    });
+  }
+  /** Delete a board task. */
+  async deleteTask(taskId) {
+    return this.req("PATCH", `/team/${this.teamId}/board/${taskId}`, {
+      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
+    });
+  }
   async req(method, path, body) {
     const url = `${this.apiBase}${path}`;
     const res = await this.fetchImpl(url, {
@@ -148,7 +193,8 @@ function buildCaelRecord(input) {
     prev_hash: prevChain,
     fnv1a_chain,
     version_vector_fingerprint: `agent@${runtimeVersion}|brain@${brainClassOf(brain)}|provider@${identity.llmProvider}|model@${identity.llmModel}`,
-    brain_class: brainClassOf(brain)
+    brain_class: brainClassOf(brain),
+    trust_epoch: "post-w107"
   };
 }
 
@@ -168,11 +214,7 @@ var ALLOWED_WRITE_ROOTS = [
   "/root/agent-output"
   // Single write sink — keeps deliverables in one place
 ];
-var BASH_WHITELIST = [
-  "lake build",
-  "lake env",
-  "lake clean",
-  "lean ",
+var BASH_READ_ONLY_PREFIXES = [
   "ls ",
   "ls\n",
   "ls$",
@@ -187,12 +229,24 @@ var BASH_WHITELIST = [
   "git log",
   "git diff",
   "git show",
+  "pwd",
+  "echo ",
+  "lake env"
+];
+var BASH_PRODUCTIVE_PREFIXES = [
+  "lake build",
+  "lake clean",
+  "lean ",
   "pnpm --filter",
   "pnpm vitest",
-  "vitest run",
-  "pwd",
-  "echo "
+  "vitest run"
 ];
+var BASH_WHITELIST = [...BASH_READ_ONLY_PREFIXES, ...BASH_PRODUCTIVE_PREFIXES];
+function isProductiveBashCommand(cmd) {
+  const trimmed = String(cmd ?? "").trim();
+  if (!trimmed) return false;
+  return BASH_PRODUCTIVE_PREFIXES.some((prefix) => trimmed.startsWith(prefix.trim()));
+}
 var MESH_TOOLS = [
   {
     name: "read_file",
@@ -315,6 +369,13 @@ ${result.stderr || result.stdout}`);
   }
 }
 function runBash(cmd, cwd) {
+  if (process.env.VITEST === "true" || process.env.NODE_ENV === "test") {
+    return Promise.resolve({
+      code: 0,
+      stdout: `[mock-bash under vitest] cmd="${cmd}" cwd="${cwd}"`,
+      stderr: ""
+    });
+  }
   return new Promise((resolveProm) => {
     const child = spawn("bash", ["-c", cmd], { cwd, env: process.env });
     let stdout = "";
@@ -383,6 +444,35 @@ var AgentRunner = class {
     const { identity, brain, mesh, costGuard, provider, logger } = this.opts;
     const log = logger ?? (() => void 0);
     await this.heartbeatWithAutoRejoin();
+    if (this.opts.messageHandler) {
+      try {
+        const receipts = await this.opts.messageHandler.processMessages();
+        if (receipts.length > 0) {
+          log({
+            ev: "messages-processed",
+            count: receipts.length,
+            statuses: receipts.map((r) => r.status)
+          });
+          if (brain.capabilityTags.length === 0 || brain.capabilityTags.every((t) => t.startsWith("delegated"))) {
+            return {
+              action: "messages-processed",
+              spentUsd: costGuard.getState().spentUsd,
+              remainingUsd: costGuard.getRemainingUsd(),
+              receipts: receipts.map((r) => ({
+                status: r.status,
+                action: r.action,
+                reason: r.reason
+              }))
+            };
+          }
+        }
+      } catch (err) {
+        log({
+          ev: "message-handler-error",
+          message: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
     if (costGuard.isOverBudget()) {
       const state = costGuard.getState();
       log({ ev: "over-budget", spentUsd: state.spentUsd, budget: identity.budgetUsdPerDay });
@@ -416,6 +506,8 @@ var AgentRunner = class {
     const MAX_TOOL_ITERS = 30;
     let lastResponse;
     const toolsCalled = /* @__PURE__ */ new Set();
+    let productiveCallCount = 0;
+    let lastCommitHash;
     while (true) {
       iters++;
       if (iters > MAX_TOOL_ITERS) {
@@ -440,12 +532,31 @@ var AgentRunner = class {
       };
       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) });
-        for (const u of resp.toolUses) toolsCalled.add(u.name);
+        for (const u of resp.toolUses) {
+          toolsCalled.add(u.name);
+          if (u.name === "write_file") {
+            const content = String(u.input?.content ?? "");
+            if (content.length > 0) productiveCallCount++;
+          } else if (u.name === "bash") {
+            const cmd = String(u.input?.cmd ?? "");
+            if (isProductiveBashCommand(cmd)) productiveCallCount++;
+          }
+        }
         messages.push({
           role: "assistant",
           content: resp.assistantBlocks ?? []
         });
         const toolResults = await Promise.all(resp.toolUses.map((u) => runTool(u)));
+        for (let ti = 0; ti < resp.toolUses.length; ti++) {
+          const tu = resp.toolUses[ti];
+          if (tu.name === "bash") {
+            const tr = toolResults[ti];
+            if (tr && !tr.is_error) {
+              const shaMatch = tr.content.match(/\b([0-9a-f]{7,40})\b/);
+              if (shaMatch) lastCommitHash = shaMatch[1];
+            }
+          }
+        }
         messages.push({
           role: "user",
           content: toolResults
@@ -456,22 +567,21 @@ var AgentRunner = class {
       break;
     }
     const durationMs = Date.now() - start;
-    const SIDE_EFFECTING_TOOLS = /* @__PURE__ */ new Set(["write_file", "bash"]);
-    const sideEffectingCalled = [...toolsCalled].some((t) => SIDE_EFFECTING_TOOLS.has(t));
-    if (!sideEffectingCalled) {
+    if (productiveCallCount === 0) {
       log({
         ev: "no-artifact",
         taskId: target.id,
         tool_iters: iters,
         toolsCalled: [...toolsCalled],
-        message: "task execution called no side-effecting tool (write_file/bash) \u2014 refusing to mark executed. Likely a pure-text or read-only-inspection response. Task remains open for a grounded attempt."
+        productiveCallCount,
+        message: "task execution did not produce a real artifact \u2014 refusing to mark executed. Required: write_file with non-empty content OR bash with a productive prefix (lake build / pnpm --filter / vitest run / lean / pnpm vitest). Pure-text, read-only inspection, and trivial-bash-bypass (`echo`, `cat`, etc.) do not satisfy the gate."
       });
       return {
         action: "no-artifact",
         taskId: target.id,
         spentUsd: costGuard.getState().spentUsd,
         remainingUsd: costGuard.getRemainingUsd(),
-        message: `no side-effecting tool called (toolsCalled=[${[...toolsCalled].join(",")}], iters=${iters})`
+        message: `no productive tool call observed (toolsCalled=[${[...toolsCalled].join(",")}], productiveCallCount=${productiveCallCount}, iters=${iters})`
       };
     }
     const cost = costGuard.recordUsage(identity.llmModel, aggUsage);
@@ -531,6 +641,12 @@ var AgentRunner = class {
 ${response.content}`
       );
     }
+    try {
+      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) });
+    }
     return {
       action: "executed",
       taskId: target.id,
@@ -637,8 +753,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-7": { input: 15, output: 75 },
-  "claude-opus-4-6": { input: 15, output: 75 },
+  "claude-opus-4-7": { input: 5, output: 25 },
+  "claude-opus-4-6": { input: 5, output: 25 },
   "claude-sonnet-4-6": { input: 3, output: 15 },
   "claude-haiku-4-5-20251001": { input: 1, output: 5 },
   "claude-haiku-4-5": { input: 1, output: 5 }
@@ -715,15 +831,29 @@ function todayUtc() {
 import { readFile as readFile2 } from "fs/promises";
 async function loadBrain(brainPath, scopeTier = "warm") {
   const systemPrompt = await readFile2(brainPath, "utf8");
-  const { domain, capabilityTags } = extractIdentity(systemPrompt);
-  return { brainPath, systemPrompt, capabilityTags, domain, scopeTier };
+  const { domain, capabilityTags, requires, prefers, avoids } = extractIdentity(systemPrompt);
+  return {
+    brainPath,
+    systemPrompt,
+    capabilityTags,
+    domain,
+    scopeTier,
+    requires,
+    prefers,
+    avoids
+  };
 }
 function extractIdentity(brain) {
   const identityBlock = sliceNamedBlock(brain, "identity");
-  if (!identityBlock) return { domain: "unknown", capabilityTags: [] };
+  if (!identityBlock) {
+    return { domain: "unknown", capabilityTags: [], requires: [], prefers: [], avoids: [] };
+  }
   const domain = scalarField(identityBlock, "domain") ?? "unknown";
   const capabilityTags = listField(identityBlock, "capability_tags") ?? [];
-  return { domain, capabilityTags };
+  const requires = listField(identityBlock, "requires") ?? [];
+  const prefers = listField(identityBlock, "prefers") ?? [];
+  const avoids = listField(identityBlock, "avoids") ?? [];
+  return { domain, capabilityTags, requires, prefers, avoids };
 }
 function sliceNamedBlock(src, name) {
   const re = new RegExp(`\\b${name}\\s*:?\\s*\\{`, "g");
@@ -994,6 +1124,181 @@ function applyFilter(events, filter) {
   return result;
 }
 
+// src/capability-router.ts
+import {
+  ANTHROPIC_CAPABILITIES,
+  OPENAI_CAPABILITIES,
+  GEMINI_CAPABILITIES,
+  XAI_CAPABILITIES,
+  OPENROUTER_CAPABILITIES,
+  LOCAL_LLM_CAPABILITIES,
+  BITNET_CAPABILITIES,
+  MOCK_CAPABILITIES
+} from "@holoscript/llm-provider";
+var NoEligibleProviderError = class extends Error {
+  constructor(requires, avoids, considered, excludedByAvoids) {
+    super(
+      `No provider satisfies brain requires=[${requires.join(", ")}] avoids=[${avoids.join(", ")}]. Considered: [${considered.join(", ")}]. Excluded by avoids: [${excludedByAvoids.join(", ")}].`
+    );
+    this.requires = requires;
+    this.avoids = avoids;
+    this.considered = considered;
+    this.excludedByAvoids = excludedByAvoids;
+    this.name = "NoEligibleProviderError";
+  }
+};
+function satisfies(capabilities, key) {
+  const value = capabilities[key];
+  if (typeof value === "boolean") return value;
+  if (typeof value === "number") return value > 0;
+  return false;
+}
+function countMatches(capabilities, keys) {
+  let count = 0;
+  for (const key of keys) {
+    if (satisfies(capabilities, key)) count++;
+  }
+  return count;
+}
+function unsatisfiedKeys(capabilities, keys) {
+  return keys.filter((key) => !satisfies(capabilities, key));
+}
+function pickProvider(opts) {
+  const { brain, envOverride, candidates } = opts;
+  const tieBreaker = opts.tieBreakerOrder ?? candidates.map((c) => c.name);
+  if (candidates.length === 0) {
+    throw new Error("pickProvider: no candidates supplied");
+  }
+  const excludedByAvoids = [];
+  const notAvoided = [];
+  for (const candidate of candidates) {
+    const matchesAvoid = brain.avoids.some((a) => satisfies(candidate.capabilities, a));
+    if (matchesAvoid) {
+      excludedByAvoids.push(candidate.name);
+    } else {
+      notAvoided.push(candidate);
+    }
+  }
+  if (brain.requires.length === 0) {
+    if (envOverride !== void 0) {
+      const envCandidate = candidates.find((c) => c.name === envOverride);
+      const matchedPrefers = envCandidate ? brain.prefers.filter((p) => satisfies(envCandidate.capabilities, p)) : [];
+      return {
+        picked: envOverride,
+        reason: "env-override-no-requirements",
+        unsatisfiedRequires: [],
+        matchedPrefers,
+        excludedByAvoids,
+        alternatives: candidates.filter((c) => c.name !== envOverride).map((c) => c.name)
+      };
+    }
+    const ordered = orderCandidates(notAvoided, tieBreaker);
+    if (ordered.length === 0) {
+      return {
+        picked: candidates[0].name,
+        reason: "open-routing-default",
+        unsatisfiedRequires: [],
+        matchedPrefers: brain.prefers.filter(
+          (p) => satisfies(candidates[0].capabilities, p)
+        ),
+        excludedByAvoids,
+        alternatives: candidates.slice(1).map((c) => c.name)
+      };
+    }
+    return {
+      picked: ordered[0].name,
+      reason: "open-routing-default",
+      unsatisfiedRequires: [],
+      matchedPrefers: brain.prefers.filter((p) => satisfies(ordered[0].capabilities, p)),
+      excludedByAvoids,
+      alternatives: ordered.slice(1).map((c) => c.name)
+    };
+  }
+  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);
+      const unsatisfied = envCandidate ? unsatisfiedKeys(envCandidate.capabilities, brain.requires) : brain.requires.slice();
+      const matchedPrefers = envCandidate ? brain.prefers.filter((p) => satisfies(envCandidate.capabilities, p)) : [];
+      return {
+        picked: envOverride,
+        reason: "env-override-mismatch",
+        unsatisfiedRequires: unsatisfied,
+        matchedPrefers,
+        excludedByAvoids,
+        alternatives: []
+      };
+    }
+    throw new NoEligibleProviderError(
+      brain.requires,
+      brain.avoids,
+      candidates.map((c) => c.name),
+      excludedByAvoids
+    );
+  }
+  const ranked = [...eligible].sort((a, b) => {
+    const aMatches = countMatches(a.capabilities, brain.prefers);
+    const bMatches = countMatches(b.capabilities, brain.prefers);
+    if (aMatches !== bMatches) return bMatches - aMatches;
+    const aIdx = tieBreaker.indexOf(a.name);
+    const bIdx = tieBreaker.indexOf(b.name);
+    const aRank = aIdx === -1 ? Number.MAX_SAFE_INTEGER : aIdx;
+    const bRank = bIdx === -1 ? Number.MAX_SAFE_INTEGER : bIdx;
+    return aRank - bRank;
+  });
+  if (envOverride !== void 0) {
+    const envEligible = ranked.find((c) => c.name === envOverride);
+    if (envEligible) {
+      return {
+        picked: envOverride,
+        reason: "env-override-satisfies",
+        unsatisfiedRequires: [],
+        matchedPrefers: brain.prefers.filter((p) => satisfies(envEligible.capabilities, p)),
+        excludedByAvoids,
+        alternatives: ranked.filter((c) => c.name !== envOverride).map((c) => c.name)
+      };
+    }
+    const envCandidate = candidates.find((c) => c.name === envOverride);
+    const unsatisfied = envCandidate ? unsatisfiedKeys(envCandidate.capabilities, brain.requires) : brain.requires.slice();
+    return {
+      picked: envOverride,
+      reason: "env-override-mismatch",
+      unsatisfiedRequires: unsatisfied,
+      matchedPrefers: envCandidate ? brain.prefers.filter((p) => satisfies(envCandidate.capabilities, p)) : [],
+      excludedByAvoids,
+      alternatives: ranked.map((c) => c.name)
+    };
+  }
+  const top = ranked[0];
+  return {
+    picked: top.name,
+    reason: "capability-best-fit",
+    unsatisfiedRequires: [],
+    matchedPrefers: brain.prefers.filter((p) => satisfies(top.capabilities, p)),
+    excludedByAvoids,
+    alternatives: ranked.slice(1).map((c) => c.name)
+  };
+}
+var BUILT_IN_CANDIDATES = [
+  { name: "anthropic", capabilities: ANTHROPIC_CAPABILITIES },
+  { name: "openai", capabilities: OPENAI_CAPABILITIES },
+  { name: "gemini", capabilities: GEMINI_CAPABILITIES },
+  { name: "xai", capabilities: XAI_CAPABILITIES },
+  { name: "openrouter", capabilities: OPENROUTER_CAPABILITIES },
+  { name: "local-llm", capabilities: LOCAL_LLM_CAPABILITIES },
+  { name: "bitnet", capabilities: BITNET_CAPABILITIES },
+  { name: "mock", capabilities: MOCK_CAPABILITIES }
+];
+function orderCandidates(candidates, tieBreaker) {
+  return [...candidates].sort((a, b) => {
+    const aIdx = tieBreaker.indexOf(a.name);
+    const bIdx = tieBreaker.indexOf(b.name);
+    const aRank = aIdx === -1 ? Number.MAX_SAFE_INTEGER : aIdx;
+    const bRank = bIdx === -1 ? Number.MAX_SAFE_INTEGER : bIdx;
+    return aRank - bRank;
+  });
+}
+
 // src/supervisor.ts
 var Supervisor = class {
   constructor(opts) {
@@ -1036,13 +1341,29 @@ var Supervisor = class {
     return { ...managed.status };
   }
   async bootAgent(spec) {
-    const identity = this.identityFromSpec(spec);
     const brain = await loadBrain(spec.brainPath, spec.scopeTier ?? "warm");
-    const provider = await this.opts.providerFactory(spec, identity);
+    const decision = pickProvider({
+      brain,
+      envOverride: spec.provider,
+      candidates: BUILT_IN_CANDIDATES
+    });
+    const effectiveSpec = decision.picked === spec.provider ? spec : { ...spec, provider: decision.picked };
+    const identity = this.identityFromSpec(effectiveSpec);
+    if (decision.reason === "env-override-mismatch" && this.opts.logger) {
+      this.opts.logger({
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        ev: "capability-router-mismatch",
+        handle: spec.handle,
+        envOverride: spec.provider,
+        unsatisfiedRequires: decision.unsatisfiedRequires,
+        excludedByAvoids: decision.excludedByAvoids
+      });
+    }
+    const provider = await this.opts.providerFactory(effectiveSpec, identity);
     const stateDir = this.opts.stateDir ?? join2(homedir(), ".holoscript-agent", "cost-state");
-    const isFree = spec.provider === "mock" || spec.provider === "local-llm" || spec.provider === "bitnet";
+    const isFree = effectiveSpec.provider === "mock" || effectiveSpec.provider === "local-llm" || effectiveSpec.provider === "bitnet";
     const costGuard = new CostGuard({
-      statePath: join2(stateDir, `${spec.handle}.json`),
+      statePath: join2(stateDir, `${effectiveSpec.handle}.json`),
       dailyBudgetUsd: identity.budgetUsdPerDay,
       pricer: isFree ? () => 0 : void 0
     });
@@ -1052,7 +1373,7 @@ var Supervisor = class {
       teamId: identity.teamId,
       fetchImpl: this.opts.fetchImpl
     });
-    const onTaskExecuted = spec.enableCommitHook ? this.buildCommitHook(spec, identity, mesh) : void 0;
+    const onTaskExecuted = effectiveSpec.enableCommitHook ? this.buildCommitHook(effectiveSpec, identity, mesh) : void 0;
     const runner = new AgentRunner({
       identity,
       brain,
@@ -1061,16 +1382,16 @@ var Supervisor = class {
       mesh,
       onTaskExecuted,
       auditLog: this.auditLog,
-      logger: (ev) => this.log({ agent: spec.handle, ...ev })
+      logger: (ev) => this.log({ agent: effectiveSpec.handle, ...ev })
     });
     const status = {
-      handle: spec.handle,
+      handle: effectiveSpec.handle,
       state: "starting",
       spentUsd: 0,
       remainingUsd: identity.budgetUsdPerDay,
       restarts: 0
     };
-    return { spec, identity, brain, runner, costGuard, status };
+    return { spec: effectiveSpec, identity, brain, runner, costGuard, status };
   }
   buildCommitHook(spec, identity, mesh) {
     const writer = makeCommitHook({