@voybio/ace-swarm 0.2.5 → 2.4.1

package/dist/tools-framework.js

@@ -4,7 +4,7 @@
  */
 import { z } from "zod";
 import { bootstrapStoreWorkspace } from "./store/bootstrap-store.js";
-import { ACE_ROOT_REL, ACE_TASKS_ROOT_REL, ALL_MCP_CLIENTS, ALL_LLM_PROVIDERS, ALL_AGENTS, COMPOSABLE_AGENTS, SWARM_AGENTS, SWARM_SUBAGENT_MAP, WORKSPACE_ROOT, classifyPathSource, detectAssetDrift, getAllMcpServerConfigSnippets, getAgentInstructionPath, getAgentManifestPath, getKernelArtifactPath, getMcpClientInstallHint, getMcpServerConfigSnippet, getTaskArtifactPath, isSwarmRole, listAvailableSkills, normalizePathForValidation, resolveWorkspaceRoot, safeRead, safeWrite, withFileLock, wsPath, } from "./helpers.js";
+import { ACE_ROOT_REL, ACE_TASKS_ROOT_REL, ALL_MCP_CLIENTS, ALL_LLM_PROVIDERS, ALL_AGENTS, COMPOSABLE_AGENTS, SWARM_AGENTS, SWARM_SUBAGENT_MAP, WORKSPACE_ROOT, classifyPathSource, detectAssetDrift, getAllMcpServerConfigSnippets, getAgentInstructionPath, getAgentManifestPath, getKernelArtifactPath, getMcpClientInstallHint, getMcpServerConfigSnippet, getTaskArtifactPath, isSwarmRole, listAvailableSkills, normalizePathForValidation, resolveWorkspaceRoot, safeRead, safeWriteAsync, withFileLock, wsPath, } from "./helpers.js";
 import { getRoleTitle, MCP_CLIENT_ENUM, scoreDomains, } from "./shared.js";
 import { defaultModelForProvider, } from "./tui/provider-discovery.js";
 import { refreshAstgrepIndex } from "./astgrep-index.js";
@@ -21,6 +21,21 @@ import { auditStoreAuthority, writeStoreAuthorityAuditReport, } from "./store/st
 import { PROVENANCE_CRITICAL_EVENT_TYPES, validateArtifactManifestPayload, validateProvenanceLogContent, validateTealConfigContent, } from "./schemas.js";
 import { readAceTaskContractAssessment } from "./ace-autonomy.js";
 import { listStoreKeysSync, readStoreBlobSync } from "./store/store-snapshot.js";
+import { parseJsonLikeText } from "./json-sanitizer.js";
+function executionRoleForDomain(domain) {
+    switch (domain) {
+        case "venture":
+            return "vos";
+        case "ux":
+            return "ui";
+        case "engineering":
+            return "coders";
+        case "research":
+            return "research";
+        default:
+            return "orchestrator";
+    }
+}
 function getArtifactManifestEntries(payload) {
     if (!payload || typeof payload !== "object" || Array.isArray(payload))
         return [];
@@ -61,6 +76,14 @@ function parseGateManifest(raw, sourceRef) {
         return undefined;
     }
 }
