@holoscript/holoscript-agent 2.0.3 → 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,26 +785,21 @@ var AgentRunner = class {
     log({ ev: "claim", taskId: target.id, title: target.title });
     await mesh.claim(target.id);
     const start = Date.now();
-    let systemContent = brain.systemPrompt;
-    if (brain.onTaskActions && brain.onTaskActions.length > 0) {
-      const llmCallAction = brain.onTaskActions.find((a) => a.verb === "llm_call");
-      const deferredVerbs = brain.onTaskActions.filter((a) => a.verb === "recall" || a.verb === "rag_query" || a.verb === "plan").map((a) => a.verb);
-      if (deferredVerbs.length > 0) {
-        log({
-          ev: "on-task-deferred",
-          taskId: target.id,
-          verbs: deferredVerbs,
-          note: "trait-backed dispatch deferred to Phase 2.2 (idea-seeds.md)"
-        });
-      }
-      if (llmCallAction && typeof llmCallAction.config.prompt === "string" && llmCallAction.config.prompt.length > 0) {
-        systemContent = `${brain.systemPrompt}
-
-[Brain on_task directive]
-${llmCallAction.config.prompt}`;
-        log({ ev: "on-task-llm-call", taskId: target.id, promptLen: llmCallAction.config.prompt.length });
-      }
-    }
+    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: systemContent },
       { role: "user", content: buildTaskPrompt(target) }