@voybio/ace-swarm 2.4.8 → 2.4.10

package/assets/scripts/ace-hook-dispatch.mjs

@@ -1,6 +1,5 @@
 #!/usr/bin/env node
 
-import { existsSync, readFileSync } from "node:fs";
 import { resolve } from "node:path";
 
 const DESTRUCTIVE_COMMAND_PATTERNS = [
@@ -14,23 +13,8 @@ const DESTRUCTIVE_COMMAND_PATTERNS = [
   /\bmkfs\b/i,
 ];
 
-const ACE_ROOT = ".agents/ACE";
-const ACE_STATE_DIRS = [
-  "agent-state",
-  "global-state",
-  "venture-state",
-  "brand-state",
-  "engineering-state",
-];
-const ACE_CORE_FILES = [
-  "agent-state/TASK.md",
-  "agent-state/STATUS.md",
-  "agent-state/SCOPE.md",
-  "agent-state/EVIDENCE_LOG.md",
-];
-const STORE_MAGIC = "ACEPACK1";
-const STORE_HEADER_SIZE = 32;
-const HOOK_CONTEXT_STORE_KEY = "state/runtime/hook_context";
+// Replaced with the installed module URL when projected into a workspace.
+const ACE_AUTONOMY_MODULE_URL = "__ACE_AUTONOMY_MODULE_URL__";
 
 const PROTECTED_PATH_FRAGMENTS = [
   ".github/hooks/",
@@ -47,15 +31,6 @@ const PROTECTED_PATH_FRAGMENTS = [
   ".vscode\\settings.json",
 ];
 
-const ROLE_TOOL_HINTS = {
-  orchestrator: ["recall_context", "route_task", "create_handoff", "execute_gates", "emit_status_event"],
-  coders: ["read_workspace_file", "safe_edit_file", "run_tests", "git_diff", "execute_gates"],
-  qa: ["read_workspace_file", "run_tests", "execute_gates", "git_diff", "append_vericify_process_post"],
-  docs: ["read_workspace_file", "write_workspace_file", "git_diff", "append_vericify_process_post"],
-  research: ["recall_context", "read_workspace_file", "build_continuity_packet", "append_vericify_process_post"],
-  spec: ["read_workspace_file", "write_workspace_file", "execute_gates", "append_vericify_process_post"],
-};
-
 function readStdin() {
   return new Promise((resolveStdin, reject) => {
     let input = "";
@@ -90,345 +65,17 @@ function resolveWorkspaceRoot(payload) {
   return resolve(cwd);
 }
 
-function mapAceRelativePath(relativePath) {
-  if (!relativePath) return relativePath;
-  const normalized = String(relativePath).replace(/\\/g, "/").replace(/^\.?\//, "");
-  if (!normalized) return normalized;
-  if (normalized === ACE_ROOT || normalized.startsWith(`${ACE_ROOT}/`)) {
-    return normalized;
-  }
-  for (const prefix of ["agent-state", "global-state", "venture-state", "brand-state", "engineering-state"]) {
-    if (normalized === prefix || normalized.startsWith(`${prefix}/`)) {
-      return `${ACE_ROOT}/${normalized}`;
-    }
-  }
-  return normalized;
-}
-
-function resolveAcePath(workspaceRoot, relativePath) {
-  const canonical = resolve(workspaceRoot, mapAceRelativePath(relativePath));
-  const normalized = String(relativePath).replace(/\\/g, "/").replace(/^\.?\//, "");
-  if (normalized && normalized !== mapAceRelativePath(relativePath)) {
-    const legacy = resolve(workspaceRoot, normalized);
-    if (!existsSync(canonical) && existsSync(legacy)) {
-      return legacy;
-    }
-  }
-  return canonical;
-}
-
-function getWorkspaceStorePath(workspaceRoot) {
-  const canonical = resolve(workspaceRoot, "agent-state", "ace-state.ace");
-  if (existsSync(canonical)) return canonical;
-  return resolve(workspaceRoot, ACE_ROOT, "ace-state.ace");
-}
-
-function readStoreUint64(buffer, offset) {
-  return buffer.readUInt32BE(offset) * 2 ** 32 + buffer.readUInt32BE(offset + 4);
-}
-
-function readStoreBlob(workspaceRoot, key) {
-  const storePath = getWorkspaceStorePath(workspaceRoot);
-  if (!existsSync(storePath)) return undefined;
-  try {
-    const file = readFileSync(storePath);
-    if (file.length < STORE_HEADER_SIZE) return undefined;
-    if (file.subarray(0, 8).toString("utf8") !== STORE_MAGIC) return undefined;
-    const indexOffset = readStoreUint64(file, 16);
-    const indexLength = readStoreUint64(file, 24);
-    const index = JSON.parse(file.subarray(indexOffset, indexOffset + indexLength).toString("utf8"));
-    const entry = index?.[key];
-    if (!entry || typeof entry.offset !== "number" || typeof entry.length !== "number") {
-      return undefined;
-    }
-    const start = entry.offset + 4;
-    const end = start + entry.length;
-    return file.subarray(start, end).toString("utf8");
-  } catch {
-    return undefined;
-  }
-}
-
-function readIfPresent(workspaceRoot, relativePath) {
-  const absolute = resolveAcePath(workspaceRoot, relativePath);
-  if (!existsSync(absolute)) {
-    const normalized = String(relativePath).replace(/\\/g, "/").replace(/^\.?\//, "");
-    const logicalPath = normalized.startsWith(`${ACE_ROOT}/`)
-      ? normalized.slice(`${ACE_ROOT}/`.length)
-      : normalized;
-    const rel = logicalPath.startsWith("agent-state/") ? logicalPath.slice("agent-state/".length) : "";
-    const keys = [];
-    if (rel) {
-      keys.push(`state/artifacts/agent-state/${rel}`);
-      keys.push(`knowledge/agent-state/${rel}`);
-      if (rel === "ACE_WORKFLOW.md") {
-        keys.unshift("knowledge/runtime/ACE_WORKFLOW.md");
-        keys.push("knowledge/kernel/ACE_WORKFLOW.md");
-      }
-    }
-    for (const key of keys) {
-      const blob = readStoreBlob(workspaceRoot, key);
-      if (typeof blob === "string") return blob;
-    }
-    return undefined;
-  }
-  try {
-    return readFileSync(absolute, "utf8");
-  } catch {
-    return undefined;
-  }
-}
-
-function oneLine(value) {
-  return String(value ?? "")
-    .replace(/\s+/g, " ")
-    .trim();
-}
-
-function truncate(value, max = 160) {
-  const text = oneLine(value);
-  if (text.length <= max) return text;
-  return `${text.slice(0, Math.max(0, max - 1)).trimEnd()}…`;
-}
-
-function extractTaskObjective(workspaceRoot) {
-  const raw = readIfPresent(workspaceRoot, "agent-state/TASK.md");
-  if (!raw) return undefined;
-  const match = raw.match(/## Objective\s+([\s\S]*?)(?:\n## |\n# |$)/);
-  if (match?.[1]) {
-    return truncate(match[1]);
-  }
-
-  const bodyLine = raw
-    .split(/\r?\n/)
-    .map((line) => line.trim())
-    .find((line) => line && !line.startsWith("#"));
-  if (bodyLine) {
-    return truncate(bodyLine);
-  }
-
-  const heading = raw.match(/^#\s+(.+)$/m)?.[1];
-  return heading ? truncate(heading) : undefined;
-}
-
-function extractStatusLine(workspaceRoot, label) {
-  const raw = readIfPresent(workspaceRoot, "agent-state/STATUS.md");
-  if (!raw) return undefined;
-  const pattern = new RegExp(`^- ${label}:\\s*(.+)$`, "m");
-  const match = raw.match(pattern);
-  return match?.[1] ? truncate(match[1]) : undefined;
-}
-
-function extractScopeReminder(workspaceRoot) {
-  const raw = readIfPresent(workspaceRoot, "agent-state/SCOPE.md");
-  if (!raw) return undefined;
-  const lines = raw
-    .split(/\r?\n/)
-    .map((line) => line.trim())
-    .filter(Boolean)
-    .filter((line) => !line.startsWith("#"));
-  if (lines.length === 0) {
-    return `ACE scope reminder: review ${ACE_ROOT}/agent-state/SCOPE.md before mutating files or state.`;
-  }
-  return `ACE scope reminder: ${truncate(lines.slice(0, 4).join(" "), 220)}`;
-}
-
-function extractRoleHint(payload) {
-  const candidates = [
-    payload.role,
-    payload.agentRole,
-    payload.agent_role,
-    payload.subagentRole,
-    payload.subagent_role,
-    payload?.subagent?.role,
-    payload?.tool_input?.role,
-  ];
-  for (const candidate of candidates) {
-    if (typeof candidate !== "string") continue;
-    const normalized = candidate.trim().toLowerCase().replace(/^agent-/, "");
-    if (normalized) return normalized;
-  }
-  return undefined;
-}
-
-function buildRoleToolHint(role) {
-  const tools = ROLE_TOOL_HINTS[role];
-  if (!tools || tools.length === 0) return undefined;
-  return `Suggested ACE tools for ${role}: ${tools.join(", ")}.`;
-}
-
-/**
- * Try to read the store-backed hook context snapshot.
- * Returns the parsed snapshot or undefined if not present / unreadable.
- */
-function tryReadHookContextSnapshot(workspaceRoot) {
-  const storeRaw = readStoreBlob(workspaceRoot, HOOK_CONTEXT_STORE_KEY);
-  if (typeof storeRaw === "string") {
-    try {
-      const parsed = JSON.parse(storeRaw);
-      if (parsed?.schema_version === 1) return parsed;
-    } catch {
-      // Fall through to legacy file compatibility.
-    }
-  }
-  const snapshotPath = resolve(workspaceRoot, ACE_ROOT, "ace-hook-context.json");
-  if (!existsSync(snapshotPath)) return undefined;
-  try {
-    const raw = readFileSync(snapshotPath, "utf8");
-    const parsed = JSON.parse(raw);
-    if (parsed?.schema_version !== 1) return undefined;
-    return parsed;
-  } catch {
-    return undefined;
-  }
-}
-
-function aceContext(workspaceRoot) {
-  // ── Fast path: store-backed snapshot ────────────────────────────────────
-  const snapshot = tryReadHookContextSnapshot(workspaceRoot);
-  if (snapshot) {
-    const taskObjective = snapshot.task?.content
-      ? truncate(snapshot.task.content.split("\n").find((l) => l.trim() && !l.startsWith("#")) ?? snapshot.task.content)
-      : undefined;
-    const scopeContent = snapshot.scope?.content ?? "";
-    const scopeLines = scopeContent.split(/\r?\n/).map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
-    const scopeReminder = scopeLines.length
-      ? `ACE scope reminder: ${truncate(scopeLines.slice(0, 4).join(" "), 220)}`
-      : undefined;
-    const hasAgentState =
-      existsSync(resolve(workspaceRoot, ACE_ROOT, "agent-state")) ||
-      existsSync(resolve(workspaceRoot, "agent-state", "ace-state.ace"));
-    const hasSkills = existsSync(resolve(workspaceRoot, ACE_ROOT, "skills")) ||
-      existsSync(resolve(workspaceRoot, ".agents", "skills"));
-    return {
-      coreFiles: [],
-      stateDirs: [],
-      taskObjective,
-      currentPhase: undefined,
-      blockers: undefined,
-      hasSkills,
-      hasAgentState,
-      scopeReminder,
-      activeAgents: snapshot.active_agents ?? [],
-    };
-  }
-
-  // ── Legacy path: read individual markdown files ─────────────────────────
-  const stateDirs = ACE_STATE_DIRS
-    .map((relPath) => `${ACE_ROOT}/${relPath}`)
-    .filter((relPath) => existsSync(resolveAcePath(workspaceRoot, relPath)));
-  const coreFiles = ACE_CORE_FILES
-    .map((relPath) => `${ACE_ROOT}/${relPath}`)
-    .filter((relPath) => existsSync(resolveAcePath(workspaceRoot, relPath)));
-
-  const taskObjective = extractTaskObjective(workspaceRoot);
-  const currentPhase = extractStatusLine(workspaceRoot, "Current phase");
-  const blockers = extractStatusLine(workspaceRoot, "Blockers");
-  const hasSkills =
-    existsSync(resolve(workspaceRoot, ".agents", "ACE", "skills")) ||
-    existsSync(resolve(workspaceRoot, ".agents", "skills"));
-  const hasAgentState =
-    existsSync(resolve(workspaceRoot, ".agents", "ACE", "agent-state")) ||
-    existsSync(resolve(workspaceRoot, "agent-state"));
-  const scopeReminder = extractScopeReminder(workspaceRoot);
-
-  return {
-    coreFiles,
-    stateDirs,
-    taskObjective,
-    currentPhase,
-    blockers,
-    hasSkills,
-    hasAgentState,
-    scopeReminder,
-    activeAgents: [],
-  };
-}
-
-function readAutonomyHint(workspaceRoot) {
-  const workflowPath = resolveAcePath(workspaceRoot, "agent-state/ACE_WORKFLOW.md");
-  const defaultHint =
-    "Runtime autonomy defaults are active: orchestrator preflight, context recall.";
-  if (!existsSync(workflowPath)) return defaultHint;
-
-  let raw = "";
+async function currentWorkContext(workspaceRoot, payload) {
+  const moduleUrl = ACE_AUTONOMY_MODULE_URL.startsWith("__")
+    ? new URL("../../dist/ace-autonomy.js", import.meta.url).href
+    : ACE_AUTONOMY_MODULE_URL;
   try {
-    raw = readFileSync(workflowPath, "utf8");
-  } catch {
-    return defaultHint;
-  }
-
-  const signals = [];
-  if (/^\s*orchestrator_preflight:\s*true\s*$/m.test(raw)) {
-    signals.push("orchestrator preflight");
-  }
-  if (/^\s*recall_context:\s*true\s*$/m.test(raw)) {
-    signals.push("context recall");
-  }
-  const reviewMode = raw.match(/^\s*review_mode:\s*["']?([A-Za-z0-9_-]+)["']?\s*$/m)?.[1];
-  if (reviewMode) {
-    signals.push(`review mode ${reviewMode}`);
-  }
-
-  return signals.length > 0
-    ? `Runtime autonomy policy is active in ${ACE_ROOT}/agent-state/ACE_WORKFLOW.md: ${signals.join(", ")}.`
-    : defaultHint;
-}
-
-function buildAceMessage(workspaceRoot, options = {}) {
-  const context = aceContext(workspaceRoot);
-  if (!context.hasAgentState && !context.hasSkills) return "";
-
-  const parts = [];
-  if (context.coreFiles.length > 0) {
-    parts.push(`ACE workspace detected. Ground truth lives in ${context.coreFiles.join(", ")}.`);
-  } else if (context.hasAgentState) {
-    parts.push(`ACE workspace detected. Ground truth lives in ${ACE_ROOT}/agent-state/*.`);
-  }
-  if (context.taskObjective) {
-    parts.push(`Current task: ${context.taskObjective}.`);
-  }
-  if (context.currentPhase) {
-    parts.push(`Current phase: ${context.currentPhase}.`);
-  }
-  if (context.blockers) {
-    parts.push(`Blockers: ${context.blockers}.`);
-  }
-  if (context.stateDirs.length > 0) {
-    parts.push(
-      `Persist durable artifacts under ${context.stateDirs.map((dir) => `${dir}/`).join(", ")} rather than editor session caches such as workspaceStorage/.../chat-session-resources/.`
-    );
-  }
-  parts.push(
-    "Before major edits, read task, scope, and status artifacts rather than relying on chat history."
-  );
-  if (context.scopeReminder) {
-    parts.push(context.scopeReminder);
-  }
-  if (context.hasSkills) {
-    parts.push(`Workspace skills are available under ${ACE_ROOT}/skills/.`);
-  }
-  const autonomyHint = readAutonomyHint(workspaceRoot);
-  if (autonomyHint) {
-    parts.push(autonomyHint);
-  }
-  const roleHint = extractRoleHint(options.payload ?? {});
-  if (roleHint && (options.eventName === "SubagentStart" || options.eventName === "UserPromptSubmit")) {
-    parts.push(`Assigned ACE role: ${roleHint}.`);
-    const toolHint = buildRoleToolHint(roleHint);
-    if (toolHint) {
-      parts.push(toolHint);
-    }
-  }
-  const promptText =
-    typeof options.payload?.prompt === "string" ? options.payload.prompt.trim() : "";
-  if (promptText && options.eventName === "UserPromptSubmit") {
-    parts.push(`Latest prompt: ${truncate(promptText, 180)}.`);
+    const { resolveCurrentWork, formatCurrentWork } = await import(moduleUrl);
+    const work = resolveCurrentWork({ workspaceRoot, goal_id: payload.goal_id, agent: payload.agent_id });
+    return formatCurrentWork(work, "block");
+  } catch (error) {
+    return `ACE current work unavailable: ${error.message}. Use recall_context to recover it.`;
   }
-  parts.push(
-    `ACE hook policy protects ${ACE_ROOT}/.github/hooks, ${ACE_ROOT}/.vscode/settings.json, and ${ACE_ROOT}/scripts/ace/*hook-dispatch.mjs from silent self-modification.`
-  );
-  return parts.join(" ");
 }
 
 function isCommandTool(toolName) {
@@ -495,62 +142,20 @@ function resolvePreToolUse(payload, workspaceRoot) {
     };
   }
 
-  const message = buildAceMessage(workspaceRoot, {
-    payload,
-    eventName: "PreToolUse",
-  });
-  if (isMutationTool(toolName) && message) {
-    return {
-      continue: true,
-      hookSpecificOutput: {
-        hookEventName: "PreToolUse",
-        permissionDecision: "allow",
-        additionalContext: `${message} Confirm the target stays within scope before mutating files or state, and persist evidence after the change.`,
-      },
-    };
-  }
-
   return { continue: true };
 }
 
-function resolvePostToolUse(payload, workspaceRoot) {
-  const toolName = toLowerText(payload.tool_name);
-  if (!isMutationTool(toolName)) {
-    return { continue: true };
-  }
-
-  const message = buildAceMessage(workspaceRoot, {
-    payload,
-    eventName: "PostToolUse",
-  });
-  return {
-    continue: true,
-    hookSpecificOutput: {
-      hookEventName: "PostToolUse",
-      additionalContext: message
-        ? `${message} If project files or state changed, reconcile evidence, run the smallest relevant verification, and call execute_gates before concluding.`
-        : "If project files or state changed, run the smallest relevant verification and call execute_gates before concluding.",
-    },
-  };
-}
-
-function resolveSessionContext(payload, workspaceRoot, eventName) {
-  const message = buildAceMessage(workspaceRoot, {
-    payload,
-    eventName,
-  });
-  if (!message) return { continue: true };
-
+async function resolveSessionContext(payload, workspaceRoot, eventName) {
   return {
     continue: true,
     hookSpecificOutput: {
       hookEventName: eventName,
-      additionalContext: message,
+      additionalContext: await currentWorkContext(workspaceRoot, payload),
     },
   };
 }
 
-function resolveHook(payload) {
+async function resolveHook(payload) {
   const eventName = toLowerText(payload.hookEventName);
   const workspaceRoot = resolveWorkspaceRoot(payload);
 
@@ -571,7 +176,7 @@ function resolveHook(payload) {
   }
 
   if (eventName === "posttooluse") {
-    return resolvePostToolUse(payload, workspaceRoot);
+    return { continue: true };
   }
 
   if (eventName === "precompact") {
@@ -589,7 +194,7 @@ async function main() {
   try {
     const raw = await readStdin();
     const payload = raw.trim() ? JSON.parse(raw) : {};
-    writeJson(resolveHook(payload));
+    writeJson(await resolveHook(payload));
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     writeJson({

package/assets/tasks/SWARM_HANDOFF.example_ui_to_coders.json

@@ -27,8 +27,7 @@
     "Behavioral tests pass for new flow and edge cases"
   ],
   "deliverables": [
-    "engineering-state/src/onboarding/",
-    "engineering-state/TEST_LOG.md"
+    "engineering-state/src/onboarding/"
   ],
   "verification": {
     "required_evidence": [

package/assets/vendor/README.md

@@ -0,0 +1,9 @@
+The Vericify native reader is vendored unchanged from the maintained Vericify integration at the commit recorded in `vericify-reader.provenance.json`, which also pins its SHA-256. ACE loads this package asset at runtime; no sibling checkout, source import, store parser, or writable Vericify store is required.
+
+ACE uses only the client's `window(...)` query: one bounded native `adapter window` invocation per attempt, inside the configured total deadline. ACE does not traverse `info`/`page` results or join records from different snapshots. The owner returns pending, expired or complete state with an acknowledged `next_after` position; ACE encodes that position in its `vcn1:` cursor and does not walk further windows automatically.
+
+Native failures arrive as typed `NativeReadError` codes (`stale_snapshot`, `missing_history`, `incompatible_protocol`, `capacity`, `timeout`, `invalid_query`, `identity_mismatch`, `expired`, `unavailable`) with an owner-set `retryable` flag. Raw native output and process errors are discarded. ACE retries only owner-marked retryable errors and keeps the codes distinct in its sanitized reasons.
+
+The native window independently verifies the supplied workspace root against the recorded workspace within its pinned read lifetime. ACE also canonicalizes the configured `workspace_root` and checks the returned `workspace_id`, plus the optional incarnation pin.
+
+License: the Vericify owner authorized distribution of `vericify-reader.mjs` alone, inside this package, under the package's Apache-2.0 [`LICENSE`](../../LICENSE) (recorded in the provenance file, 2026-10-21). That authorization covers no other Vericify source, binary or package.