+function parseJsonForValidation(raw) {
+    return parseJsonLikeText(raw);
+}
+function jsonValidationDetail(parsed, validDetail = "valid JSON") {
+    return parsed.sanitized.removed_control_bytes > 0
+        ? `control bytes removed before parse (${parsed.sanitized.removed_control_bytes}); source requires repair`
+        : validDetail;
+}
 function readGateManifests(gatesDir) {
     const files = readdirSync(gatesDir).filter((f) => f.endsWith(".json"));
     const allGates = [];
@@ -287,7 +310,7 @@ async function appendEvidenceLogEntrySafe(review) {
     const timestamp = new Date().toISOString();
     const anchor = `#ts:${timestamp}`;
     const evidenceRef = `agent-state/EVIDENCE_LOG.md${anchor}`;
-    return withFileLock("agent-state/EVIDENCE_LOG.md", () => {
+    return withFileLock("agent-state/EVIDENCE_LOG.md", async () => {
         const existing = safeRead("agent-state/EVIDENCE_LOG.md");
         const seed = existing.startsWith("[FILE NOT FOUND]") || existing.startsWith("[ACCESS DENIED]")
             ? "# EVIDENCE LOG\n\nAppend-only validation evidence.\n\n## Entries\n"
@@ -319,7 +342,7 @@ async function appendEvidenceLogEntrySafe(review) {
                 })
                 : ["  - none"]),
         ];
-        const path = safeWrite("agent-state/EVIDENCE_LOG.md", `${seed}${lines.join("\n")}\n`);
+        const path = await safeWriteAsync("agent-state/EVIDENCE_LOG.md", `${seed}${lines.join("\n")}\n`);
         return { path, evidenceRef };
     });
 }
