@voybio/ace-swarm 0.1.0

package/dist/ace-context.js

@@ -0,0 +1,240 @@
+import { buildAceContinuityPacket, buildAceRecallContext, formatAceContinuityPacketMarkdown, formatAceRecallMarkdown, normalizeAutonomyPolicy, normalizeContinuityPolicy, } from "./ace-autonomy.js";
+import { listAceInternalToolCatalog, } from "./ace-internal-tools.js";
+import { ALL_AGENTS, readAgentInstructions } from "./helpers.js";
+import { readRuntimeProfileState, renderRuntimePrompt } from "./runtime-profile.js";
+const ROLE_TOOL_DEFAULTS = {
+    orchestrator: [
+        "recall_context",
+        "route_task",
+        "run_local_model",
+        "get_vericify_context",
+        "get_vericify_delta",
+        "create_handoff",
+        "ack_handoff",
+        "enqueue_job",
+        "dispatch_jobs",
+        "list_jobs",
+        "execute_gates",
+        "context_snapshot",
+        "append_vericify_process_post",
+        "emit_status_event",
+    ],
+    coders: [
+        "read_workspace_file",
+        "write_workspace_file",
+        "safe_edit_file",
+        "run_tests",
+        "git_diff",
+        "git_status",
+        "execute_gates",
+        "append_vericify_process_post",
+    ],
+    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 resolveRoleInstructions(role) {
+    const normalized = role.trim().toLowerCase().replace(/^agent-/, "");
+    if (ALL_AGENTS.includes(normalized)) {
+        return readAgentInstructions(normalized);
+    }
+    return `No ACE role instructions found for '${role}'. Use route_task if role selection is uncertain.`;
+}
+export function renderAceRecallPromptBlock(recall, includeSlices = true) {
+    if (!recall)
+        return "";
+    const slices = includeSlices
+        ? recall.state_slices
+            .filter((entry) => entry.present)
+            .slice(0, 6)
+            .flatMap((entry) => [`### ${entry.path}`, "```text", entry.excerpt, "```"])
+        : [];
+    return [formatAceRecallMarkdown(recall), ...(slices.length > 0 ? ["", ...slices] : [])].join("\n");
+}
+export function renderAceSnapshotPromptBlock(recall) {
+    if (!recall?.snapshot)
+        return "";
+    return [
+        `Name: ${recall.snapshot.name}`,
+        `Timestamp: ${recall.snapshot.timestamp}`,
+        `Summary: ${recall.snapshot.summary}`,
+        "```json",
+        recall.snapshot.content,
+        "```",
+    ].join("\n");
+}
+export function renderAceContinuityPromptBlock(packet) {
+    return packet ? formatAceContinuityPacketMarkdown(packet) : "";
+}
+function keywordScore(task, tool) {
+    const haystack = `${tool.name} ${tool.description} ${tool.input_keys.join(" ")}`.toLowerCase();
+    return task
+        .toLowerCase()
+        .split(/[^a-z0-9_]+/)
+        .filter((token) => token.length > 2)
+        .reduce((score, token) => (haystack.includes(token) ? score + 1 : score), 0);
+}
+function selectToolCount(tier) {
+    if (tier === "brief")
+        return 5;
+    if (tier === "compressed")
+        return 12;
+    return 20;
+}
+function scopeTools(role, task, tier, explicitTools) {
+    const catalog = listAceInternalToolCatalog();
+    if (explicitTools && explicitTools.length > 0) {
+        const explicitSet = new Set(explicitTools);
+        return catalog.filter((tool) => explicitSet.has(tool.name));
+    }
+    const roleDefaults = new Set(ROLE_TOOL_DEFAULTS[role.trim().toLowerCase()] ?? []);
+    const ranked = catalog
+        .map((tool) => ({
+        tool,
+        score: (roleDefaults.has(tool.name) ? 5 : 0) + keywordScore(task, tool),
+    }))
+        .sort((left, right) => right.score - left.score || left.tool.name.localeCompare(right.tool.name))
+        .slice(0, selectToolCount(tier))
+        .map((entry) => entry.tool);
+    if (ranked.length > 0 && ranked.some((tool) => roleDefaults.has(tool.name))) {
+        return ranked;
+    }
+    return catalog.slice(0, selectToolCount(tier));
+}
+function renderToolCatalogMarkdown(tools, tier) {
+    const includeInputs = tier !== "brief";
+    return tools
+        .map((tool) => {
+        const parts = [`- \`${tool.name}\` — ${tool.description || "ACE MCP tool"}`];
+        if (includeInputs && tool.input_keys.length > 0) {
+            parts.push(`  - input keys: ${tool.input_keys.join(", ")}`);
+        }
+        return parts.join("\n");
+    })
+        .join("\n");
+}
+function selectPlanningCatalogCount(tier) {
+    if (tier === "brief")
+        return 24;
+    if (tier === "compressed")
+        return 40;
+    return Number.POSITIVE_INFINITY;
+}
+function buildPlanningCatalog(role, task, tier) {
+    const roleDefaults = new Set(ROLE_TOOL_DEFAULTS[role.trim().toLowerCase()] ?? []);
+    const ranked = listAceInternalToolCatalog().map((tool) => ({
+        tool,
+        score: (roleDefaults.has(tool.name) ? 5 : 0) + keywordScore(task, tool),
+    }));
+    const limit = selectPlanningCatalogCount(tier);
+    return ranked
+        .sort((left, right) => right.score - left.score || left.tool.name.localeCompare(right.tool.name))
+        .slice(0, limit)
+        .map((entry) => entry.tool);
+}
+export function buildToolPlan(options) {
+    const tier = options.tier ?? "compressed";
+    const catalog = Array.isArray(options.tools) && options.tools.length > 0
+        ? listAceInternalToolCatalog().filter((tool) => options.tools?.includes(tool.name))
+        : buildPlanningCatalog(options.role, options.task, tier);
+    const recommended = scopeTools(options.role, options.task, tier, options.tools).map((tool) => tool.name);
+    const selectionLimit = tier === "brief" ? 8 : tier === "compressed" ? 12 : 15;
+    const catalogLines = catalog.map((tool) => `- ${tool.name} — ${tool.description || "ACE internal tool"}`);
+    return {
+        prompt: [
+            `You are selecting ACE tools for role '${options.role}'.`,
+            `Task: ${options.task}`,
+            "",
+            `Choose between 1 and ${selectionLimit} tools from this catalog.`,
+            "Prefer the smallest tool set that can make real progress.",
+            "Prioritize the default ACE tools for the role when they fit the task.",
+            'Respond with JSON only: {"selected_tools":["tool_a","tool_b"],"reasoning":"short reason"}',
+            "",
+            "## Tool Catalog",
+            ...catalogLines,
+            "",
+            `## Role-biased recommendations`,
+            recommended.length > 0 ? `- ${recommended.join(", ")}` : "- none",
+        ].join("\n"),
+        catalog,
+        recommended_tools: recommended,
+        selection_limit: selectionLimit,
+    };
+}
+export function renderAceContext(options) {
+    const tier = options.tier ?? "compressed";
+    const active = readRuntimeProfileState();
+    const autonomy = normalizeAutonomyPolicy(active.profile.autonomy);
+    const continuity = normalizeContinuityPolicy(active.profile.continuity);
+    const recall = buildAceRecallContext({
+        state_sources: autonomy.state_sources,
+    });
+    const continuityPacket = continuity.enabled
+        ? buildAceContinuityPacket({
+            policy: continuity,
+        })
+        : undefined;
+    const tools = scopeTools(options.role, options.task, tier, options.tools);
+    const runtimePrompt = renderRuntimePrompt({
+        task: options.task,
+        workspace_path: options.workspace,
+        autonomy,
+        continuity,
+        ace_state_recall_md: renderAceRecallPromptBlock(recall, !continuity.enabled),
+        ace_context_snapshot_md: renderAceSnapshotPromptBlock(recall),
+        ace_continuity_packet_md: renderAceContinuityPromptBlock(continuityPacket),
+    });
+    const roleInstructions = resolveRoleInstructions(options.role);
+    const toolCatalog = renderToolCatalogMarkdown(tools, tier);
+    const stateDigest = recall.task_contract.summary;
+    const systemPrompt = [
+        runtimePrompt,
+        "",
+        "## Active Role",
+        `- Role: ${options.role}`,
+        "",
+        "## Role Instructions",
+        roleInstructions,
+        "",
+        "## Tool Scope",
+        toolCatalog || "- No ACE tools available.",
+        "",
+        "## Output Contract",
+        'Respond in JSON only with one of these shapes:',
+        '- `{"status":"tool","thinking":"...","tool_calls":[{"tool":"name","input":{}}]}`',
+        '- `{"status":"message","thinking":"...","message":"..."}`',
+        '- `{"status":"complete","thinking":"...","summary":"..."}`',
+        '- `{"status":"need_input","thinking":"...","message":"..."}`',
+    ].join("\n");
+    return {
+        systemPrompt,
+        tools,
+        stateDigest,
+        // TODO: replace with model-aware token counting when context window management lands.
+        tokenEstimate: Math.max(1, Math.ceil(systemPrompt.length / 4)),
+        tier,
+    };
+}
+//# sourceMappingURL=ace-context.js.map

package/dist/ace-internal-tools.d.ts

@@ -0,0 +1,8 @@
+export interface AceInternalToolCatalogEntry {
+    name: string;
+    description: string;
+    input_keys: string[];
+}
+export declare function listAceInternalToolCatalog(): AceInternalToolCatalogEntry[];
+export declare function executeAceInternalTool(name: string, input: Record<string, unknown> | undefined, sessionId?: string): Promise<any>;
+//# sourceMappingURL=ace-internal-tools.d.ts.map

package/dist/ace-internal-tools.js

@@ -0,0 +1,76 @@
+import { randomUUID } from "node:crypto";
+import { createAceServer } from "./server.js";
+let internalServer;
+function getServer() {
+    if (!internalServer) {
+        internalServer = createAceServer({ toolGovernance: false });
+    }
+    return internalServer;
+}
+function getRegistry() {
+    const server = getServer();
+    if (!server._registeredTools) {
+        throw new Error("MCP SDK internal API changed: _registeredTools not found. Update ace-internal-tools.ts to match the new SDK structure.");
+    }
+    return server._registeredTools;
+}
+function summarizeSchemaKeys(schema) {
+    if (!schema)
+        return [];
+    const shapeSource = schema.shape;
+    if (shapeSource && typeof shapeSource === "object") {
+        return Object.keys(shapeSource);
+    }
+    return [];
+}
+function buildRequestExtra(sessionId) {
+    return {
+        signal: new AbortController().signal,
+        sessionId,
+        requestId: randomUUID(),
+        sendNotification: async () => undefined,
+        sendRequest: async () => ({}),
+    };
+}
+export function listAceInternalToolCatalog() {
+    return Object.entries(getRegistry())
+        .filter(([, tool]) => tool.enabled)
+        .map(([name, tool]) => ({
+        name,
+        description: tool.description ?? "",
+        input_keys: summarizeSchemaKeys(tool.inputSchema),
+    }))
+        .sort((left, right) => left.name.localeCompare(right.name));
+}
+export async function executeAceInternalTool(name, input, sessionId) {
+    const tool = getRegistry()[name];
+    if (!tool || !tool.enabled) {
+        return {
+            content: [{ type: "text", text: `ACE tool '${name}' is not registered.` }],
+            isError: true,
+        };
+    }
+    const parsedInput = tool.inputSchema
+        ? tool.inputSchema.safeParse(input ?? {})
+        : { success: true, data: undefined };
+    if (!parsedInput.success) {
+        const errorText = parsedInput.error.issues
+            .map((issue) => issue.message)
+            .join("; ");
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Invalid arguments for '${name}': ${errorText}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+    const extra = buildRequestExtra(sessionId);
+    if (tool.inputSchema) {
+        return tool.handler(parsedInput.data, extra);
+    }
+    return tool.handler(extra);
+}
+//# sourceMappingURL=ace-internal-tools.js.map

package/dist/ace-server-instructions.d.ts

@@ -0,0 +1,12 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function buildAceDigest(workspaceRoot: string): string;
+export declare function buildServerInstructions(workspaceRoot: string): string;
+export declare function buildHostInstructionText(host: "claude" | "copilot" | "cursor" | "codex", workspaceRoot: string): string;
+export declare function buildBootstrapNudge(workspaceRoot: string): string;
+export declare function buildBootstrapGuidance(workspaceRoot: string, toolName: string): string;
+export declare function buildMutationGuidance(workspaceRoot: string, toolName: string): string;
+export declare function buildRefreshGuidance(workspaceRoot: string, toolName: string): string;
+export declare function installAceToolGovernance(server: McpServer, workspaceRoot: string): void;
+export declare function buildHookAdditionalContext(workspaceRoot: string): string;
+export declare function buildScopeReminder(workspaceRoot: string): string | undefined;
+//# sourceMappingURL=ace-server-instructions.d.ts.map

package/dist/ace-server-instructions.js

@@ -0,0 +1,324 @@
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+const ACE_ROOT_REL = ".agents/ACE";
+const CORE_FILES = [
+    `${ACE_ROOT_REL}/agent-state/TASK.md`,
+    `${ACE_ROOT_REL}/agent-state/STATUS.md`,
+    `${ACE_ROOT_REL}/agent-state/SCOPE.md`,
+    `${ACE_ROOT_REL}/agent-state/EVIDENCE_LOG.md`,
+];
+const STATE_DIRS = [
+    `${ACE_ROOT_REL}/agent-state`,
+    `${ACE_ROOT_REL}/global-state`,
+    `${ACE_ROOT_REL}/venture-state`,
+    `${ACE_ROOT_REL}/brand-state`,
+    `${ACE_ROOT_REL}/engineering-state`,
+];
+const BOOTSTRAP_TOOLS = new Set([
+    "bootstrap_state",
+    "recall_context",
+    "build_continuity_packet",
+]);
+// Named set — new refresh_* tools must be added here explicitly.
+// These tools rewrite snapshot files but don't need EVIDENCE_LOG reconciliation guidance.
+const REFRESH_TOOLS = new Set([
+    "refresh_astgrep_index",
+    "refresh_tracker_snapshot",
+    "refresh_vericify_bridge",
+]);
+// Named set — tools that mutate state but do not match any MUTATION_PREFIXES entry.
+// New mutation tools with non-standard prefixes must be added here explicitly.
+const NAMED_MUTATION_TOOLS = new Set([
+    "rewrite_targets",
+]);
+const MUTATION_PREFIXES = [
+    "ack_",
+    "add_",
+    "append_",
+    "close_",
+    "complete_",
+    "context_",
+    "create_",
+    "dispatch_",
+    "emit_",
+    "enqueue_",
+    "execute_",
+    "git_",
+    "open_",
+    "remove_",
+    "resume_",
+    "run_",
+    "safe_",
+    "scan_",
+    "snapshot_",
+    "start_",
+    "stop_",
+    "update_",
+    "write_",
+];
+function readIfPresent(filePath) {
+    if (!existsSync(filePath))
+        return undefined;
+    try {
+        return readFileSync(filePath, "utf-8");
+    }
+    catch {
+        return undefined;
+    }
+}
+function nonEmptyLines(input) {
+    return input
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean);
+}
+function oneLine(input) {
+    return input.replace(/\s+/g, " ").trim();
+}
+function truncate(input, max = 140) {
+    if (input.length <= max)
+        return input;
+    return `${input.slice(0, Math.max(0, max - 1)).trimEnd()}…`;
+}
+function resolveWorkspacePath(workspaceRoot, relativePath) {
+    const canonicalRel = relativePath.startsWith(`${ACE_ROOT_REL}/`)
+        ? relativePath
+        : `agent-state|global-state|venture-state|brand-state|engineering-state`
+            .split("|")
+            .some((prefix) => relativePath === prefix || relativePath.startsWith(`${prefix}/`))
+            ? `${ACE_ROOT_REL}/${relativePath}`
+            : relativePath;
+    const canonicalPath = resolve(workspaceRoot, canonicalRel);
+    if (canonicalRel !== relativePath) {
+        const legacyPath = resolve(workspaceRoot, relativePath);
+        if (!existsSync(canonicalPath) && existsSync(legacyPath)) {
+            return legacyPath;
+        }
+    }
+    return canonicalPath;
+}
+function listExistingCoreFiles(workspaceRoot) {
+    return CORE_FILES.filter((relativePath) => existsSync(resolveWorkspacePath(workspaceRoot, relativePath)));
+}
+function listExistingStateDirs(workspaceRoot) {
+    return STATE_DIRS.filter((relativePath) => existsSync(resolveWorkspacePath(workspaceRoot, relativePath)));
+}
+function extractObjective(taskRaw) {
+    if (!taskRaw)
+        return undefined;
+    const match = taskRaw.match(/## Objective\s+([\s\S]*?)(?:\n## |\n# |$)/);
+    if (match?.[1]) {
+        return truncate(oneLine(match[1]));
+    }
+    const bodyLine = nonEmptyLines(taskRaw).find((line) => !line.startsWith("#"));
+    if (bodyLine) {
+        return truncate(oneLine(bodyLine));
+    }
+    const heading = taskRaw.match(/^#\s+(.+)$/m)?.[1];
+    return heading ? truncate(oneLine(heading)) : undefined;
+}
+function extractStatusValue(statusRaw, label) {
+    if (!statusRaw)
+        return undefined;
+    const pattern = new RegExp(`^- ${label}:\\s*(.+)$`, "m");
+    const match = statusRaw.match(pattern);
+    return match?.[1] ? truncate(oneLine(match[1])) : undefined;
+}
+function extractAutonomyHint(workspaceRoot) {
+    const workflowRaw = readIfPresent(resolveWorkspacePath(workspaceRoot, "agent-state/ACE_WORKFLOW.md"));
+    if (!workflowRaw)
+        return undefined;
+    const hints = [];
+    if (/^\s*orchestrator_preflight:\s*true\s*$/m.test(workflowRaw)) {
+        hints.push("orchestrator preflight");
+    }
+    if (/^\s*recall_context:\s*true\s*$/m.test(workflowRaw)) {
+        hints.push("context recall");
+    }
+    const reviewMode = workflowRaw.match(/^\s*review_mode:\s*["']?([A-Za-z0-9_-]+)["']?\s*$/m)?.[1];
+    if (reviewMode) {
+        hints.push(`review mode ${reviewMode}`);
+    }
+    return hints.length > 0 ? hints.join(", ") : undefined;
+}
+export function buildAceDigest(workspaceRoot) {
+    const taskRaw = readIfPresent(resolveWorkspacePath(workspaceRoot, "agent-state/TASK.md"));
+    const statusRaw = readIfPresent(resolveWorkspacePath(workspaceRoot, "agent-state/STATUS.md"));
+    const objective = extractObjective(taskRaw);
+    const phase = extractStatusValue(statusRaw, "Current phase");
+    const blockers = extractStatusValue(statusRaw, "Blockers");
+    const parts = [
+        objective ? `task=${objective}` : undefined,
+        phase ? `phase=${phase}` : undefined,
+        blockers ? `blockers=${blockers}` : undefined,
+    ].filter((value) => Boolean(value));
+    return parts.length > 0 ? parts.join(" | ") : "ACE state detected; load recall_context for task and status.";
+}
+export function buildServerInstructions(workspaceRoot) {
+    const coreFiles = listExistingCoreFiles(workspaceRoot);
+    const stateDirs = listExistingStateDirs(workspaceRoot);
+    const digest = buildAceDigest(workspaceRoot);
+    const autonomyHint = extractAutonomyHint(workspaceRoot);
+    const lines = [
+        "You are operating in an ACE-governed workspace.",
+        coreFiles.length > 0
+            ? `Ground truth lives in ${coreFiles.join(", ")}.`
+            : `Ground truth lives in ${ACE_ROOT_REL}/agent-state/* artifacts, not chat history.`,
+        stateDirs.length > 0
+            ? `Durable artifacts belong under ${stateDirs.map((entry) => `${entry}/`).join(", ")}.`
+            : undefined,
+        "Before significant work, call recall_context to load current task, scope, and status.",
+        "Use route_task and get_agent_instructions for role guidance; do not self-assign by guesswork.",
+        "After meaningful edits or state changes, call execute_gates and persist evidence/handoffs in ACE artifacts.",
+        "For delegated or long-running work, use create_handoff / ack_handoff and append_vericify_process_post instead of ad-hoc status notes.",
+        `Current ACE digest: ${digest}.`,
+        autonomyHint ? `Runtime autonomy signals: ${autonomyHint}.` : undefined,
+    ];
+    return lines.filter((line) => Boolean(line)).join("\n");
+}
+export function buildHostInstructionText(host, workspaceRoot) {
+    const hostLabel = {
+        claude: "Claude Code",
+        copilot: "GitHub Copilot",
+        cursor: "Cursor",
+        codex: "Codex",
+    }[host];
+    return [
+        `# ACE Bootstrap For ${hostLabel}`,
+        "",
+        "This is a thin ACE bootstrap stub.",
+        "Full instructions, skills, task packs, and runtime state live inside `.agents/ACE/ace-state.zarr` and should be accessed through the ACE MCP server.",
+        "",
+        "Session start protocol:",
+        "1. Call `recall_context` to load task, scope, and status from ACE state.",
+        "2. Call `route_task` and `get_agent_instructions` before choosing a role.",
+        "3. Prefer ACE prompts/resources (`ace-orchestrator`, `get_task_pack`, `get_skill_instructions`) over relying on this file.",
+        "",
+        "Ground truth:",
+        "- `.agents/ACE/ace-state.zarr` is authoritative.",
+        "- `.agents/ACE/tasks/todo.md` is the human-facing todo surface.",
+        "- `.agents/ACE/ace-hook-context.json` is the compact hook snapshot.",
+        "",
+        `Workspace digest hint: ${buildAceDigest(workspaceRoot)}.`,
+    ].join("\n");
+}
+export function buildBootstrapNudge(workspaceRoot) {
+    const coreFiles = listExistingCoreFiles(workspaceRoot);
+    return [
+        "ACE bootstrap hint: call `recall_context` before significant work so task and scope come from file-backed state.",
+        `ACE digest: ${buildAceDigest(workspaceRoot)}.`,
+        coreFiles.length > 0 ? `Current core files: ${coreFiles.join(", ")}.` : undefined,
+    ]
+        .filter((value) => Boolean(value))
+        .join(" ");
+}
+export function buildBootstrapGuidance(workspaceRoot, toolName) {
+    return `ACE context loaded via \`${toolName}\`. Current digest: ${buildAceDigest(workspaceRoot)}.`;
+}
+export function buildMutationGuidance(workspaceRoot, toolName) {
+    return [
+        `ACE digest after \`${toolName}\`: ${buildAceDigest(workspaceRoot)}.`,
+        `If this changed code or state, reconcile \`${ACE_ROOT_REL}/agent-state/EVIDENCE_LOG.md\`, run \`execute_gates\` when appropriate, and use structured handoffs/process posts for delegated follow-up.`,
+    ].join(" ");
+}
+export function buildRefreshGuidance(workspaceRoot, toolName) {
+    return [
+        `ACE snapshot refresh completed via \`${toolName}\`.`,
+        `Current digest: ${buildAceDigest(workspaceRoot)}.`,
+    ].join(" ");
+}
+function isBootstrapTool(toolName) {
+    return BOOTSTRAP_TOOLS.has(toolName);
+}
+function isRefreshTool(toolName) {
+    return REFRESH_TOOLS.has(toolName);
+}
+function isMutationTool(toolName) {
+    if (isBootstrapTool(toolName) || isRefreshTool(toolName))
+        return false;
+    if (NAMED_MUTATION_TOOLS.has(toolName))
+        return true;
+    return MUTATION_PREFIXES.some((prefix) => toolName.startsWith(prefix));
+}
+function normalizeCallToolResult(result) {
+    return {
+        ...result,
+        content: Array.isArray(result.content) ? [...result.content] : [],
+    };
+}
+function appendTextContent(result, text) {
+    const normalized = normalizeCallToolResult(result);
+    const existing = normalized.content
+        .filter((entry) => entry.type === "text")
+        .map((entry) => entry.text);
+    if (existing.some((entry) => entry.includes(text))) {
+        return normalized;
+    }
+    normalized.content.push({ type: "text", text });
+    return normalized;
+}
+function isCallToolResult(value) {
+    return Boolean(value) && typeof value === "object" && "content" in value;
+}
+export function installAceToolGovernance(server, workspaceRoot) {
+    const bootstrappedSessions = new Set();
+    const wrapToolCallback = (toolName, callback) => async (...args) => {
+        const extra = args.at(-1);
+        const sessionId = typeof extra?.sessionId === "string" ? extra.sessionId : undefined;
+        const rawResult = await callback(...args);
+        const failed = Boolean(rawResult && typeof rawResult === "object" && rawResult.isError);
+        if (sessionId && !failed && isBootstrapTool(toolName)) {
+            bootstrappedSessions.add(sessionId);
+        }
+        if (!isCallToolResult(rawResult)) {
+            return rawResult;
+        }
+        let next = rawResult;
+        if (sessionId && !bootstrappedSessions.has(sessionId) && !isBootstrapTool(toolName)) {
+            next = appendTextContent(next, buildBootstrapNudge(workspaceRoot));
+        }
+        if (isBootstrapTool(toolName)) {
+            next = appendTextContent(next, buildBootstrapGuidance(workspaceRoot, toolName));
+        }
+        else if (isRefreshTool(toolName)) {
+            next = appendTextContent(next, buildRefreshGuidance(workspaceRoot, toolName));
+        }
+        else if (isMutationTool(toolName)) {
+            next = appendTextContent(next, buildMutationGuidance(workspaceRoot, toolName));
+        }
+        return next;
+    };
+    const originalTool = server.tool.bind(server);
+    server.tool = (name, ...rest) => {
+        const maybeCallback = rest.at(-1);
+        if (typeof maybeCallback !== "function") {
+            return originalTool(name, ...rest);
+        }
+        return originalTool(name, ...rest.slice(0, -1), wrapToolCallback(name, maybeCallback));
+    };
+    const originalRegisterTool = server.registerTool.bind(server);
+    server.registerTool = (name, config, callback) => {
+        if (typeof callback !== "function") {
+            return originalRegisterTool(name, config, callback);
+        }
+        return originalRegisterTool(name, config, wrapToolCallback(name, callback));
+    };
+}
+export function buildHookAdditionalContext(workspaceRoot) {
+    const parts = [
+        buildServerInstructions(workspaceRoot),
+        `State digest: ${buildAceDigest(workspaceRoot)}.`,
+    ];
+    return parts.join("\n");
+}
+export function buildScopeReminder(workspaceRoot) {
+    const scopeRaw = readIfPresent(resolveWorkspacePath(workspaceRoot, "agent-state/SCOPE.md"));
+    if (!scopeRaw)
+        return undefined;
+    const scopeLines = nonEmptyLines(scopeRaw).filter((line) => !line.startsWith("#"));
+    if (scopeLines.length === 0) {
+        return `ACE scope reminder: review ${ACE_ROOT_REL}/agent-state/SCOPE.md before mutating files or state.`;
+    }
+    return `ACE scope reminder: ${truncate(oneLine(scopeLines.slice(0, 4).join(" ")), 220)}`;
+}
+//# sourceMappingURL=ace-server-instructions.js.map