@voybio/ace-swarm 0.1.0

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

@@ -0,0 +1,538 @@
+#!/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 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 PROTECTED_PATH_FRAGMENTS = [
+  ".github/hooks/",
+  ".github\\hooks\\",
+  ".agents/ACE/scripts/ace/ace-hook-dispatch.mjs",
+  ".agents\\ACE\\scripts\\ace\\ace-hook-dispatch.mjs",
+  ".agents/ACE/scripts/ace/copilot-hook-dispatch.mjs",
+  ".agents\\ACE\\scripts\\ace\\copilot-hook-dispatch.mjs",
+  "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 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 readIfPresent(workspaceRoot, relativePath) {
+  const absolute = resolveAcePath(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 ${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-materialized hook context snapshot.
+ * Returns the parsed snapshot or undefined if not present / unreadable.
+ * When present this is the single authoritative source; the dispatcher
+ * never needs to open the .zarr store directly.
+ */
+function tryReadHookContextSnapshot(workspaceRoot) {
+  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-materialized 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"));
+    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 = "";
+  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)}.`);
+  }
+  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) {
+  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();

package/assets/scripts/bootstrap-workspace.sh

@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"
+LEGACY_ROOT="$(cd -- "${SCRIPT_DIR}/../.." && pwd)"
+CANONICAL_ROOT="$(cd -- "${SCRIPT_DIR}/../../../.." && pwd)"
+if [ -d "${CANONICAL_ROOT}/.agents/ACE" ] || [ ! -d "${LEGACY_ROOT}/.agents/ACE" ]; then
+  WORKSPACE_ROOT="${CANONICAL_ROOT}"
+else
+  WORKSPACE_ROOT="${LEGACY_ROOT}"
+fi
+PROJECT_NAME="${1:-ACE Project}"
+
+export ACE_WORKSPACE_ROOT="${WORKSPACE_ROOT}"
+cd "${WORKSPACE_ROOT}"
+
+if command -v ace >/dev/null 2>&1; then
+  ace init --project "$PROJECT_NAME"
+  exit 0
+fi
+
+if command -v ace-swarm >/dev/null 2>&1; then
+  ace-swarm init --project "$PROJECT_NAME"
+  exit 0
+fi
+
+npx -y ace-swarm init --project "$PROJECT_NAME"

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

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+import "./ace-hook-dispatch.mjs";

package/assets/scripts/eval-harness.sh

@@ -0,0 +1,68 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT="${ACE_WORKSPACE_ROOT:-$PWD}"
+STAMP="$(date -u +"%Y-%m-%dT%H:%M:%SZ")"
+OUT="$ROOT/.agents/ACE/agent-state/EVAL_REPORT.md"
+
+mkdir -p "$ROOT/agent-state"
+
+pass_count=0
+fail_count=0
+
+run_check() {
+  local name="$1"
+  shift
+  if "$@" >/tmp/ace_eval_last.out 2>/tmp/ace_eval_last.err; then
+    echo "- PASS: $name" >>"$OUT"
+    pass_count=$((pass_count + 1))
+  else
+    echo "- FAIL: $name" >>"$OUT"
+    echo "  - stderr: $(tr '\n' ' ' </tmp/ace_eval_last.err | sed 's/  */ /g')" >>"$OUT"
+    fail_count=$((fail_count + 1))
+  fi
+}
+
+{
+  echo "# EVAL_REPORT"
+  echo
+  echo "Generated: $STAMP"
+  echo
+  echo "## Checks"
+} >"$OUT"
+
+# Resolve ace-swarm runtime: prefer local monorepo, fall back to npx-installed package
+if [ -f "$ROOT/ace-mcp-server/dist/cli.js" ]; then
+  ACE_CLI="node $ROOT/ace-mcp-server/dist/cli.js"
+  ACE_IMPORT_PREFIX="./ace-mcp-server/dist"
+elif command -v ace >/dev/null 2>&1; then
+  ACE_CLI="ace"
+  ACE_PKG_DIR="$(node -e "console.log(require.resolve('ace-swarm/package.json').replace('/package.json',''))")"
+  ACE_IMPORT_PREFIX="$ACE_PKG_DIR/dist"
+else
+  ACE_CLI="npx --yes ace-swarm"
+  ACE_PKG_DIR="$(npx --yes ace-swarm paths 2>/dev/null | grep PACKAGE_ROOT | cut -d= -f2)"
+  ACE_IMPORT_PREFIX="$ACE_PKG_DIR/dist"
+fi
+
+run_check "cli_paths" $ACE_CLI paths
+run_check "schema_validation_smoke" node --input-type=module -e "import('${ACE_IMPORT_PREFIX}/schemas.js').then((m)=>{ const ok=m.validateStatusEventPayload({schema_version:'1.0.0',event_id:'evt-12345',trace_id:'trace-12345',timestamp:new Date().toISOString(),source_module:'capability-ops',event_type:'SMOKE',status:'pass',payload:{summary:'smoke'}}); if(!ok.ok) throw new Error(ok.errors.join('; ')); })"
+run_check "index_delta_smoke" node --input-type=module -e "import('${ACE_IMPORT_PREFIX}/index-store.js').then((m)=>{ const r=m.scanWorkspaceDelta({path:'.',depth:2,max_files:500,file_entry_cap:0}); if(typeof r.snapshot.file_count !== 'number') throw new Error('invalid file_count'); if(!r.fingerprint_path) throw new Error('missing fingerprint path'); })"
+
+{
+  echo
+  echo "## Summary"
+  echo "- Passed: $pass_count"
+  echo "- Failed: $fail_count"
+  echo
+  if [ "$fail_count" -eq 0 ]; then
+    echo "Verdict: PASS"
+  else
+    echo "Verdict: FAIL"
+  fi
+} >>"$OUT"
+
+if [ "$fail_count" -eq 0 ]; then
+  exit 0
+fi
+exit 1