@@ -534,6 +557,12 @@ export function registerFrameworkTools(server) {
             recommendedSubagents.add("memory");
         }
         return {
+            structuredContent: {
+                detected_domain: detected,
+                suggested_execution_role: executionRoleForDomain(detected),
+                default_entry_agent: "orchestrator",
+                task_contract_ok: taskContract.ok,
+            },
             content: [
                 {
                     type: "text",
@@ -635,7 +664,7 @@ export function registerFrameworkTools(server) {
             model: resolvedLlmModel ?? undefined,
             baseUrl: resolvedLlmBaseUrl ?? undefined,
         });
-        const astIndex = refreshAstgrepIndex({
+        const astIndex = await refreshAstgrepIndex({
             scope: ".",
             append_evidence: true,
             emit_event: true,
@@ -662,7 +691,7 @@ export function registerFrameworkTools(server) {
             category: "major_update",
             message: "Bootstrapped ACE workspace state",
             artifacts: [
-                `${ACE_ROOT_REL}/ace-state.ace`,
+                storeResult.storePath,
                 `${ACE_TASKS_ROOT_REL}/todo.md`,
                 normalizePathForValidation(delta.index_path),
                 "agent-state/AST_GREP_INDEX.json",
@@ -717,7 +746,10 @@ export function registerFrameworkTools(server) {
                                 "",
                                 "## LLM Runtime Profile",
                                 `- provider: ${llm_provider}`,
-                                `- model: ${resolvedLlmModel ?? defaultModelForProvider(llm_provider)}`,
+                                `- model: ${resolvedLlmModel ??
+                                    (llm_provider === "llama.cpp"
+                                        ? "(set via ace connect or ace doctor --scan)"
+                                        : defaultModelForProvider(llm_provider))}`,
                                 `- base_url: ${resolvedLlmBaseUrl ??
                                     (llm_provider === "ollama" || llm_provider === "llama.cpp"
                                         ? "discover via ace doctor --scan or set explicitly"
@@ -990,58 +1022,60 @@ export function registerFrameworkTools(server) {
         // Check: handoff registry parseable
         const hrRaw = safeRead("agent-state/handoff-registry.json");
         const hrOk = !hrRaw.startsWith("[FILE NOT FOUND]");
+        let hrParsed;
         if (hrOk) {
-            try {
-                JSON.parse(hrRaw);
+            const parsed = parseJsonForValidation(hrRaw);
+            if (parsed.ok) {
+                hrParsed = parsed.value;
                 checks.push({
                     name: "handoff-registry:parse",
-                    ok: true,
-                    detail: "valid JSON",
+                    ok: parsed.sanitized.removed_control_bytes === 0,
+                    detail: jsonValidationDetail(parsed),
                 });
             }
-            catch {
+            else {
                 checks.push({
                     name: "handoff-registry:parse",
                     ok: false,
-                    detail: "CORRUPT JSON",
+                    detail: `agent-state/handoff-registry.json: ${parsed.error}`,
                 });
             }
         }
         // Check: run-ledger parseable
         const rlRaw = safeRead("agent-state/run-ledger.json");
         if (!rlRaw.startsWith("[FILE NOT FOUND]")) {
-            try {
-                JSON.parse(rlRaw);
+            const parsed = parseJsonForValidation(rlRaw);
+            if (parsed.ok) {
                 checks.push({
                     name: "run-ledger:parse",
-                    ok: true,
-                    detail: "valid JSON",
+                    ok: parsed.sanitized.removed_control_bytes === 0,
+                    detail: jsonValidationDetail(parsed),
                 });
             }
-            catch {
+            else {
                 checks.push({
                     name: "run-ledger:parse",
                     ok: false,
-                    detail: "CORRUPT JSON",
+                    detail: `agent-state/run-ledger.json: ${parsed.error}`,
                 });
             }
         }
         // Check: todo-state parseable
         const tsRaw = safeRead("agent-state/todo-state.json");
         if (!tsRaw.startsWith("[FILE NOT FOUND]")) {
-            try {
-                JSON.parse(tsRaw);
+            const parsed = parseJsonForValidation(tsRaw);
+            if (parsed.ok) {
                 checks.push({
                     name: "todo-state:parse",
-                    ok: true,
-                    detail: "valid JSON",
+                    ok: parsed.sanitized.removed_control_bytes === 0,
+                    detail: jsonValidationDetail(parsed),
                 });
             }
-            catch {
+            else {
                 checks.push({
                     name: "todo-state:parse",
                     ok: false,
-                    detail: "CORRUPT JSON",
+                    detail: `agent-state/todo-state.json: ${parsed.error}`,
                 });
             }
         }
@@ -1061,19 +1095,19 @@ export function registerFrameworkTools(server) {
                 });
                 continue;
             }
-            try {
-                JSON.parse(raw);
+            const parsed = parseJsonForValidation(raw);
+            if (parsed.ok) {
                 checks.push({
                     name: check.name,
-                    ok: true,
-                    detail: "valid JSON",
+                    ok: parsed.sanitized.removed_control_bytes === 0,
+                    detail: jsonValidationDetail(parsed),
                 });
             }
-            catch {
+            else {
                 checks.push({
                     name: check.name,
                     ok: false,
-                    detail: "CORRUPT JSON",
+                    detail: `${check.rel}: ${parsed.error}`,
                 });
             }
         }
@@ -1127,25 +1161,28 @@ export function registerFrameworkTools(server) {
         const artifactManifestRaw = safeRead("agent-state/ARTIFACT_MANIFEST.json");
         let artifactManifestEntries = [];
         if (!artifactManifestRaw.startsWith("[FILE NOT FOUND]")) {
-            try {
-                const parsed = JSON.parse(artifactManifestRaw);
-                const validation = validateArtifactManifestPayload(parsed);
+            const parsed = parseJsonForValidation(artifactManifestRaw);
+            if (parsed.ok) {
+                const validation = validateArtifactManifestPayload(parsed.value);
+                const controlBytesOk = parsed.sanitized.removed_control_bytes === 0;
                 checks.push({
                     name: "artifact-manifest:schema",
-                    ok: validation.ok,
-                    detail: validation.ok
-                        ? `valid (${validation.schema})`
-                        : validation.errors.join("; "),
+                    ok: validation.ok && controlBytesOk,
+                    detail: !controlBytesOk
+                        ? jsonValidationDetail(parsed)
+                        : validation.ok
+                            ? `valid (${validation.schema})`
+                            : validation.errors.join("; "),
                 });
                 if (validation.ok) {
-                    artifactManifestEntries = getArtifactManifestEntries(parsed);
+                    artifactManifestEntries = getArtifactManifestEntries(parsed.value);
                 }
             }
-            catch {
+            else {
                 checks.push({
                     name: "artifact-manifest:parse",
                     ok: false,
-                    detail: "CORRUPT JSON",
+                    detail: `agent-state/ARTIFACT_MANIFEST.json: ${parsed.error}`,
                 });
             }
         }
@@ -1183,8 +1220,16 @@ export function registerFrameworkTools(server) {
         // Check: module registry role coverage vs event emitters
         const registryRaw = safeRead("agent-state/MODULES/registry.json");
         if (!registryRaw.startsWith("[FILE NOT FOUND]")) {
-            try {
-                const registry = JSON.parse(registryRaw);
+            const parsed = parseJsonForValidation(registryRaw);
+            if (parsed.ok) {
+                if (parsed.sanitized.removed_control_bytes > 0) {
+                    checks.push({
+                        name: "registry:parse",
+                        ok: false,
+                        detail: jsonValidationDetail(parsed),
+                    });
+                }
+                const registry = parsed.value;
                 const registeredRoles = new Set(registry.roles ?? []);
                 const expectedEmitters = [
                     "capability-safety",
@@ -1203,11 +1248,11 @@ export function registerFrameworkTools(server) {
                     });
                 }
             }
-            catch {
+            else {
                 checks.push({
                     name: "registry:parse",
                     ok: false,
-                    detail: "registry.json is corrupt",
+                    detail: `agent-state/MODULES/registry.json: ${parsed.error}`,
                 });
             }
         }
@@ -1228,30 +1273,24 @@ export function registerFrameworkTools(server) {
             });
         }
         // Check: handoff consistency (open handoffs have source files)
-        if (hrOk) {
-            try {
-                const registry = JSON.parse(hrRaw);
-                const handoffs = Object.values(registry.handoffs ?? {});
-                let openWithoutFile = 0;
-                for (const h of handoffs) {
-                    if ((h.status === "open" || h.status === "accepted") &&
-                        h.source_file) {
-                        const fileContent = safeRead(h.source_file);
-                        if (fileContent.startsWith("[FILE NOT FOUND]"))
-                            openWithoutFile++;
-                    }
+        if (hrOk && hrParsed) {
+            const handoffs = Object.values(hrParsed.handoffs ?? {});
+            let openWithoutFile = 0;
+            for (const h of handoffs) {
+                if ((h.status === "open" || h.status === "accepted") &&
+                    h.source_file) {
+                    const fileContent = safeRead(h.source_file);
+                    if (fileContent.startsWith("[FILE NOT FOUND]"))
+                        openWithoutFile++;
                 }
-                checks.push({
-                    name: "handoff:source-file-integrity",
-                    ok: openWithoutFile === 0,
-                    detail: openWithoutFile === 0
-                        ? "all open handoffs have source files"
-                        : `${openWithoutFile} open handoffs reference missing source files`,
-                });
-            }
-            catch {
-                /* already caught above */
             }
+            checks.push({
+                name: "handoff:source-file-integrity",
+                ok: openWithoutFile === 0,
+                detail: openWithoutFile === 0
+                    ? "all open handoffs have source files"
+                    : `${openWithoutFile} open handoffs reference missing source files`,
+            });
         }
         // Check: event provenance gaps in recent events.
         // Scans for provenance-critical event types that are missing

package/dist/tools-handoff.js

@@ -3,7 +3,7 @@
  */
 import { randomUUID } from "node:crypto";
 import { z } from "zod";
-import { ACE_TASKS_ROOT_REL, normalizePathForValidation, readTaskArtifact, safeWrite, wsPath, WORKSPACE_ROOT, } from "./helpers.js";
+import { ACE_TASKS_ROOT_REL, normalizePathForValidation, readTaskArtifact, safeWriteAsync, wsPath, WORKSPACE_ROOT, } from "./helpers.js";
 import { ROLE_ENUM, HANDOFF_VALIDATION_MODE, HANDOFF_LIFECYCLE_STATUS_ENUM, } from "./shared.js";
 import { validateHandoffPayload, validateSwarmHandoffPayload, lintHandoffPayload, } from "./schemas.js";
 import { acknowledgeHandoffSafe, getHandoffRegistryPath, readHandoffRegistry, registerHandoffSafe, } from "./handoff-registry.js";
@@ -247,7 +247,7 @@ export function registerHandoffTools(server) {
             .replace("T", "-")
             .slice(0, 15);
         const filePath = wsPath("tasks", `SWARM_HANDOFF.${from}_to_${to}_${timeStr}_${shortId}.json`);
-        safeWrite(filePath, JSON.stringify(handoff, null, 2));
+        await safeWriteAsync(filePath, JSON.stringify(handoff, null, 2));
         const registry = await registerHandoffSafe({
             handoff_id: handoff.handoff_id,
             from: handoff.router.from,

package/dist/tools-lifecycle.js

@@ -2,8 +2,8 @@
  * Lifecycle tool registrations: status events, circuit breaker, and kanban.
  */
 import { z } from "zod";
-import { safeRead, safeWrite } from "./helpers.js";
-import { appendStatusEventSafe, getStatusEventsPath, readStatusEvents, } from "./status-events.js";
+import { safeRead, safeWriteAsync } from "./helpers.js";
+import { appendStatusEventSafe, getStatusEventsPath, readStatusEvents } from "./status-events.js";
 import { refreshKanbanArtifacts } from "./kanban.js";
 export function registerLifecycleTools(server) {
     server.tool("emit_status_event", "Append a schema-valid lifecycle event into agent-state/STATUS_EVENTS.ndjson", {
@@ -119,7 +119,7 @@ export function registerLifecycleTools(server) {
             ? "# STATUS\n\n"
             : current.trimEnd();
         const next = `${seed}\n- [${timestamp}] CIRCUIT_BREAKER_OPENED: ${reason}${owner ? ` (owner: ${owner})` : ""}\n`;
-        const statusPath = safeWrite("agent-state/STATUS.md", next);
+        const statusPath = await safeWriteAsync("agent-state/STATUS.md", next);
         const event = await appendStatusEventSafe({
             source_module: "capability-ops",
             event_type: "CIRCUIT_BREAKER_OPENED",
@@ -158,7 +158,7 @@ export function registerLifecycleTools(server) {
             ? "# STATUS\n\n"
             : current.trimEnd();
         const next = `${seed}\n- [${timestamp}] CIRCUIT_BREAKER_CLOSED: ${reason}\n`;
-        const statusPath = safeWrite("agent-state/STATUS.md", next);
+        const statusPath = await safeWriteAsync("agent-state/STATUS.md", next);
         const event = await appendStatusEventSafe({
             source_module: "capability-ops",
             event_type: "CIRCUIT_BREAKER_CLOSED",

package/dist/tools-memory.js

@@ -3,7 +3,7 @@
  */
 import { existsSync } from "node:fs";
 import { z } from "zod";
-import { resolveWorkspaceRoot, safeRead, safeWrite, wsPath } from "./helpers.js";
+import { resolveWorkspaceRoot, safeRead, safeWriteAsync, wsPath } from "./helpers.js";
 import { isReadError } from "./shared.js";
 import { appendRunLedgerEntrySafe } from "./run-ledger.js";
 import { appendStatusEventSafe } from "./status-events.js";
@@ -13,7 +13,7 @@ import { openStore } from "./store/ace-packed-store.js";
 import { ProjectionManager } from "./store/materializers/projection-manager.js";
 import { ContextSnapshotRepository } from "./store/repositories/context-snapshot-repository.js";
 import { getWorkspaceStorePath, storeExistsSync, toVirtualStorePath, } from "./store/store-snapshot.js";
-import { withStoreWriteQueue } from "./store/write-queue.js";
+import { withStoreWriteCoordinator } from "./store/write-coordinator.js";
 const CONTEXT_STORE_REL = "agent-state/context-snapshots";
 export function registerMemoryTools(server) {
     server.tool("context_snapshot", "Capture a named context snapshot for later retrieval (decisions, progress, state)", {
@@ -41,7 +41,7 @@ export function registerMemoryTools(server) {
         let path = wsPath(CONTEXT_STORE_REL, `${name}.json`);
         if (storeExistsSync(root) && existsSync(getWorkspaceStorePath(root))) {
             const storePath = getWorkspaceStorePath(root);
-            const saved = await withStoreWriteQueue(storePath, async () => {
+            const saved = await withStoreWriteCoordinator(storePath, async () => {
                 const store = await openStore(storePath);
                 try {
                     const repo = new ContextSnapshotRepository(store);
@@ -62,7 +62,7 @@ export function registerMemoryTools(server) {
                 finally {
                     await store.close();
                 }
-            });
+            }, { operation_label: "contextSnapshotSave" });
             path = toVirtualStorePath(storePath, `state/memory/context_snapshots/${saved.file}`);
         }
         else {
@@ -82,7 +82,7 @@ export function registerMemoryTools(server) {
                 .slice(0, 48);
             const filename = `${slug}.json`;
             path = wsPath(CONTEXT_STORE_REL, filename);
-            safeWrite(path, JSON.stringify(snapshot, null, 2));
+            await safeWriteAsync(path, JSON.stringify(snapshot, null, 2));
             const indexPath = wsPath(CONTEXT_STORE_REL, "index.json");
             const indexRaw = safeRead(indexPath);
             let index = { snapshots: [] };
@@ -97,7 +97,7 @@ export function registerMemoryTools(server) {
             index.snapshots = index.snapshots.filter((s) => s.name !== name);
             index.snapshots.push({ name, file: filename, timestamp, summary });
             index.snapshots.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
-            safeWrite(indexPath, JSON.stringify(index, null, 2));
+            await safeWriteAsync(indexPath, JSON.stringify(index, null, 2));
         }
         const ledger = await appendRunLedgerEntrySafe({
             tool: "context_snapshot",

package/dist/tools-todo.js

@@ -2,7 +2,7 @@
  * TODO, task management, and run-ledger tool registrations.
  */
 import { z } from "zod";
-import { ACE_TASKS_ROOT_REL, readTaskArtifact, resolveWritableTaskPath, safeWrite, } from "./helpers.js";
+import { ACE_TASKS_ROOT_REL, readTaskArtifact, resolveWritableTaskPath, safeWriteAsync, } from "./helpers.js";
 import { TODO_STATUS_ENUM } from "./shared.js";
 import { getTodoStatePath, readTodoState, syncTodoStateSafe, transitionTodoNodeSafe, } from "./todo-state.js";
 import { appendRunLedgerEntrySafe, getRunLedgerPath, readRunLedger, } from "./run-ledger.js";
@@ -33,7 +33,7 @@ export function registerTodoTools(server) {
     }, async ({ new_content, node_id, status, note }) => {
         if (typeof new_content === "string") {
             const synced = await syncTodoStateSafe(new_content);
-            const path = safeWrite(resolveWritableTaskPath("todo"), new_content);
+            const path = await safeWriteAsync(resolveWritableTaskPath("todo"), new_content);
             const runLedger = await appendRunLedgerEntrySafe({
                 tool: "update_todo",
                 category: "major_update",

package/dist/tracker-adapters.d.ts

@@ -67,7 +67,7 @@ export declare function validateTrackerSnapshotContent(raw: string): ValidationR
 export declare function loadTrackerSnapshot(explicitPath?: string): TrackerSnapshotResult;
 export declare function readTrackerSnapshot(): TrackerSnapshot;
 export declare function getTrackerSnapshotPath(): string;
-export declare function writeTrackerSnapshot(snapshot: TrackerSnapshot): string;
+export declare function writeTrackerSnapshot(snapshot: TrackerSnapshot): Promise<string>;
 export declare function listTrackerAdapterKinds(): string[];
 export declare function getTrackerAdapter(kind?: string): IssueTrackerAdapter;
 export declare function buildDefaultTrackerSnapshot(kind?: TrackerAdapterKind): TrackerSnapshot;

package/dist/tracker-adapters.js

@@ -1,11 +1,12 @@
 import { randomUUID } from "node:crypto";
 import { spawn } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync, } from "node:fs";
-import { dirname, resolve } from "node:path";
+import { existsSync, readFileSync, } from "node:fs";
+import { resolve } from "node:path";
 import { DEFAULTS_ROOT, resolveWorkspaceArtifactPath as resolveWorkspaceArtifactPathHelper, resolveWorkspaceRoot, } from "./helpers.js";
 import { validateTrackerSnapshotPayload } from "./schemas.js";
-import { appendStatusEvent } from "./status-events.js";
+import { appendStatusEventSafe } from "./status-events.js";
 import { readRuntimeProfile } from "./runtime-profile.js";
+import { safeWriteAsync } from "./helpers.js";
 export const TRACKER_SNAPSHOT_REL_PATH = "agent-state/tracker-snapshot.json";
 export const TRACKER_SNAPSHOT_SCHEMA_REL_PATH = "agent-state/MODULES/schemas/TRACKER_SNAPSHOT.schema.json";
 export const TRACKER_SNAPSHOT_SCHEMA_NAME = "tracker-snapshot@1.0.0";
@@ -40,14 +41,6 @@ function resolveTrackerSnapshotTarget(explicitPath) {
 function resolveWorkspaceArtifactPath(filePath) {
     return resolveWorkspaceArtifactPathHelper(filePath, "write");
 }
-function safeWriteWorkspaceFile(filePath, content) {
-    const abs = resolveWorkspaceArtifactPath(filePath);
-    mkdirSync(dirname(abs), { recursive: true });
-    const tmpPath = `${abs}.${process.pid}.${Date.now()}.tmp`;
-    writeFileSync(tmpPath, content, "utf-8");
-    renameSync(tmpPath, abs);
-    return abs;
-}
 function normalizeTrackerItem(item) {
     return {
         ...item,
@@ -150,12 +143,14 @@ function filterTrackerItems(items, filter) {
 }
 function emitTrackerEvent(eventType, summary, payload) {
     try {
-        appendStatusEvent({
+        void appendStatusEventSafe({
             source_module: "capability-framework",
             event_type: eventType,
             status: eventType === "TRACKER_SNAPSHOT_REFRESH_FAILED" ? "fail" : "done",
             summary,
             payload,
+        }).catch(() => {
+            // Tracker operations must not fail because event logging failed.
         });
     }
     catch {
@@ -455,7 +450,7 @@ async function githubCreateComment(itemId, body) {
             }),
         ];
         nextSnapshot.updated_at = now;
-        writeTrackerSnapshot(nextSnapshot);
+        await writeTrackerSnapshot(nextSnapshot);
         emitTrackerEvent("TRACKER_COMMENT_CREATED", `Tracker comment created for ${issue.item_id}.`, {
             adapter_kind: "external",
             provider: "github",
@@ -502,7 +497,7 @@ async function githubUpdateItemState(itemId, state) {
     try {
         const issue = (await githubGetIssuesById([itemId]))[0];
         const snapshot = upsertTrackerItem(readOrBuildExternalSnapshot(), issue);
-        writeTrackerSnapshot(snapshot);
+        await writeTrackerSnapshot(snapshot);
         emitTrackerEvent("TRACKER_ITEM_STATE_UPDATED", `Tracker item ${issue.item_id} moved to ${issue.state}.`, {
             adapter_kind: "external",
             provider: "github",
@@ -569,13 +564,13 @@ export function readTrackerSnapshot() {
 export function getTrackerSnapshotPath() {
     return resolveTrackerSnapshotTarget().path;
 }
-export function writeTrackerSnapshot(snapshot) {
+export async function writeTrackerSnapshot(snapshot) {
     const normalized = normalizeTrackerSnapshot(snapshot);
     const validation = validateTrackerSnapshotPayload(normalized);
     if (!validation.ok) {
         throw new Error(`Tracker snapshot failed validation (${validation.schema}): ${validation.errors.join("; ")}`);
     }
-    return safeWriteWorkspaceFile(TRACKER_SNAPSHOT_REL_PATH, JSON.stringify(normalized, null, 2));
+    return safeWriteAsync(TRACKER_SNAPSHOT_REL_PATH, JSON.stringify(normalized, null, 2));
 }
 const noneTrackerAdapter = {
     kind: "none",
@@ -700,7 +695,7 @@ const memoryTrackerAdapter = {
                 updated_at: now,
                 comments: [...snapshot.comments, comment],
             };
-            writeTrackerSnapshot(nextSnapshot);
+            await writeTrackerSnapshot(nextSnapshot);
             emitTrackerEvent("TRACKER_COMMENT_CREATED", `Tracker comment created for ${comment.item_id}.`, {
                 adapter_kind: "memory",
                 item_id: comment.item_id,
@@ -743,7 +738,7 @@ const memoryTrackerAdapter = {
                 updated_at: now,
                 items,
             };
-            writeTrackerSnapshot(nextSnapshot);
+            await writeTrackerSnapshot(nextSnapshot);
             emitTrackerEvent("TRACKER_ITEM_STATE_UPDATED", `Tracker item ${items[itemIndex].item_id} moved to ${nextState}.`, {
                 adapter_kind: "memory",
                 item_id: items[itemIndex].item_id,

package/dist/tracker-sync.js

@@ -2,15 +2,17 @@ import { resolve } from "node:path";
 import { resolveWorkspaceRoot } from "./helpers.js";
 import { readRuntimeProfile } from "./runtime-profile.js";
 import { buildDefaultTrackerSnapshot, getTrackerAdapter, writeTrackerSnapshot, readTrackerSnapshot, TRACKER_SNAPSHOT_REL_PATH, } from "./tracker-adapters.js";
-import { appendStatusEvent } from "./status-events.js";
+import { appendStatusEventSafe } from "./status-events.js";
 function emitTrackerSyncEvent(eventType, summary, payload) {
     try {
-        appendStatusEvent({
+        void appendStatusEventSafe({
             source_module: "capability-framework",
             event_type: eventType,
             status: eventType === "TRACKER_SNAPSHOT_REFRESH_FAILED" ? "fail" : "done",
             summary,
             payload,
+        }).catch(() => {
+            // Snapshot refresh must not fail because observability logging failed.
         });
     }
     catch {
@@ -52,7 +54,7 @@ export async function refreshTrackerSnapshot(kind) {
                 items,
             };
         }
-        const writtenPath = writeTrackerSnapshot(snapshot);
+        const writtenPath = await writeTrackerSnapshot(snapshot);
         emitTrackerSyncEvent("TRACKER_SNAPSHOT_REFRESHED", `Tracker snapshot refreshed using ${snapshot.adapter_kind}.`, {
             adapter_kind: snapshot.adapter_kind,
             snapshot_path: writtenPath,

package/dist/tui/agent-runner.js

@@ -17,7 +17,9 @@ import { readAgentInstructions } from "../helpers.js";
 export class AgentRunner extends EventEmitter {
     agents = new Map();
     workspaceRoot;
-    startupTimeoutMs = 5000;
+    // Full-suite test runs can heavily contend CPU/IO while workers bootstrap.
+    // Keep startup resilient to transient contention before declaring failure.
+    startupTimeoutMs = 12000;
     constructor(workspaceRoot) {
         super();
         this.workspaceRoot = workspaceRoot;