@voybio/ace-swarm 2.4.3 → 2.4.6

package/dist/server.js

@@ -1,7 +1,8 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
 import { buildServerInstructions, installAceToolGovernance, } from "./ace-server-instructions.js";
 import { resolveWorkspaceRoot } from "./helpers.js";
 import { openStore } from "./store/ace-packed-store.js";
@@ -11,7 +12,21 @@ import { registerResources } from "./resources.js";
 import { registerTools } from "./tools.js";
 import { backfillHandoffsIntoScheduler } from "./tools-handoff.js";
 export const ACE_MCP_SERVER_NAME = "ace-swarm";
-export const ACE_MCP_SERVER_VERSION = "0.2.1";
+// Report the true package version to MCP clients instead of a stale hard-coded string.
+function resolvePackageVersion() {
+    try {
+        // dist/server.js → package root is one level up from dist/.
+        const pkgPath = join(dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+        const parsed = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        if (typeof parsed.version === "string" && parsed.version.length > 0)
+            return parsed.version;
+    }
+    catch {
+        // fall through to the compiled fallback
+    }
+    return "0.0.0";
+}
+export const ACE_MCP_SERVER_VERSION = resolvePackageVersion();
 const HERMES_SHADOW_INSTRUCTIONS = "ACE filtered shadow MCP tool transport for Hermes-local execution. Only tools allowed by the active ACE capability snapshot are registered; public ACE prompts and resources are not exposed.";
 export function createAceServer(options = {}) {
     const workspaceRoot = resolveWorkspaceRoot();
@@ -77,7 +92,40 @@ async function verifyMcpStoreStartup(workspaceRoot, logStartup) {
         console.error(message);
     return false;
 }
-export async function startStdioServer(logStartup = true) {
+/**
+ * Curated premium-host surface (report WS-G). ~15–25 high-value tools instead of the
+ * full tool surface, cutting the per-session schema tax. Everything omitted here remains reachable
+ * via `run_orchestrator` delegation or by starting with `--profile full`. Goal-engine
+ * tools (start_goal/…) are intentionally absent until WS-F ships.
+ */
+export const HOST_MIN_TOOL_PROFILE = [
+    "recall_context",
+    "route_task",
+    "run_orchestrator",
+    "propose_plan",
+    "validate_plan",
+    "create_handoff",
+    "ack_handoff",
+    "get_handoff_status",
+    "execute_gates",
+    "emit_status_event",
+    "append_vericify_process_post",
+    "get_vericify_context",
+    "get_vericify_delta",
+    "astgrep_locate",
+    "compile_structural_edit",
+    "preview_structural_edit",
+    "astgrep_rewrite",
+    "safe_edit_file",
+    "run_tests",
+    "run_local_model",
+    "context_snapshot",
+    "build_continuity_packet",
+];
+export function resolveHostProfileAllowlist(profile) {
+    return profile === "host-min" ? HOST_MIN_TOOL_PROFILE : undefined;
+}
+export async function startStdioServer(logStartup = true, profile = "full") {
     const workspaceRoot = resolveWorkspaceRoot();
     if (!(await verifyMcpStoreStartup(workspaceRoot, logStartup))) {
         return;
@@ -93,11 +141,13 @@ export async function startStdioServer(logStartup = true) {
             console.error(`Scheduler backfill warning: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
-    const server = createAceServer();
+    const toolAllowlist = resolveHostProfileAllowlist(profile);
+    const server = createAceServer({ toolAllowlist });
     const transport = new StdioServerTransport();
     await server.connect(transport);
     if (logStartup) {
-        console.error(`ACE MCP Server (${ACE_MCP_SERVER_NAME}) running on stdio`);
+        console.error(`ACE MCP Server (${ACE_MCP_SERVER_NAME}) running on stdio` +
+            (toolAllowlist ? ` (profile=${profile}, ${toolAllowlist.length} tools)` : ` (profile=${profile})`));
     }
 }
 export async function startHermesShadowStdioServer(toolAllowlist, logStartup = false) {

package/dist/shared.d.ts

@@ -87,6 +87,15 @@ export declare const EVENT_TYPE: {
     readonly GIT_INITIALIZED: "GIT_INITIALIZED";
     readonly GIT_COMMITTED: "GIT_COMMITTED";
     readonly HANDOFF_SCHEDULER_SYNCED: "HANDOFF_SCHEDULER_SYNCED";
+    readonly MCP_BINARY_PARSE_ERROR: "MCP_BINARY_PARSE_ERROR";
+    readonly MODEL_BRIDGE_COMPLETION_BLOCKED: "MODEL_BRIDGE_COMPLETION_BLOCKED";
+    readonly MODEL_CONTEXT_OVERFLOW_SUSPECTED: "MODEL_CONTEXT_OVERFLOW_SUSPECTED";
+    readonly OLLAMA_MODEL_LOAD_ERROR: "OLLAMA_MODEL_LOAD_ERROR";
+    readonly OLLAMA_REPAIR_ATTEMPTED: "OLLAMA_REPAIR_ATTEMPTED";
+    readonly ORCHESTRATOR_STEP: "ORCHESTRATOR_STEP";
+    readonly PLAN_UPDATE: "PLAN_UPDATE";
+    readonly PLAYBOOK_CURATED: "PLAYBOOK_CURATED";
+    readonly PLAYBOOK_REFLECT_FAILED: "PLAYBOOK_REFLECT_FAILED";
     readonly RUNTIME_EXECUTOR_SESSION_BLOCKED: "RUNTIME_EXECUTOR_SESSION_BLOCKED";
     readonly RUNTIME_EXECUTOR_SESSION_COMPLETED: "RUNTIME_EXECUTOR_SESSION_COMPLETED";
     readonly RUNTIME_EXECUTOR_SESSION_FAILED: "RUNTIME_EXECUTOR_SESSION_FAILED";
@@ -109,6 +118,8 @@ export declare const EVENT_TYPE: {
     readonly SCHEDULER_JOB_STARTED: "SCHEDULER_JOB_STARTED";
     readonly SCHEDULER_RECOVERY: "SCHEDULER_RECOVERY";
     readonly SCHEDULER_TICK: "SCHEDULER_TICK";
+    readonly SCHEDULER_WATCHDOG: "SCHEDULER_WATCHDOG";
+    readonly STRUCTURAL_LANE_FENCED: "STRUCTURAL_LANE_FENCED";
     readonly TESTS_PASSED: "TESTS_PASSED";
     readonly TESTS_FAILED: "TESTS_FAILED";
     readonly TRACKER_COMMENT_CREATED: "TRACKER_COMMENT_CREATED";
@@ -120,6 +131,7 @@ export declare const EVENT_TYPE: {
     readonly WORKSPACE_SESSION_CREATED: "WORKSPACE_SESSION_CREATED";
     readonly WORKSPACE_SESSION_FAILED: "WORKSPACE_SESSION_FAILED";
     readonly WORKSPACE_SESSION_REMOVED: "WORKSPACE_SESSION_REMOVED";
+    readonly WORKSPACE_WRITE_REJECTED: "WORKSPACE_WRITE_REJECTED";
 };
 export interface DomainKeyword {
     keyword: string;

package/dist/shared.js

@@ -132,6 +132,15 @@ export const EVENT_TYPE = {
     GIT_INITIALIZED: "GIT_INITIALIZED",
     GIT_COMMITTED: "GIT_COMMITTED",
     HANDOFF_SCHEDULER_SYNCED: "HANDOFF_SCHEDULER_SYNCED",
+    MCP_BINARY_PARSE_ERROR: "MCP_BINARY_PARSE_ERROR",
+    MODEL_BRIDGE_COMPLETION_BLOCKED: "MODEL_BRIDGE_COMPLETION_BLOCKED",
+    MODEL_CONTEXT_OVERFLOW_SUSPECTED: "MODEL_CONTEXT_OVERFLOW_SUSPECTED",
+    OLLAMA_MODEL_LOAD_ERROR: "OLLAMA_MODEL_LOAD_ERROR",
+    OLLAMA_REPAIR_ATTEMPTED: "OLLAMA_REPAIR_ATTEMPTED",
+    ORCHESTRATOR_STEP: "ORCHESTRATOR_STEP",
+    PLAN_UPDATE: "PLAN_UPDATE",
+    PLAYBOOK_CURATED: "PLAYBOOK_CURATED",
+    PLAYBOOK_REFLECT_FAILED: "PLAYBOOK_REFLECT_FAILED",
     RUNTIME_EXECUTOR_SESSION_BLOCKED: "RUNTIME_EXECUTOR_SESSION_BLOCKED",
     RUNTIME_EXECUTOR_SESSION_COMPLETED: "RUNTIME_EXECUTOR_SESSION_COMPLETED",
     RUNTIME_EXECUTOR_SESSION_FAILED: "RUNTIME_EXECUTOR_SESSION_FAILED",
@@ -154,6 +163,8 @@ export const EVENT_TYPE = {
     SCHEDULER_JOB_STARTED: "SCHEDULER_JOB_STARTED",
     SCHEDULER_RECOVERY: "SCHEDULER_RECOVERY",
     SCHEDULER_TICK: "SCHEDULER_TICK",
+    SCHEDULER_WATCHDOG: "SCHEDULER_WATCHDOG",
+    STRUCTURAL_LANE_FENCED: "STRUCTURAL_LANE_FENCED",
     TESTS_PASSED: "TESTS_PASSED",
     TESTS_FAILED: "TESTS_FAILED",
     TRACKER_COMMENT_CREATED: "TRACKER_COMMENT_CREATED",
@@ -164,7 +175,8 @@ export const EVENT_TYPE = {
     WORKSPACE_HOOK_FAILED: "WORKSPACE_HOOK_FAILED",
     WORKSPACE_SESSION_CREATED: "WORKSPACE_SESSION_CREATED",
     WORKSPACE_SESSION_FAILED: "WORKSPACE_SESSION_FAILED",
-    WORKSPACE_SESSION_REMOVED: "WORKSPACE_SESSION_REMOVED"
+    WORKSPACE_SESSION_REMOVED: "WORKSPACE_SESSION_REMOVED",
+    WORKSPACE_WRITE_REJECTED: "WORKSPACE_WRITE_REJECTED",
 };
 export const DOMAIN_KEYWORDS = {
     venture: [

package/dist/source-mutation-coordinator.d.ts

@@ -0,0 +1,54 @@
+export type SourceEditEventType = "SOURCE_EDIT_LEASE_ACQUIRED" | "SOURCE_EDIT_CONFLICT" | "SOURCE_EDIT_COMMITTED";
+export interface SourceEditEvent {
+    event: SourceEditEventType;
+    target_path: string;
+    timestamp: string;
+    pid: number;
+    hostname: string;
+    lock_path?: string;
+    waited_ms?: number;
+    base_hash?: string;
+    expected_hash?: string;
+    observed_hash?: string;
+    committed_hash?: string;
+    reason_code?: string;
+}
+export interface SourceMutationCoordinatorOptions {
+    agent_id?: string;
+    wait_ms?: number;
+    poll_interval_ms?: number;
+    lease_ttl_ms?: number;
+    stale_grace_ms?: number;
+}
+export interface SourceEditLeaseInfo {
+    token: string;
+    targetPath: string;
+    lockPath: string;
+    metadataPath: string;
+    pid: number;
+    hostname: string;
+    agentId?: string;
+    acquiredAt: string;
+    expiresAt: string;
+    ttlMs: number;
+    waitedMs: number;
+}
+export declare class SourceEditLeaseBusyError extends Error {
+    readonly reason_code = "source_edit_lease_busy";
+    readonly targetPath: string;
+    readonly lockPath: string;
+    readonly waitedMs: number;
+    readonly currentHolder?: SourceEditLeaseInfo;
+    constructor(input: {
+        targetPath: string;
+        lockPath: string;
+        waitedMs: number;
+        currentHolder?: SourceEditLeaseInfo;
+    });
+}
+export declare function sourceEditLockPath(targetPath: string): string;
+export declare function appendSourceEditEvent(event: Omit<SourceEditEvent, "timestamp" | "pid" | "hostname">): void;
+/** Test/CLI hook: resolves when everything buffered so far has been flushed. */
+export declare function waitForSourceEditEventFlush(): Promise<void>;
+export declare function withSourceMutationCoordinatorSync<T>(targetPath: string, fn: (lease: SourceEditLeaseInfo) => T, options?: SourceMutationCoordinatorOptions): T;
+//# sourceMappingURL=source-mutation-coordinator.d.ts.map

package/dist/source-mutation-coordinator.js

@@ -0,0 +1,259 @@
+import { randomUUID } from "node:crypto";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { hostname } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { wsPath } from "./helpers.js";
+import { normalizeRelPath, slugify } from "./shared.js";
+import { getWorkspaceStorePath, readStoreBlobSync } from "./store/store-snapshot.js";
+import { writeStoreBlobSync } from "./store/store-artifacts.js";
+import { withStoreWriteCoordinator } from "./store/write-coordinator.js";
+const DEFAULT_WAIT_MS = 15_000;
+const DEFAULT_POLL_INTERVAL_MS = 100;
+const DEFAULT_LEASE_TTL_MS = 30_000;
+const DEFAULT_STALE_GRACE_MS = 1_000;
+const SOURCE_EDIT_EVENTS_KEY = "state/source-edit-events.ndjson";
+const SOURCE_EDIT_EVENTS_ARCHIVE_KEY = "state/source-edit-events-archive.ndjson";
+const MAX_SOURCE_EDIT_EVENT_LINES = 2000; // mirror status-events.ts MAX_EVENT_LINES
+let pendingSourceEditLines = [];
+let sourceEditFlush;
+export class SourceEditLeaseBusyError extends Error {
+    reason_code = "source_edit_lease_busy";
+    targetPath;
+    lockPath;
+    waitedMs;
+    currentHolder;
+    constructor(input) {
+        super(input.currentHolder
+            ? `Source edit lease busy for ${input.targetPath}; held by pid=${input.currentHolder.pid} hostname=${input.currentHolder.hostname}`
+            : `Source edit lease busy for ${input.targetPath}; no lease metadata available`);
+        this.name = "SourceEditLeaseBusyError";
+        this.targetPath = input.targetPath;
+        this.lockPath = input.lockPath;
+        this.waitedMs = input.waitedMs;
+        this.currentHolder = input.currentHolder;
+    }
+}
+function sleepSync(ms) {
+    if (ms <= 0)
+        return;
+    const shared = new SharedArrayBuffer(4);
+    const view = new Int32Array(shared);
+    Atomics.wait(view, 0, 0, ms);
+}
+function lockSlugForPath(targetPath) {
+    const normalized = normalizeRelPath(targetPath);
+    const digest = randomStableSuffix(normalized);
+    return `${slugify(normalized) || "root"}-${digest}`;
+}
+function randomStableSuffix(value) {
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < value.length; i += 1) {
+        hash ^= value.charCodeAt(i);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return (hash >>> 0).toString(16).padStart(8, "0");
+}
+export function sourceEditLockPath(targetPath) {
+    return wsPath(".ace-staging", "locks", `file__${lockSlugForPath(targetPath)}.lock`);
+}
+function leaseMetadataPath(lockPath) {
+    return join(lockPath, "lease.json");
+}
+function normalizeLeaseRecord(record) {
+    if (!record)
+        return undefined;
+    if (typeof record.token !== "string" ||
+        typeof record.targetPath !== "string" ||
+        typeof record.lockPath !== "string" ||
+        typeof record.metadataPath !== "string" ||
+        typeof record.pid !== "number" ||
+        typeof record.hostname !== "string" ||
+        typeof record.acquiredAt !== "string" ||
+        typeof record.expiresAt !== "string" ||
+        typeof record.ttlMs !== "number" ||
+        typeof record.waitedMs !== "number") {
+        return undefined;
+    }
+    return {
+        token: record.token,
+        targetPath: record.targetPath,
+        lockPath: record.lockPath,
+        metadataPath: record.metadataPath,
+        pid: record.pid,
+        hostname: record.hostname,
+        agentId: typeof record.agentId === "string" ? record.agentId : undefined,
+        acquiredAt: record.acquiredAt,
+        expiresAt: record.expiresAt,
+        ttlMs: record.ttlMs,
+        waitedMs: record.waitedMs,
+    };
+}
+function readLeaseRecord(lockPath) {
+    const metadataPath = leaseMetadataPath(lockPath);
+    if (!existsSync(metadataPath))
+        return undefined;
+    try {
+        const parsed = JSON.parse(readFileSync(metadataPath, "utf-8"));
+        return normalizeLeaseRecord(parsed);
+    }
+    catch {
+        return undefined;
+    }
+}
+function leaseIsStale(lease, staleGraceMs) {
+    const expiresAt = Date.parse(lease.expiresAt);
+    if (!Number.isFinite(expiresAt))
+        return true;
+    return Date.now() > expiresAt + staleGraceMs;
+}
+function canRecoverStaleLease(lease, staleGraceMs) {
+    if (!leaseIsStale(lease, staleGraceMs))
+        return false;
+    if (lease.hostname !== hostname())
+        return false;
+    try {
+        process.kill(lease.pid, 0);
+        return false;
+    }
+    catch (error) {
+        return error instanceof Error && "code" in error && error.code === "ESRCH";
+    }
+}
+function createLeaseRecord(targetPath, lockPath, options, waitedMs) {
+    const ttlMs = options.lease_ttl_ms ?? DEFAULT_LEASE_TTL_MS;
+    const acquiredAtMs = Date.now();
+    return {
+        token: randomUUID(),
+        targetPath,
+        lockPath,
+        metadataPath: leaseMetadataPath(lockPath),
+        pid: process.pid,
+        hostname: hostname(),
+        agentId: options.agent_id,
+        acquiredAt: new Date(acquiredAtMs).toISOString(),
+        expiresAt: new Date(acquiredAtMs + ttlMs).toISOString(),
+        ttlMs,
+        waitedMs,
+    };
+}
+function tryAcquireLease(targetPath, lockPath, options, waitedMs) {
+    mkdirSync(dirname(lockPath), { recursive: true });
+    mkdirSync(lockPath, { recursive: false });
+    const lease = createLeaseRecord(targetPath, lockPath, options, waitedMs);
+    writeFileSync(lease.metadataPath, JSON.stringify({ kind: "source_edit_lease", ...lease }, null, 2), "utf-8");
+    return lease;
+}
+function acquireLease(targetPath, options) {
+    const lockPath = sourceEditLockPath(targetPath);
+    const waitMs = options.wait_ms ?? DEFAULT_WAIT_MS;
+    const pollIntervalMs = options.poll_interval_ms ?? DEFAULT_POLL_INTERVAL_MS;
+    const staleGraceMs = options.stale_grace_ms ?? DEFAULT_STALE_GRACE_MS;
+    const startedAt = Date.now();
+    while (Date.now() - startedAt <= waitMs) {
+        try {
+            return tryAcquireLease(targetPath, lockPath, options, Date.now() - startedAt);
+        }
+        catch (error) {
+            const isBusy = error instanceof Error &&
+                "code" in error &&
+                error.code === "EEXIST";
+            if (!isBusy)
+                throw error;
+            const current = readLeaseRecord(lockPath);
+            if (current && canRecoverStaleLease(current, staleGraceMs)) {
+                rmSync(lockPath, { recursive: true, force: true });
+                continue;
+            }
+            sleepSync(Math.min(pollIntervalMs, waitMs));
+        }
+    }
+    throw new SourceEditLeaseBusyError({
+        targetPath,
+        lockPath,
+        waitedMs: Date.now() - startedAt,
+        currentHolder: readLeaseRecord(lockPath),
+    });
+}
+function releaseLease(lease) {
+    const current = readLeaseRecord(lease.lockPath);
+    if (!current) {
+        rmSync(lease.lockPath, { recursive: true, force: true });
+        return;
+    }
+    if (current.token !== lease.token) {
+        throw new Error(`Source edit lease token mismatch while releasing ${lease.targetPath}`);
+    }
+    rmSync(lease.lockPath, { recursive: true, force: true });
+}
+export function appendSourceEditEvent(event) {
+    const payload = {
+        ...event,
+        timestamp: new Date().toISOString(),
+        pid: process.pid,
+        hostname: hostname(),
+    };
+    const workspaceRoot = wsPath();
+    if (existsSync(getWorkspaceStorePath(workspaceRoot))) {
+        pendingSourceEditLines.push(JSON.stringify(payload));
+        scheduleSourceEditFlush(workspaceRoot);
+        return;
+    }
+    const eventsPath = wsPath("agent-state", "source-edit-events.ndjson");
+    mkdirSync(dirname(eventsPath), { recursive: true });
+    appendFileSync(eventsPath, `${JSON.stringify(payload)}\n`, "utf-8");
+}
+function scheduleSourceEditFlush(workspaceRoot) {
+    if (sourceEditFlush)
+        return; // one in-flight flush drains everything queued behind it
+    sourceEditFlush = flushSourceEditEvents(workspaceRoot).finally(() => {
+        sourceEditFlush = undefined;
+        if (pendingSourceEditLines.length > 0)
+            scheduleSourceEditFlush(workspaceRoot);
+    });
+}
+async function flushSourceEditEvents(workspaceRoot) {
+    const storePath = getWorkspaceStorePath(workspaceRoot);
+    try {
+        await withStoreWriteCoordinator(storePath, async () => {
+            const lines = pendingSourceEditLines;
+            if (lines.length === 0)
+                return;
+            pendingSourceEditLines = [];
+            const existing = readStoreBlobSync(workspaceRoot, SOURCE_EDIT_EVENTS_KEY) ?? "";
+            const merged = `${existing.replace(/\n?$/, existing ? "\n" : "")}${lines.join("\n")}\n`;
+            const all = merged.split("\n").filter((l) => l.trim().length > 0);
+            if (all.length > MAX_SOURCE_EDIT_EVENT_LINES) {
+                const excess = all.splice(0, all.length - MAX_SOURCE_EDIT_EVENT_LINES);
+                const archive = readStoreBlobSync(workspaceRoot, SOURCE_EDIT_EVENTS_ARCHIVE_KEY) ?? "";
+                writeStoreBlobSync(workspaceRoot, SOURCE_EDIT_EVENTS_ARCHIVE_KEY, `${archive.replace(/\n?$/, archive ? "\n" : "")}${excess.join("\n")}\n`);
+            }
+            writeStoreBlobSync(workspaceRoot, SOURCE_EDIT_EVENTS_KEY, all.join("\n") + "\n");
+        }, { operation_label: "sourceEditEvents.flush" });
+    }
+    catch (error) {
+        console.error(`source-edit event flush skipped: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/** Test/CLI hook: resolves when everything buffered so far has been flushed. */
+export async function waitForSourceEditEventFlush() {
+    while (sourceEditFlush || pendingSourceEditLines.length > 0) {
+        await (sourceEditFlush ?? Promise.resolve());
+    }
+}
+export function withSourceMutationCoordinatorSync(targetPath, fn, options = {}) {
+    const normalizedTarget = normalizeRelPath(targetPath);
+    const lease = acquireLease(normalizedTarget, options);
+    appendSourceEditEvent({
+        event: "SOURCE_EDIT_LEASE_ACQUIRED",
+        target_path: normalizedTarget,
+        lock_path: resolve(lease.lockPath),
+        waited_ms: lease.waitedMs,
+    });
+    try {
+        return fn(lease);
+    }
+    finally {
+        releaseLease(lease);
+    }
+}
+//# sourceMappingURL=source-mutation-coordinator.js.map

package/dist/status-events.d.ts

@@ -10,6 +10,9 @@ export interface AppendStatusEventInput {
     objective_id?: string;
     decision_id?: string;
 }
+export interface AppendStatusEventOptions {
+    workspaceRoot?: string;
+}
 export interface StatusEventRecord {
     schema_version: "1.0.0";
     event_id: string;
@@ -31,7 +34,7 @@ export declare function appendStatusEvent(input: AppendStatusEventInput): {
  * Concurrency-safe variant of appendStatusEvent.
  * Use this from async tool handlers where parallel subagents may fire.
  */
-export declare function appendStatusEventSafe(input: AppendStatusEventInput): Promise<{
+export declare function appendStatusEventSafe(input: AppendStatusEventInput, options?: AppendStatusEventOptions): Promise<{
     path: string;
     event: StatusEventRecord;
 }>;

package/dist/status-events.js

@@ -1,5 +1,6 @@
 import { randomUUID } from "node:crypto";
-import { existsSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
 import { resolveWorkspaceRoot, resolveWorkspaceArtifactPath as resolveWorkspaceArtifactPathHelper, safeRead, safeWrite, } from "./helpers.js";
 import { isReadError } from "./shared.js";
 import { validateStatusEventPayload, PROVENANCE_CRITICAL_EVENT_TYPES } from "./schemas.js";
@@ -52,8 +53,8 @@ function safeReadWorkspaceFile(filePath) {
 function safeWriteWorkspaceFile(filePath, content) {
     return safeWrite(filePath, content);
 }
-async function withDynamicFileLock(path, fn) {
-    const key = resolveWorkspaceArtifactPath(path);
+async function withDynamicFileLock(path, fn, root) {
+    const key = root ? join(root, path) : resolveWorkspaceArtifactPath(path);
     const prev = _fileLocks.get(key) ?? Promise.resolve();
     let releaseLock;
     const next = new Promise((resolveLock) => {
@@ -77,6 +78,12 @@ function readExistingNdjson() {
     }
     return existing.trimEnd();
 }
+function readExistingNdjsonAtRoot(root) {
+    const path = join(root, STATUS_EVENTS_REL_PATH);
+    if (!existsSync(path))
+        return "";
+    return readFileSync(path, "utf-8").trimEnd();
+}
 function rotateIfNeeded(content) {
     const lines = content.split("\n").filter((l) => l.trim().length > 0);
     if (lines.length <= MAX_EVENT_LINES)
@@ -90,6 +97,31 @@ function rotateIfNeeded(content) {
     safeWriteWorkspaceFile(STATUS_EVENTS_ARCHIVE_REL, archiveFull);
     return lines.join("\n") + "\n";
 }
+function rotateIfNeededAtRoot(root, content) {
+    const lines = content.split("\n").filter((l) => l.trim().length > 0);
+    if (lines.length <= MAX_EVENT_LINES)
+        return content;
+    const excess = lines.splice(0, lines.length - MAX_EVENT_LINES);
+    const archiveContent = excess.join("\n") + "\n";
+    const archivePath = join(root, STATUS_EVENTS_ARCHIVE_REL);
+    const existingArchive = existsSync(archivePath) ? readFileSync(archivePath, "utf-8") : "";
+    const archiveFull = existingArchive.trim().length === 0
+        ? archiveContent
+        : `${existingArchive.trimEnd()}\n${archiveContent}`;
+    mkdirSync(dirname(archivePath), { recursive: true });
+    writeFileSync(archivePath, archiveFull, "utf-8");
+    return lines.join("\n") + "\n";
+}
+function appendStatusEventToRoot(root, event) {
+    const existing = readExistingNdjsonAtRoot(root);
+    const line = JSON.stringify(event);
+    const combined = existing.length > 0 ? `${existing}\n${line}\n` : `${line}\n`;
+    const next = rotateIfNeededAtRoot(root, combined);
+    const path = join(root, STATUS_EVENTS_REL_PATH);
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, next, "utf-8");
+    return { path, event };
+}
 async function mirrorStatusEventToStore(root, event) {
     const storePath = getWorkspaceStorePath(root);
     if (!existsSync(storePath))
@@ -186,16 +218,19 @@ export function appendStatusEvent(input) {
  * Concurrency-safe variant of appendStatusEvent.
  * Use this from async tool handlers where parallel subagents may fire.
  */
-export async function appendStatusEventSafe(input) {
-    const root = workspaceRoot();
+export async function appendStatusEventSafe(input, options = {}) {
+    const root = options.workspaceRoot ?? workspaceRoot();
     return withDynamicFileLock(STATUS_EVENTS_REL_PATH, async () => {
         const event = buildStatusEvent(input);
         validateStatusEvent(event);
         if (storeExistsSync(root)) {
             return appendStatusEventStoreBacked(root, event);
         }
+        if (options.workspaceRoot) {
+            return appendStatusEventToRoot(root, event);
+        }
         return appendStatusEvent(input);
-    });
+    }, options.workspaceRoot);
 }
 function mapStoreTrackerEvent(record) {
     const metadata = record.metadata ?? {};

package/dist/store/ace-packed-store.d.ts

@@ -2,9 +2,9 @@
  * AcePackedStore — ACEPACK v2
  *
  * Single-file binary store. One file, no subdirectories, no companion files.
- * Events grow in the columnar section indefinitely (Option A). compact() only
- * reclaims dead space in the KV chunk region — it does NOT reset or archive
- * events. Historical event replay across all past runs is always available.
+ * Recent events live in the hot columnar section. Older contiguous event
+ * prefixes can be moved into BGZF-compressed KV archive batches with
+ * archiveColdEvents(); getEntries() reads both layers transparently.
  *
  * File layout:
  *
@@ -45,14 +45,27 @@
  * Timestamp/kind scanning reads only the fixed-width columns, never the pool.
  *
  * compact() removes dead KV space (overwritten keys) via atomic tmp-rename.
- * Events are preserved across compact() — they accumulate for the workspace
- * lifetime. See HOT_COLD_EVENT_TIERING.md for a future branch that adds
- * BGZF batch archiving for very long-lived workspaces.
+ * Events are preserved across compact(). For very long-lived workspaces,
+ * archiveColdEvents() moves old event prefixes into archive/events/* BGZF
+ * batches and advances evtBaseId.
  *
  * Backward compat: v1 files (64-byte header) are migrated on first commit().
  * v1 events live in core/log/ KV blobs and are pulled into the columnar section.
  */
 import { IAcePackedStore, UnifiedEntry, EntryFilter, TopologyEntry, ContentSourceCode } from "./types.js";
+export declare class AcePackedStoreCorruptionError extends Error {
+    constructor(message: string);
+}
+interface ArchiveColdEventsOptions {
+    olderThanMs?: number;
+    maxEventsPerBatch?: number;
+    now?: number;
+}
+export interface ArchiveColdEventsResult {
+    batches_written: number;
+    events_archived: number;
+    bytes_written: number;
+}
 export declare class AcePackedStore implements IAcePackedStore {
     private storePath;
     private readOnly;
@@ -65,6 +78,7 @@ export declare class AcePackedStore implements IAcePackedStore {
     private committed;
     private pending;
     private evtBaseId;
+    private skippedMalformedCount;
     open(path: string, opts?: {
         readOnly?: boolean;
     }): Promise<void>;
@@ -73,13 +87,14 @@ export declare class AcePackedStore implements IAcePackedStore {
     commit(): Promise<void>;
     /**
      * Compacts the KV chunk region — removes dead space left by overwritten keys.
-     * Events are NOT reset or archived; they accumulate in the columnar section
-     * for the workspace lifetime (Option A — grow forever).
-     * See HOT_COLD_EVENT_TIERING.md for the future branch that adds BGZF archiving.
+     * Events are preserved exactly as currently tiered. Use archiveColdEvents()
+     * first when old hot events should move into BGZF archive batches.
      */
     compact(): Promise<void>;
     close(): Promise<void>;
     get(key: string): Promise<Uint8Array | undefined>;
+    /** Events dropped as malformed since this instance was opened (v1 migration only). */
+    get skippedMalformedEventCount(): number;
     set(key: string, value: Uint8Array): Promise<void>;
     delete(key: string): Promise<boolean>;
     list(): AsyncGenerator<string>;
@@ -88,6 +103,9 @@ export declare class AcePackedStore implements IAcePackedStore {
     getBlob(key: string): Promise<string | undefined>;
     setBlob(key: string, content: string): Promise<void>;
     appendEntry(entry: Omit<UnifiedEntry, "id" | "ts">): Promise<UnifiedEntry>;
+    private readArchiveIndex;
+    private getArchivedEntries;
+    archiveColdEvents(options?: ArchiveColdEventsOptions): Promise<ArchiveColdEventsResult>;
     getEntries(filter?: EntryFilter): Promise<UnifiedEntry[]>;
     getEntry(_key: string): Promise<UnifiedEntry | undefined>;
     getTopology(kind: string): Promise<TopologyEntry[]>;
@@ -106,4 +124,5 @@ export declare class AcePackedStore implements IAcePackedStore {
 export declare function openStore(storePath: string, opts?: {
     readOnly?: boolean;
 }): Promise<AcePackedStore>;
+export {};
 //# sourceMappingURL=ace-packed-store.d.ts.map