@voybio/ace-swarm 0.1.0 → 0.2.1

package/dist/tui/local-model-contract.js

@@ -0,0 +1,272 @@
+import { readStoreBlobSync, readStoreJsonSync } from "../store/store-snapshot.js";
+import { resolveAceStateLayout, readAceLogicalFile } from "../ace-state-resolver.js";
+function oneLine(input) {
+    return input.replace(/\s+/g, " ").trim();
+}
+function clip(input, max = 220) {
+    if (input.length <= max)
+        return input;
+    return `${input.slice(0, Math.max(0, max - 1)).trimEnd()}…`;
+}
+function extractObjective(taskRaw) {
+    if (!taskRaw)
+        return undefined;
+    const objectiveMatch = taskRaw.match(/## Objective\s+([\s\S]*?)(?:\n## |\n# |$)/);
+    if (objectiveMatch?.[1]) {
+        return clip(oneLine(objectiveMatch[1]));
+    }
+    const bodyLine = taskRaw
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .find((line) => line.length > 0 && !line.startsWith("#"));
+    return bodyLine ? clip(oneLine(bodyLine)) : undefined;
+}
+function extractStatusField(statusRaw, label) {
+    if (!statusRaw)
+        return undefined;
+    const pattern = new RegExp(`^- ${label}:\\s*(.+)$`, "im");
+    const match = statusRaw.match(pattern);
+    return match?.[1] ? clip(oneLine(match[1])) : undefined;
+}
+function determineRole(task, preferredRole) {
+    const lowered = task.toLowerCase();
+    if (preferredRole && preferredRole !== "orchestrator") {
+        return preferredRole;
+    }
+    if (/\b(doc|docs|readme|changelog|guide)\b/.test(lowered))
+        return "docs";
+    if (/\b(test|qa|verify|regression|assert|review)\b/.test(lowered))
+        return "qa";
+    if (/\b(ui|design|layout|ux|css|frontend)\b/.test(lowered))
+        return "ui";
+    if (/\b(research|investigate|compare|audit|analyze|analysis)\b/.test(lowered))
+        return "research";
+    if (/\b(spec|schema|contract|interface)\b/.test(lowered))
+        return "spec";
+    if (/\b(build|implement|fix|patch|code|refactor|wire|edit)\b/.test(lowered))
+        return "coders";
+    return "orchestrator";
+}
+export function shouldSynthesizeShortPlan(task) {
+    const lowered = task.toLowerCase();
+    const signals = [
+        /\b(compare|investigate|analyze)\b.*\b(implement|fix|change|edit)\b/,
+        /\b(implement|fix|change|edit)\b.*\b(test|verify|review|qa)\b/,
+        /\b(multi-step|multiple|several)\b/,
+        /\b(and|then)\b/,
+        /\bcompare\b/,
+        /\bmodify\b.*\bverify\b/,
+    ];
+    return signals.some((pattern) => pattern.test(lowered));
+}
+function buildRecallSummary(workspaceRoot) {
+    const taskRaw = readAceLogicalFile(workspaceRoot, "agent-state/TASK.md");
+    const statusRaw = readAceLogicalFile(workspaceRoot, "agent-state/STATUS.md");
+    const objective = extractObjective(taskRaw);
+    const phase = extractStatusField(statusRaw, "Current phase");
+    const blockers = extractStatusField(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(" | ") : undefined;
+}
+function hasContent(workspaceRoot, relativePath) {
+    const content = readAceLogicalFile(workspaceRoot, relativePath);
+    return typeof content === "string" && content.trim().length > 0;
+}
+export function buildAcePreflightPacket(input) {
+    const resolution = resolveAceStateLayout(input.workspaceRoot);
+    const blockers = [...resolution.missingCriticalArtifacts];
+    const warnings = [];
+    const qualityGatesPresent = hasContent(input.workspaceRoot, "agent-state/QUALITY_GATES.md");
+    const handoffPresent = hasContent(input.workspaceRoot, "agent-state/HANDOFF.json");
+    const evidencePresent = hasContent(input.workspaceRoot, "agent-state/EVIDENCE_LOG.md");
+    const statusRaw = readAceLogicalFile(input.workspaceRoot, "agent-state/STATUS.md");
+    const blockerStatus = extractStatusField(statusRaw, "Blockers");
+    const blockedByStatus = blockerStatus && !/\bnone\b/i.test(blockerStatus);
+    if (!qualityGatesPresent)
+        warnings.push("Missing agent-state/QUALITY_GATES.md");
+    if (!handoffPresent)
+        warnings.push("Missing agent-state/HANDOFF.json");
+    if (!evidencePresent)
+        warnings.push("Missing agent-state/EVIDENCE_LOG.md");
+    if (blockedByStatus && blockerStatus)
+        warnings.push(`Status blockers: ${blockerStatus}`);
+    const taskContractHealth = blockers.length > 0 ? "blocked" : warnings.length > 0 ? "thin" : "healthy";
+    const quartetHealth = blockers.length > 0
+        ? "incomplete"
+        : blockedByStatus
+            ? "contradictory"
+            : warnings.length > 0
+                ? "thin"
+                : "healthy";
+    const preflightState = blockers.length > 0 ? "blocked" : warnings.length > 0 || blockedByStatus ? "attention_required" : "ready";
+    const recommendedRole = determineRole(input.task, input.preferredRole);
+    const synthesize = shouldSynthesizeShortPlan(input.task);
+    const recommendedNextAction = preflightState === "blocked"
+        ? "validate_framework"
+        : synthesize
+            ? "run_orchestrator"
+            : quartetHealth !== "healthy"
+                ? "recall_context"
+                : recommendedRole === "orchestrator"
+                    ? "route_task"
+                    : "recall_context";
+    return {
+        session_id: input.sessionId,
+        workspace_root: input.workspaceRoot,
+        state_resolution: resolution,
+        preflight_state: preflightState,
+        bridge_status: preflightState === "blocked" ? "blocked" : "running",
+        quartet_health: quartetHealth,
+        task_contract_health: taskContractHealth,
+        recommended_role: recommendedRole,
+        recommended_next_action: recommendedNextAction,
+        blockers,
+        warnings,
+        recall_summary: buildRecallSummary(input.workspaceRoot),
+        should_synthesize_plan: synthesize,
+    };
+}
+export function nextActivationLedger(sessionId, current, recommendedAction) {
+    return {
+        session_id: sessionId,
+        created_at: current?.created_at ?? Date.now(),
+        updated_at: Date.now(),
+        prompt_count: (current?.prompt_count ?? 0) + 1,
+        shown_nudges: [...(current?.shown_nudges ?? [])],
+        accepted_nudges: [...(current?.accepted_nudges ?? [])],
+        activated_tools: [...(current?.activated_tools ?? [])],
+        activated_roles: [...(current?.activated_roles ?? [])],
+        last_recommended_action: recommendedAction ?? current?.last_recommended_action,
+    };
+}
+export function buildStartupNudge(preflight, ledger) {
+    const action = preflight.recommended_next_action;
+    if (!action)
+        return undefined;
+    const nudgeId = `next:${action}`;
+    if (ledger.activated_tools.includes(action) || ledger.accepted_nudges.includes(nudgeId)) {
+        return undefined;
+    }
+    const text = action === "validate_framework"
+        ? "ACE state is incomplete. Run validate_framework before free-form execution."
+        : action === "run_orchestrator"
+            ? "This looks multi-step. Prefer run_orchestrator over a single free-form reply."
+            : action === "route_task"
+                ? "Role selection is still ambiguous. Route the task before deeper work."
+                : "Load ACE context first with recall_context before deeper work.";
+    return { id: nudgeId, text, recommended_action: action };
+}
+function compactTrapPack() {
+    return [
+        "Stop if you are about to claim tested, verified, or passed without evidence.",
+        "If ACE state is thin or contradictory, use recall_context or validate_framework before improvising.",
+        "For obviously multi-step work, prefer run_orchestrator over a single free-form answer.",
+        "Do not declare completion while approval, retry, or blocker state remains active.",
+    ];
+}
+export function buildBridgeTaskInput(conversation, preflight) {
+    const lines = [
+        "## Recent Conversation",
+        conversation,
+        "",
+        "## ACE Preflight",
+        `- preflight_state: ${preflight.preflight_state}`,
+        `- quartet_health: ${preflight.quartet_health}`,
+        `- task_contract_health: ${preflight.task_contract_health}`,
+        preflight.recall_summary ? `- recall_summary: ${preflight.recall_summary}` : undefined,
+        preflight.recommended_role ? `- recommended_role: ${preflight.recommended_role}` : undefined,
+        preflight.recommended_next_action
+            ? `- recommended_next_action: ${preflight.recommended_next_action}`
+            : undefined,
+        preflight.blockers.length > 0 ? `- blockers: ${preflight.blockers.join("; ")}` : undefined,
+        preflight.warnings.length > 0 ? `- warnings: ${preflight.warnings.join("; ")}` : undefined,
+        "",
+        "## Compact Guardrails",
+        ...compactTrapPack().map((entry) => `- ${entry}`),
+    ].filter((value) => Boolean(value));
+    if (preflight.should_synthesize_plan) {
+        lines.push("", "## Required Short Plan Skeleton", "1. recall and orient", "2. route or confirm responsible role", "3. execute the main change", "4. run gate, QA, or verification follow-up");
+    }
+    return lines.join("\n");
+}
+export function mapBridgeResultToRuntimeStatus(input) {
+    const lowered = input.summary.toLowerCase();
+    let bridgeStatus = input.current.bridge_status;
+    if (/\bapproval\b/.test(lowered)) {
+        bridgeStatus = "approval_pending";
+    }
+    else if (/\bretry/i.test(input.summary)) {
+        bridgeStatus = "retrying";
+    }
+    else if (/\bneed\b.*\binput\b/.test(lowered)) {
+        bridgeStatus = "needs_input";
+    }
+    else if (bridgeStatus === "running") {
+        bridgeStatus = "done";
+    }
+    if (bridgeStatus === "done" && input.current.approval_state === "pending") {
+        bridgeStatus = "approval_pending";
+    }
+    const approvalState = bridgeStatus === "approval_pending" ? "pending" : input.current.approval_state;
+    const activeTool = bridgeStatus === "approval_pending" || bridgeStatus === "done"
+        ? undefined
+        : input.toolNames.at(-1);
+    return {
+        ...input.current,
+        bridge_status: bridgeStatus,
+        approval_state: approvalState,
+        active_tool: activeTool,
+        updated_at: Date.now(),
+    };
+}
+export function buildContinuityRecord(input) {
+    return {
+        session_id: input.preflight.session_id,
+        workspace_root: input.preflight.workspace_root,
+        state_resolution_mode: input.preflight.state_resolution.physicalMode,
+        last_role: input.role,
+        last_preflight_state: input.preflight.preflight_state,
+        last_bridge_status: input.bridgeStatus,
+        active_tool: input.activeTool,
+        blockers: [...input.preflight.blockers],
+        recent_decisions: uniqueDecisionList([
+            input.preflight.recommended_role ? `role=${input.preflight.recommended_role}` : undefined,
+            input.preflight.recommended_next_action
+                ? `next=${input.preflight.recommended_next_action}`
+                : undefined,
+        ]),
+        recommended_next_action: input.preflight.recommended_next_action,
+        evidence_refs: Array.from(new Set(input.evidenceRefs ?? [])),
+        created_at: Date.now(),
+        updated_at: Date.now(),
+    };
+}
+function uniqueDecisionList(values) {
+    return Array.from(new Set(values.filter((value) => Boolean(value))));
+}
+export function containsVerificationLanguage(text) {
+    return /\b(verified|verify|validated|tested|pass(?:ed)?|confirmed|proven)\b/i.test(text);
+}
+export function hasEvidenceLikeTool(toolNames) {
+    return toolNames.some((tool) => ["run_tests", "execute_gates", "git_diff", "safe_edit_file", "read_workspace_file"].includes(tool));
+}
+export function applyEvidenceGuardrail(summary, toolNames) {
+    if (!containsVerificationLanguage(summary))
+        return summary;
+    if (hasEvidenceLikeTool(toolNames))
+        return summary;
+    return `Unverified summary: ${summary}`;
+}
+export function readRuntimeWorkflowHint(workspaceRoot) {
+    return readStoreBlobSync(workspaceRoot, "knowledge/runtime/ACE_WORKFLOW.md")
+        ?? readAceLogicalFile(workspaceRoot, "agent-state/ACE_WORKFLOW.md")
+        ?? undefined;
+}
+export function readStatusHint(workspaceRoot) {
+    return readStoreJsonSync(workspaceRoot, "state/runtime/llm_profile")?.provider;
+}
+//# sourceMappingURL=local-model-contract.js.map

package/dist/vericify-bridge.js

@@ -5,7 +5,7 @@ import { resolveWorkspaceArtifactPath as resolveWorkspaceArtifactPathHelper, res
 import { validateVericifyBridgeSnapshotPayload, validateVericifyProcessPostLogPayload, } from "./schemas.js";
 import { getRuntimeProfilePath, readRuntimeProfile } from "./runtime-profile.js";
 import { openStore } from "./store/ace-packed-store.js";
-import { VericifyProjector } from "./store/materializers/vericify-projector.js";
+import { ProjectionManager } from "./store/materializers/projection-manager.js";
 import { VericifyRepository } from "./store/repositories/vericify-repository.js";
 import { getWorkspaceStorePath, storeExistsSync } from "./store/store-snapshot.js";
 import { isOperationalArtifactPath, operationalArtifactVirtualPath } from "./store/store-artifacts.js";
@@ -383,9 +383,8 @@ export async function appendVericifyProcessPost(input) {
                         },
                     });
                     await store.commit();
-                    const projector = new VericifyProjector(store, root);
-                    await projector.projectVericifyPosts();
-                    await store.commit();
+                    const projections = new ProjectionManager(store, root);
+                    await projections.projectAfterCommit(["vericify_posts"]);
                 }
                 finally {
                     await store.close();

package/dist/vericify-context.js

@@ -8,10 +8,19 @@ const PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 function tryResolveVericifyApi(searchFrom) {
     if (!searchFrom)
         return undefined;
+    const directCandidates = [
+        resolve(searchFrom, "src", "api.js"),
+        resolve(searchFrom, "vericify", "src", "api.js"),
+        resolve(searchFrom, "..", "vericify", "src", "api.js"),
+    ];
+    for (const candidate of directCandidates) {
+        if (existsSync(candidate)) {
+            return candidate;
+        }
+    }
     const packageRoot = resolve(searchFrom, "node_modules", "vericify");
-    if (!existsSync(packageRoot)) {
+    if (!existsSync(packageRoot))
         return undefined;
-    }
     try {
         const resolvedPath = requireFromModule.resolve("vericify/api", { paths: [searchFrom] });
         return resolvedPath.startsWith(packageRoot) ? resolvedPath : undefined;
@@ -34,14 +43,15 @@ function resolveVericifyApiPath(workspaceRoot) {
         return match;
     throw new Error([
         "Unable to locate Vericify API.",
-        "Install `vericify` locally in the workspace or alongside `ace-swarm`,",
+        "Install `vericify` locally, keep a sibling checkout beside `ace-swarm`,",
         "or set VERICIFY_API_PATH to an installed `vericify/api` entry file.",
     ].join(" "));
 }
 async function loadVericifyApi(workspaceRoot) {
     const apiPath = resolveVericifyApiPath(workspaceRoot);
     const loaded = await import(pathToFileURL(apiPath).href);
-    if (typeof loaded.buildCompactPacket !== "function" ||
+    if (typeof loaded.loadWorkspaceState !== "function" ||
+        typeof loaded.buildCompactPacket !== "function" ||
         typeof loaded.buildCompactDelta !== "function" ||
         typeof loaded.projectWorkspaceState !== "function") {
         throw new Error(`Vericify API at ${apiPath} is missing compact context exports.`);
@@ -53,7 +63,8 @@ export async function getVericifyContextPacket(input) {
         ? resolve(input.workspaceRoot)
         : resolveWorkspaceRoot();
     const api = await loadVericifyApi(workspaceRoot);
-    const projected = api.projectWorkspaceState(workspaceRoot);
+    const workspaceState = api.loadWorkspaceState(workspaceRoot);
+    const projected = api.projectWorkspaceState(workspaceState);
     return api.buildCompactPacket(projected, {
         runId: input?.runId ?? "workspace:current",
     });
@@ -63,7 +74,8 @@ export async function getVericifyDelta(input) {
         ? resolve(input.workspaceRoot)
         : resolveWorkspaceRoot();
     const api = await loadVericifyApi(workspaceRoot);
-    const projected = api.projectWorkspaceState(workspaceRoot);
+    const workspaceState = api.loadWorkspaceState(workspaceRoot);
+    const projected = api.projectWorkspaceState(workspaceState);
     return api.buildCompactDelta(projected, {
         runId: input.runId ?? "workspace:current",
         since: input.since,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@voybio/ace-swarm",
-  "version": "0.1.0",
-  "description": "ACE Framework MCP server and CLI — Zarrita-backed single-file state, local-model serving, agent orchestration, and host compliance enforcement.",
+  "version": "0.2.1",
+  "description": "ACE Framework MCP server and CLI — single-file ACEPACK state, local-model serving, agent orchestration, and host compliance enforcement.",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -46,6 +46,7 @@
   "keywords": [
     "mcp",
     "mcp-server",
+    "harness",
     "ace",
     "ace-swarm",
     "agents",
@@ -57,8 +58,7 @@
     "codex",
     "ollama",
     "llama.cpp",
-    "zarr",
-    "zarrita",
+    "acepack",
     "local-models"
   ],
   "author": "",
@@ -68,8 +68,6 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.26.0",
-    "@zarrita/core": "^0.0.3",
-    "@zarrita/storage": "^0.1.4",
     "vericify": "*",
     "zod": "^4.3.6"
   },