@holoscript/holoscript-agent 2.0.2 → 2.0.4

package/dist/supervisor.js

@@ -109,6 +109,37 @@ var HolomeshClient = class {
   async delegateTask(taskId, toAgentId) {
     return this.req("PATCH", `/team/${this.teamId}/board/${taskId}`, await this.signBody({ action: "delegate", toAgentId }));
   }
+  // ── Cognitive-verb knowledge surface (Phase 2.2 — recall / rag_query) ────────
+  /**
+   * Query the TEAM knowledge base (the `rag_query` cognitive verb). Bearer-only
+   * GET; `q` is the server-side search filter. Returns [] on any failure so a
+   * retrieval miss never breaks a tick.
+   */
+  async queryTeamKnowledge(query, limit = 5) {
+    const qs = new URLSearchParams({ q: query, limit: String(limit) }).toString();
+    try {
+      const data = await this.req(
+        "GET",
+        `/team/${this.teamId}/knowledge?${qs}`
+      );
+      return data.entries ?? [];
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Query this agent's PRIVATE workspace knowledge (the `recall` cognitive verb).
+   * The endpoint has no server-side search param, so the caller filters by query
+   * client-side. Returns [] on any failure.
+   */
+  async queryPrivateKnowledge() {
+    try {
+      const data = await this.req("GET", `/knowledge/private`);
+      return data.entries ?? [];
+    } catch {
+      return [];
+    }
+  }
   async req(method, path, body) {
     const url = `${this.apiBase}${path}`;
     const res = await this.fetchImpl(url, {
@@ -569,6 +600,109 @@ function errResult(id, message) {
   return { type: "tool_result", tool_use_id: id, content: message, is_error: true };
 }
 
+// src/cognitive-verbs.ts
+var DEFAULT_LIMIT = 5;
+var MAX_ENTRY_CHARS = 320;
+var MAX_INJECTED_CHARS = 2400;
+function strField(config, ...keys) {
+  for (const k of keys) {
+    const v = config[k];
+    if (typeof v === "string" && v.trim()) return v.trim();
+  }
+  return "";
+}
+function numField(config, key, fallback) {
+  const v = config[key];
+  return typeof v === "number" && Number.isFinite(v) ? v : fallback;
+}
+function formatEntries(entries) {
+  let out = "";
+  for (const e of entries) {
+    const line = `- ${(e.content ?? "").replace(/\s+/g, " ").trim().slice(0, MAX_ENTRY_CHARS)}`;
+    if (out.length + line.length > MAX_INJECTED_CHARS) break;
+    out += (out ? "\n" : "") + line;
+  }
+  return out;
+}
+async function augmentWithOnTaskCognition(deps) {
+  let content = deps.systemPrompt;
+  if (!deps.onTaskActions || deps.onTaskActions.length === 0) return content;
+  for (const action of deps.onTaskActions) {
+    try {
+      switch (action.verb) {
+        case "llm_call": {
+          const prompt = strField(action.config, "prompt");
+          if (prompt) {
+            content += `
+
+[Brain on_task directive]
+${prompt}`;
+            deps.log({ ev: "on-task-llm-call", taskId: deps.task.id, promptLen: prompt.length });
+          }
+          break;
+        }
+        case "rag_query": {
+          const query = strField(action.config, "query", "q") || deps.task.title;
+          const limit = numField(action.config, "limit", DEFAULT_LIMIT);
+          const entries = await deps.queryTeamKnowledge(query, limit);
+          if (entries.length > 0) {
+            content += `
+
+[Retrieved knowledge for "${query}"]
+${formatEntries(entries)}`;
+          }
+          deps.log({ ev: "on-task-rag-query", taskId: deps.task.id, query, retrieved: entries.length });
+          break;
+        }
+        case "recall": {
+          const query = strField(action.config, "query", "q");
+          const limit = numField(action.config, "limit", DEFAULT_LIMIT);
+          const all = await deps.queryPrivateKnowledge();
+          const needle = query.toLowerCase();
+          const matched = (needle ? all.filter((e) => `${e.id ?? ""} ${e.content ?? ""}`.toLowerCase().includes(needle)) : all).slice(0, limit);
+          if (matched.length > 0) {
+            content += `
+
+[Recalled memory${query ? ` for "${query}"` : ""}]
+${formatEntries(matched)}`;
+          }
+          deps.log({ ev: "on-task-recall", taskId: deps.task.id, query, recalled: matched.length });
+          break;
+        }
+        case "plan": {
+          if (!deps.plan) break;
+          const goal = strField(action.config, "goal", "prompt", "of") || deps.task.title;
+          const planText = await deps.plan(
+            `Produce a short numbered plan (max 6 steps) to accomplish this task. Be concrete and specific to the goal; do not execute it.
+
+Goal: ${goal}`
+          );
+          const trimmed = planText.trim().slice(0, MAX_INJECTED_CHARS);
+          if (trimmed) {
+            content += `
+
+[Plan]
+${trimmed}`;
+            deps.log({ ev: "on-task-plan", taskId: deps.task.id, planLen: trimmed.length });
+          }
+          break;
+        }
+        // `reflect` is handled post-artifact in runner.ts, not here.
+        default:
+          break;
+      }
+    } catch (err) {
+      deps.log({
+        ev: "on-task-verb-error",
+        taskId: deps.task.id,
+        verb: action.verb,
+        message: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  return content;
+}
+
 // src/runner.ts
 var RUNTIME_VERSION = "1.0.0";
 var AgentRunner = class {
@@ -651,8 +785,23 @@ var AgentRunner = class {
     log({ ev: "claim", taskId: target.id, title: target.title });
     await mesh.claim(target.id);
     const start = Date.now();
+    const systemContent = await augmentWithOnTaskCognition({
+      systemPrompt: brain.systemPrompt,
+      onTaskActions: brain.onTaskActions ?? [],
+      task: { id: target.id, title: target.title },
+      queryTeamKnowledge: (q, limit) => mesh.queryTeamKnowledge(q, limit),
+      queryPrivateKnowledge: () => mesh.queryPrivateKnowledge(),
+      plan: async (prompt) => {
+        const resp = await provider.complete(
+          { messages: [{ role: "user", content: prompt }], maxTokens: 512, temperature: 0.3 },
+          identity.llmModel
+        );
+        return resp.content;
+      },
+      log
+    });
     const messages = [
-      { role: "system", content: brain.systemPrompt },
+      { role: "system", content: systemContent },
       { role: "user", content: buildTaskPrompt(target) }
     ];
     let aggUsage = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
@@ -1092,7 +1241,8 @@ async function loadBrain(brainPath, scopeTier = "warm") {
     requires,
     prefers,
     avoids,
-    reflect: extractReflect(raw)
+    reflect: extractReflect(raw),
+    onTaskActions: extractOnTaskActions(raw)
   };
 }
 function extractReflect(brain) {
@@ -1127,6 +1277,53 @@ function extractIdentity(brain) {
   const avoids = listField(identityBlock, "avoids") ?? [];
   return { domain, capabilityTags, requires, prefers, avoids };
 }
+function extractOnTaskActions(brain) {
+  const block = sliceNamedBlock(brain, "on_task");
+  if (!block) return [];
+  const VERBS = ["recall", "rag_query", "llm_call", "plan", "reflect"];
+  const entries = [];
+  for (const verb of VERBS) {
+    const re = new RegExp(`\\b${verb}\\s*\\{`, "g");
+    let m;
+    while ((m = re.exec(block)) !== null) {
+      const start = m.index + m[0].length;
+      let depth = 1;
+      let end = -1;
+      for (let i = start; i < block.length; i++) {
+        if (block[i] === "{") depth++;
+        else if (block[i] === "}") {
+          depth--;
+          if (depth === 0) {
+            end = i;
+            break;
+          }
+        }
+      }
+      if (end < 0) continue;
+      entries.push({ verb, config: parseKVBlock(block.slice(start, end)), _pos: m.index });
+    }
+  }
+  return entries.sort((a, b) => a._pos - b._pos).map(({ _pos: _ignored, ...rest }) => rest);
+}
+function parseKVBlock(block) {
+  const out = {};
+  const strRe = /\b(\w+)\s*:\s*"([^"]*)"/g;
+  let m;
+  while ((m = strRe.exec(block)) !== null) out[m[1]] = m[2];
+  const arrRe = /\b(\w+)\s*:\s*\[([^\]]*)\]/g;
+  while ((m = arrRe.exec(block)) !== null) {
+    out[m[1]] = m[2].split(",").map((s) => s.trim().replace(/^["']|["']$/g, "")).filter((s) => s.length > 0);
+  }
+  const boolRe = /\b(\w+)\s*:\s*(true|false)\b/g;
+  while ((m = boolRe.exec(block)) !== null) {
+    if (!(m[1] in out)) out[m[1]] = m[2] === "true";
+  }
+  const numRe = /\b(\w+)\s*:\s*(-?\d+(?:\.\d+)?)\b/g;
+  while ((m = numRe.exec(block)) !== null) {
+    if (!(m[1] in out)) out[m[1]] = parseFloat(m[2]);
+  }
+  return out;
+}
 function sliceNamedBlock(src, name) {
   const re = new RegExp(`\\b${name}\\s*:?\\s*\\{`, "g");
   const match = re.exec(src);