ace-swarm 2.2.0 → 2.3.0

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

@@ -0,0 +1,447 @@
+#!/usr/bin/env node
+
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+const DESTRUCTIVE_COMMAND_PATTERNS = [
+  /\brm\s+-rf\b/i,
+  /\bgit\s+reset\s+--hard\b/i,
+  /\bgit\s+checkout\s+--\b/i,
+  /\bgit\s+clean\s+-fdx\b/i,
+  /\bdel\s+\/s\s+\/q\b/i,
+  /\bdrop\s+table\b/i,
+  /\btruncate\s+table\b/i,
+  /\bmkfs\b/i,
+];
+
+const PROTECTED_PATH_FRAGMENTS = [
+  ".github/hooks/",
+  ".github\\hooks\\",
+  "scripts/ace/ace-hook-dispatch.mjs",
+  "scripts\\ace\\ace-hook-dispatch.mjs",
+  "scripts/ace/copilot-hook-dispatch.mjs",
+  "scripts\\ace\\copilot-hook-dispatch.mjs",
+  ".vscode/settings.json",
+  ".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 = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      input += chunk;
+    });
+    process.stdin.on("end", () => resolveStdin(input));
+    process.stdin.on("error", reject);
+  });
+}
+
+function writeJson(payload) {
+  process.stdout.write(JSON.stringify(payload));
+}
+
+function toLowerText(value) {
+  return typeof value === "string" ? value.trim().toLowerCase() : "";
+}
+
+function safeJson(value) {
+  try {
+    return JSON.stringify(value ?? {});
+  } catch {
+    return "";
+  }
+}
+
+function resolveWorkspaceRoot(payload) {
+  const cwd =
+    typeof payload.cwd === "string" && payload.cwd.trim() ? payload.cwd.trim() : process.cwd();
+  return resolve(cwd);
+}
+
+function readIfPresent(workspaceRoot, relativePath) {
+  const absolute = resolve(workspaceRoot, relativePath);
+  if (!existsSync(absolute)) 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 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(", ")}.`;
+}
+
+function aceContext(workspaceRoot) {
+  const stateDirs = [
+    "agent-state",
+    "global-state",
+    "venture-state",
+    "brand-state",
+    "engineering-state",
+  ].filter((relPath) => existsSync(resolve(workspaceRoot, relPath)));
+  const coreFiles = [
+    "agent-state/TASK.md",
+    "agent-state/STATUS.md",
+    "agent-state/SCOPE.md",
+    "agent-state/EVIDENCE_LOG.md",
+  ].filter((relPath) => existsSync(resolve(workspaceRoot, relPath)));
+
+  const taskObjective = extractTaskObjective(workspaceRoot);
+  const currentPhase = extractStatusLine(workspaceRoot, "Current phase");
+  const blockers = extractStatusLine(workspaceRoot, "Blockers");
+  const hasSkills = existsSync(resolve(workspaceRoot, ".agents", "skills"));
+  const hasAgentState = existsSync(resolve(workspaceRoot, "agent-state"));
+  const scopeReminder = extractScopeReminder(workspaceRoot);
+
+  return {
+    coreFiles,
+    stateDirs,
+    taskObjective,
+    currentPhase,
+    blockers,
+    hasSkills,
+    hasAgentState,
+    scopeReminder,
+  };
+}
+
+function readAutonomyHint(workspaceRoot) {
+  const workflowPath = resolve(workspaceRoot, "agent-state", "ACE_WORKFLOW.md");
+  const defaultHint =
+    "Runtime autonomy defaults are active: orchestrator preflight, context recall.";
+  if (!existsSync(workflowPath)) return defaultHint;
+
+  let raw = "";
+  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 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 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 .agents/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)}.`);
+  }
+  parts.push(
+    "ACE hook policy protects .github/hooks, .vscode/settings.json, and scripts/ace/*hook-dispatch.mjs from silent self-modification."
+  );
+  return parts.join(" ");
+}
+
+function isCommandTool(toolName) {
+  return ["terminal", "shell", "bash", "command", "execute", "run"].some((token) =>
+    toolName.includes(token)
+  );
+}
+
+function isMutationTool(toolName) {
+  return [
+    "edit",
+    "write",
+    "create",
+    "replace",
+    "delete",
+    "rename",
+    "move",
+    "file",
+    "commit",
+    "dispatch",
+    "update",
+    "append",
+  ].some((token) => toolName.includes(token));
+}
+
+function containsProtectedPath(text) {
+  const normalized = toLowerText(text);
+  return PROTECTED_PATH_FRAGMENTS.some((fragment) => normalized.includes(fragment.toLowerCase()));
+}
+
+function containsDestructiveCommand(text) {
+  return DESTRUCTIVE_COMMAND_PATTERNS.some((pattern) => pattern.test(text));
+}
+
+function resolvePreToolUse(payload, workspaceRoot) {
+  const toolName = toLowerText(payload.tool_name);
+  const serializedInput = safeJson(payload.tool_input);
+
+  if (isCommandTool(toolName) && containsDestructiveCommand(serializedInput)) {
+    return {
+      continue: true,
+      hookSpecificOutput: {
+        hookEventName: "PreToolUse",
+        permissionDecision: "deny",
+        permissionDecisionReason:
+          "Blocked by ACE hook policy: destructive shell command detected.",
+        additionalContext:
+          "Use a non-destructive alternative or ask for explicit confirmation before destructive terminal actions.",
+      },
+    };
+  }
+
+  if (isMutationTool(toolName) && containsProtectedPath(serializedInput)) {
+    return {
+      continue: true,
+      hookSpecificOutput: {
+        hookEventName: "PreToolUse",
+        permissionDecision: "ask",
+        permissionDecisionReason:
+          "Editing hook or control-plane files requires confirmation.",
+        additionalContext:
+          "This workspace treats hook files, dispatcher scripts, and VS Code settings as protected control-plane artifacts.",
+      },
+    };
+  }
+
+  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 };
+
+  return {
+    continue: true,
+    hookSpecificOutput: {
+      hookEventName: eventName,
+      additionalContext: message,
+    },
+  };
+}
+
+function resolveHook(payload) {
+  const eventName = toLowerText(payload.hookEventName);
+  const workspaceRoot = resolveWorkspaceRoot(payload);
+
+  if (eventName === "sessionstart") {
+    return resolveSessionContext(payload, workspaceRoot, "SessionStart");
+  }
+
+  if (eventName === "subagentstart") {
+    return resolveSessionContext(payload, workspaceRoot, "SubagentStart");
+  }
+
+  if (eventName === "userpromptsubmit") {
+    return resolveSessionContext(payload, workspaceRoot, "UserPromptSubmit");
+  }
+
+  if (eventName === "pretooluse") {
+    return resolvePreToolUse(payload, workspaceRoot);
+  }
+
+  if (eventName === "posttooluse") {
+    return resolvePostToolUse(payload, workspaceRoot);
+  }
+
+  if (eventName === "precompact") {
+    return resolveSessionContext(payload, workspaceRoot, "PreCompact");
+  }
+
+  if (eventName === "subagentstop" || eventName === "stop") {
+    return { continue: true };
+  }
+
+  return { continue: true };
+}
+
+async function main() {
+  try {
+    const raw = await readStdin();
+    const payload = raw.trim() ? JSON.parse(raw) : {};
+    writeJson(resolveHook(payload));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    writeJson({
+      continue: true,
+      systemMessage: `ACE hook warning: ${message}`,
+    });
+  }
+}
+
+main();