@voybio/ace-swarm 2.4.8 → 2.4.10

package/dist/tools-scheduler.js

@@ -2,6 +2,7 @@
  * Job scheduler tool registrations.
  */
 import { z } from "zod";
+import { resolveWorkspaceRoot } from "./helpers.js";
 import { acknowledgeJob, completeJob, dispatchJobNow, dispatchJobs, enqueueJob, getJobLockTablePath, getJobQueuePath, getSchedulerLeasePath, heartbeatJob, reapStaleRunningJobsTick, readJobQueue, readJobLockTable, readSchedulerLease, } from "./job-scheduler.js";
 // Event emission handled in core job-scheduler.ts — no wrapper duplication.
 const PRIORITY_BAND_ENUM = z.enum(["P0", "P1", "P2", "P3"]);
@@ -22,6 +23,7 @@ function asJsonBlock(value) {
     return `\`\`\`json\n${JSON.stringify(value, null, 2)}\n\`\`\``;
 }
 export function registerSchedulerTools(server) {
+    const workspaceRoot = resolveWorkspaceRoot();
     server.tool("enqueue_job", "Add a handoff job to the scheduler queue with priority/dependency/resource metadata", {
         kind: z.string().describe("Job kind/type identifier"),
         payload: z
@@ -46,7 +48,7 @@ export function registerSchedulerTools(server) {
         backoff_ms: z.number().int().min(1000).max(86_400_000).optional(),
         job_id: z.string().optional().describe("Optional caller-provided job id"),
     }, async (input) => {
-        const result = await enqueueJob(input);
+        const result = await enqueueJob(input, workspaceRoot);
         return {
             content: [
                 {
@@ -78,15 +80,15 @@ export function registerSchedulerTools(server) {
             .describe("Include lock table payload (default true)"),
         limit: z.number().int().min(1).max(1000).optional().describe("Max jobs returned"),
     }, async ({ status, include_locks, limit }) => {
-        const queue = readJobQueue();
+        const queue = readJobQueue(workspaceRoot);
         const filtered = queue.jobs.filter((job) => (status ? job.status === status : true));
         const clipped = typeof limit === "number" ? filtered.slice(0, limit) : filtered;
-        const lockTable = readJobLockTable();
-        const lease = readSchedulerLease();
+        const lockTable = readJobLockTable(workspaceRoot);
+        const lease = readSchedulerLease(workspaceRoot);
         const payload = {
-            queue_path: getJobQueuePath(),
-            lock_path: getJobLockTablePath(),
-            lease_path: getSchedulerLeasePath(),
+            queue_path: getJobQueuePath(workspaceRoot),
+            lock_path: getJobLockTablePath(workspaceRoot),
+            lease_path: getSchedulerLeasePath(workspaceRoot),
             total_jobs: queue.jobs.length,
             returned_jobs: clipped.length,
             jobs: clipped,
@@ -109,7 +111,7 @@ export function registerSchedulerTools(server) {
         action: z.enum(["accept", "reject", "cancel", "resume"]),
         reason: z.string().optional(),
     }, async ({ job_id, action, reason }) => {
-        const result = await acknowledgeJob({ job_id, action, reason });
+        const result = await acknowledgeJob({ job_id, action, reason }, workspaceRoot);
         return {
             content: [
                 {
@@ -135,7 +137,7 @@ export function registerSchedulerTools(server) {
         lease_ttl_seconds: z.number().int().min(5).max(3600).optional(),
         now_iso: z.string().optional().describe("Optional deterministic clock override"),
     }, async (input) => {
-        const result = await dispatchJobs(input);
+        const result = await dispatchJobs(input, workspaceRoot);
         return {
             content: [
                 {
@@ -144,6 +146,7 @@ export function registerSchedulerTools(server) {
                         result.ok ? "✅ Scheduler dispatch completed" : "⚠️ Scheduler lease not acquired",
                         `Owner: ${result.owner}`,
                         `Lease acquired: ${result.lease_acquired}`,
+                        `Lease retained for execution: ${result.lease_retained}`,
                         `Queue: ${result.queue_path}`,
                         `Locks: ${result.lock_path}`,
                         asJsonBlock(result),
@@ -157,7 +160,7 @@ export function registerSchedulerTools(server) {
         owner: z.string().optional(),
         now_iso: z.string().optional(),
     }, async ({ job_id, owner, now_iso }) => {
-        const result = await dispatchJobNow({ job_id, owner, now_iso });
+        const result = await dispatchJobNow({ job_id, owner, now_iso }, workspaceRoot);
         return {
             content: [
                 {
@@ -184,7 +187,7 @@ export function registerSchedulerTools(server) {
             evidence_ref,
             error,
             now_iso,
-        });
+        }, workspaceRoot);
         return {
             content: [
                 {
@@ -202,7 +205,7 @@ export function registerSchedulerTools(server) {
         lease_ttl_seconds: z.number().int().min(5).max(3600).optional(),
         now_iso: z.string().optional().describe("Optional deterministic clock override"),
     }, async ({ job_id, owner, lease_ttl_seconds, now_iso }) => {
-        const result = await heartbeatJob({ job_id, owner, lease_ttl_seconds, now_iso });
+        const result = await heartbeatJob({ job_id, owner, lease_ttl_seconds, now_iso }, workspaceRoot);
         return {
             content: [
                 {
@@ -224,7 +227,7 @@ export function registerSchedulerTools(server) {
             .describe("Staleness window in seconds (default 120)"),
         now_iso: z.string().optional().describe("Optional deterministic clock override"),
     }, async ({ heartbeat_stale_seconds, now_iso }) => {
-        const result = await reapStaleRunningJobsTick({ heartbeat_stale_seconds, now_iso });
+        const result = await reapStaleRunningJobsTick({ heartbeat_stale_seconds, now_iso }, workspaceRoot);
         return {
             content: [
                 {
@@ -246,9 +249,9 @@ export function registerSchedulerTools(server) {
                 text: [
                     "# Lock Table",
                     "",
-                    `Path: ${getJobLockTablePath()}`,
+                    `Path: ${getJobLockTablePath(workspaceRoot)}`,
                     "",
-                    asJsonBlock(readJobLockTable()),
+                    asJsonBlock(readJobLockTable(workspaceRoot)),
                 ].join("\n"),
             },
         ],
@@ -260,9 +263,9 @@ export function registerSchedulerTools(server) {
                 text: [
                     "# Scheduler Lease",
                     "",
-                    `Path: ${getSchedulerLeasePath()}`,
+                    `Path: ${getSchedulerLeasePath(workspaceRoot)}`,
                     "",
-                    asJsonBlock(readSchedulerLease() ?? null),
+                    asJsonBlock(readSchedulerLease(workspaceRoot) ?? null),
                 ].join("\n"),
             },
         ],

package/dist/tools-todo.js

@@ -1,35 +1,44 @@
-/**
- * TODO, task management, and run-ledger tool registrations.
- */
+import { resolveCurrentWork, formatCurrentWork } from "./ace-autonomy.js";
 import { z } from "zod";
-import { ACE_TASKS_ROOT_REL, readTaskArtifact, resolveWritableTaskPath, safeWriteAsync, } from "./helpers.js";
+import { ACE_TASKS_ROOT_REL, resolveWritableTaskPath, } from "./helpers.js";
 import { TODO_STATUS_ENUM } from "./shared.js";
-import { appendTodoItemSafe, getTodoStatePath, readTodoState, syncTodoStateSafe, transitionTodoNodeSafe, } from "./todo-state.js";
+import { appendTodoItemSafe, deleteTodoItemSafe, getTodoStatePath, syncTodoStateSafe, transitionTodoNodeSafe, } from "./todo-state.js";
 import { appendRunLedgerEntrySafe, getRunLedgerPath, readRunLedger, } from "./run-ledger.js";
-import { refreshKanbanArtifacts } from "./kanban.js";
+import { formatKanbanRefresh, refreshKanbanArtifacts } from "./kanban.js";
+import { hostAgent } from './host-work-context.js';
+import { readStoreJsonSync } from './store/store-snapshot.js';
+import { resolveWorkspaceRoot } from './helpers.js';
+import { GoalRepository } from './store/repositories/goal-repository.js';
+import { deriveLinkedTodo } from './linked-work.js';
+function todoRefusal(reason_code, message, options = [{ tool: "get_todo_state", args: {}, why: "Read current task identities and statuses." }]) {
+    const now = formatCurrentWork(resolveCurrentWork(), "line");
+    return { isError: true, structuredContent: { reason_code, message, options, now }, content: [{ type: "text", text: [message, ...options.map((o) => `${o.tool}(${JSON.stringify(o.args)}): ${o.why}`), now].join("\n") }] };
+}
+function importNotes(result) {
+    return [...(result.import_warnings ?? []).map((warning) => `Import warning: ${warning}`), ...(result.projection_pending ? ["Canonical todo state is current; markdown refresh pending."] : [])].join("\n");
+}
 export function registerTodoTools(server) {
-    server.tool("get_todo", "Read the current swarm TODO execution board", {}, async () => ({
-        content: [{ type: "text", text: readTaskArtifact("todo") }],
-    }));
-    server.tool("get_todo_state", "Read synced TODO node state with dependencies and explicit statuses", {}, async () => ({
-        content: [
-            {
-                type: "text",
-                text: `# TODO State\n\nPath: ${getTodoStatePath()}\n\n\`\`\`json\n${JSON.stringify(readTodoState(), null, 2)}\n\`\`\``,
-            },
-        ],
-    }));
-    server.tool("update_todo", "Replace TODO board content, append a new TODO item, or transition a TODO node status with gate validation", {
+    server.tool("get_todo", "Read the current swarm TODO execution board", {}, async () => {
+        const synced = await syncTodoStateSafe();
+        return { structuredContent: { ...synced }, content: [{ type: "text", text: [synced.markdown, importNotes(synced)].filter(Boolean).join("\n") }] };
+    });
+    server.tool("get_todo_state", "Read synced TODO node state with dependencies and explicit statuses", {}, async () => {
+        const synced = await syncTodoStateSafe();
+        return { structuredContent: { ...synced }, content: [{ type: "text", text: `# TODO State\n\nPath: ${getTodoStatePath()}\n\n\`\`\`json\n${JSON.stringify(synced.state, null, 2)}\n\`\`\`\n${importNotes(synced)}` }] };
+    });
+    server.tool("update_todo", "Import TODO edits without deleting absent rows; append, explicitly delete, or transition a task", {
         new_content: z
             .string()
             .optional()
-            .describe("Full updated TODO markdown content (full replace mode)"),
+            .describe("TODO markdown to import; omitted rows are retained, use delete_id to remove"),
+        delete_id: z.string().optional().describe("Explicitly delete this task; omission from markdown never deletes"),
         node_id: z
             .string()
             .optional()
             .describe("Todo node id to transition (transition mode)"),
         status: TODO_STATUS_ENUM.optional().describe("Target status for transition mode"),
         note: z.string().optional().describe("Optional transition context note"),
+        agent: z.string().optional().describe('Host label when completing a linked goal step'),
         append_title: z
             .string()
             .optional()
@@ -48,146 +57,149 @@ export function registerTodoTools(server) {
             .string()
             .optional()
             .describe("Optional explicit node id for the new append-mode item"),
-    }, async ({ new_content, node_id, status, note, append_title, append_section, append_depends_on, append_id, }) => {
-        if (typeof append_title === "string") {
-            const appended = await appendTodoItemSafe(append_title, {
-                section: append_section,
-                depends_on: append_depends_on,
-                id: append_id,
-            });
-            if (!appended.ok) {
+    }, async ({ new_content, delete_id, node_id, status, note, append_title, append_section, append_depends_on, append_id, agent, }, extra) => {
+        try {
+            if (delete_id) {
+                const deleted = await deleteTodoItemSafe(delete_id);
+                if (!deleted.ok)
+                    return todoRefusal("unknown_todo", deleted.error ?? "Todo not found.");
+                const kanban = refreshKanbanArtifacts("tool:update_todo");
+                return { structuredContent: { ...deleted }, content: [{ type: "text", text: [`TODO deleted: ${delete_id}`, importNotes(deleted), formatKanbanRefresh(kanban)].filter(Boolean).join("\n") }] };
+            }
+            if (typeof append_title === "string") {
+                const appended = await appendTodoItemSafe(append_title, {
+                    section: append_section,
+                    depends_on: append_depends_on,
+                    id: append_id,
+                });
+                if (!appended.ok) {
+                    return todoRefusal("todo_append_rejected", appended.error ?? "Failed to append TODO item.");
+                }
+                const runLedger = await appendRunLedgerEntrySafe({
+                    tool: "update_todo",
+                    category: "info",
+                    message: `Appended TODO item ${appended.node_id}`,
+                    artifacts: [`${ACE_TASKS_ROOT_REL}/todo.md`, "agent-state/todo-state.json"],
+                    metadata: {
+                        mode: "append",
+                        node_id: appended.node_id,
+                        todo_id: appended.node_id,
+                        section: appended.section,
+                    },
+                });
+                const kanban = refreshKanbanArtifacts("tool:update_todo");
+                const counts = kanban.counts;
                 return {
+                    structuredContent: { ...appended },
                     content: [
-                        { type: "text", text: `❌ ${appended.error ?? "Failed to append TODO item."}` },
+                        {
+                            type: "text",
+                            text: [
+                                `✅ TODO item appended: ${appended.node_id}`,
+                                `Section: ${appended.section}`,
+                                `TODO state: ${appended.path}`,
+                                `TODO markdown: ${appended.todo_path}`,
+                                importNotes(appended),
+                                `Run ledger: ${runLedger.path} (${runLedger.entry.id})`,
+                                formatKanbanRefresh(kanban),
+                                `Kanban counts: backlog=${counts.backlog}, blocked=${counts.blocked}, in_progress=${counts.in_progress}, gated=${counts.gated}, done=${counts.done}`,
+                            ].join("\n"),
+                        },
                     ],
                 };
             }
-            const runLedger = await appendRunLedgerEntrySafe({
-                tool: "update_todo",
-                category: "info",
-                message: `Appended TODO item ${appended.node_id}`,
-                artifacts: [`${ACE_TASKS_ROOT_REL}/todo.md`, "agent-state/todo-state.json"],
-                metadata: {
-                    mode: "append",
-                    node_id: appended.node_id,
-                    section: appended.section,
-                },
-            });
-            const kanban = refreshKanbanArtifacts("tool:update_todo");
-            const counts = kanban.counts;
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: [
-                            `✅ TODO item appended: ${appended.node_id}`,
-                            `Section: ${appended.section}`,
-                            `TODO state: ${appended.path}`,
-                            `TODO markdown: ${appended.todo_path}`,
-                            `Run ledger: ${runLedger.path} (${runLedger.entry.id})`,
-                            `Kanban updated: ${kanban.html_path}`,
-                            `Kanban counts: backlog=${counts.backlog}, blocked=${counts.blocked}, in_progress=${counts.in_progress}, gated=${counts.gated}, done=${counts.done}`,
-                        ].join("\n"),
+            if (typeof new_content === "string") {
+                const synced = await syncTodoStateSafe(new_content);
+                const path = resolveWritableTaskPath("todo");
+                const runLedger = await appendRunLedgerEntrySafe({
+                    tool: "update_todo",
+                    category: "major_update",
+                    message: "Imported TODO markdown edits; omitted tasks retained",
+                    artifacts: [`${ACE_TASKS_ROOT_REL}/todo.md`, "agent-state/todo-state.json"],
+                    metadata: {
+                        mode: "replace",
+                        node_count: synced.state.order.length,
                     },
-                ],
-            };
-        }
-        if (typeof new_content === "string") {
-            const synced = await syncTodoStateSafe(new_content);
-            const path = await safeWriteAsync(resolveWritableTaskPath("todo"), new_content);
-            const runLedger = await appendRunLedgerEntrySafe({
-                tool: "update_todo",
-                category: "major_update",
-                message: "Replaced TODO markdown board content",
-                artifacts: [`${ACE_TASKS_ROOT_REL}/todo.md`, "agent-state/todo-state.json"],
-                metadata: {
-                    mode: "replace",
-                    node_count: synced.state.order.length,
-                },
-            });
-            const kanban = refreshKanbanArtifacts("tool:update_todo");
-            const counts = kanban.counts;
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: [
-                            `✅ TODO updated: ${path}`,
-                            `TODO state synced: ${synced.path}`,
-                            `Run ledger: ${runLedger.path} (${runLedger.entry.id})`,
-                            `Kanban updated: ${kanban.html_path}`,
-                            `Kanban counts: backlog=${counts.backlog}, blocked=${counts.blocked}, in_progress=${counts.in_progress}, gated=${counts.gated}, done=${counts.done}`,
-                        ].join("\n"),
-                    },
-                ],
-            };
-        }
-        if (node_id && status) {
-            const transition = await transitionTodoNodeSafe(node_id, status);
-            if (!transition.ok) {
-                const detailLines = [
-                    transition.error
-                        ? `❌ ${transition.error}`
-                        : "❌ TODO transition failed.",
-                    transition.node_id ? `Node: ${transition.node_id}` : "",
-                    transition.from && transition.to
-                        ? `Attempted: ${transition.from} -> ${transition.to}`
-                        : "",
-                    transition.allowed?.length
-                        ? `Allowed next states: ${transition.allowed.join(", ")}`
-                        : "",
-                    transition.unresolved_dependencies?.length
-                        ? `Unresolved dependencies: ${transition.unresolved_dependencies.join(", ")}`
-                        : "",
-                ].filter(Boolean);
+                });
+                const kanban = refreshKanbanArtifacts("tool:update_todo");
+                const counts = kanban.counts;
                 return {
-                    content: [{ type: "text", text: detailLines.join("\n") }],
+                    structuredContent: { ...synced },
+                    content: [
+                        {
+                            type: "text",
+                            text: [
+                                `✅ TODO updated: ${path}`,
+                                `TODO state synced: ${synced.path}`,
+                                importNotes(synced),
+                                `Run ledger: ${runLedger.path} (${runLedger.entry.id})`,
+                                formatKanbanRefresh(kanban),
+                                `Kanban counts: backlog=${counts.backlog}, blocked=${counts.blocked}, in_progress=${counts.in_progress}, gated=${counts.gated}, done=${counts.done}`,
+                            ].join("\n"),
+                        },
+                    ],
                 };
             }
-            const previous = transition.from ?? status;
-            const category = previous === "done" && status !== "done"
-                ? "regression"
-                : "major_update";
-            const runLedger = await appendRunLedgerEntrySafe({
-                tool: "update_todo",
-                category,
-                message: `Transitioned TODO node ${node_id}: ${previous} -> ${status}`,
-                artifacts: [`${ACE_TASKS_ROOT_REL}/todo.md`, "agent-state/todo-state.json"],
-                metadata: {
-                    mode: "transition",
-                    node_id,
-                    from: previous,
-                    to: status,
-                    note: note ?? "",
-                },
-            });
-            const kanban = refreshKanbanArtifacts("tool:update_todo");
-            const counts = kanban.counts;
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: [
-                            `✅ TODO transition applied: ${node_id}`,
-                            `Transition: ${previous} -> ${status}`,
-                            `TODO state: ${transition.path}`,
-                            `TODO markdown: ${transition.todo_path}`,
-                            `Run ledger: ${runLedger.path} (${runLedger.entry.id})`,
-                            `Kanban updated: ${kanban.html_path}`,
-                            `Kanban counts: backlog=${counts.backlog}, blocked=${counts.blocked}, in_progress=${counts.in_progress}, gated=${counts.gated}, done=${counts.done}`,
-                        ].join("\n"),
+            if (node_id && status) {
+                const rawTodo = readStoreJsonSync(resolveWorkspaceRoot(), `state/todo/${node_id}`);
+                const linked = rawTodo && deriveLinkedTodo(rawTodo, resolveWorkspaceRoot()).step_ref;
+                if (linked) {
+                    if (status !== 'done' && status !== 'blocked')
+                        return todoRefusal('linked_step_owned', 'This todo is a step view. Use next_step to start/resume its goal; complete_step records its outcome.');
+                    const step = new GoalRepository(resolveWorkspaceRoot()).getPlan(linked.goal_id)?.steps.find(s => s.step_id === linked.step_id);
+                    const { completeStep } = await import('./host-goal-engine.js');
+                    const result = await completeStep(linked.goal_id, linked.step_id, { status, summary: note || `Todo ${node_id} ${status}`, evidence: [{ ref: `host:todo:${node_id}`, kind: 'note', detail: note }] }, { agent: hostAgent(agent, extra.sessionId), attempt: step?.attempt ?? 0 });
+                    return { isError: !!result.isError, structuredContent: { ...result }, content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+                }
+                const transition = await transitionTodoNodeSafe(node_id, status);
+                if (!transition.ok) {
+                    const reason = transition.unresolved_dependencies?.length ? "todo_dependencies_unmet" : transition.allowed ? "todo_transition_invalid" : "unknown_todo";
+                    return todoRefusal(reason, [transition.error ?? "TODO transition failed.", transition.allowed?.length ? `Allowed next states: ${transition.allowed.join(", ")}.` : "", transition.unresolved_dependencies?.length ? `Waiting on: ${transition.unresolved_dependencies.join(", ")}.` : ""].filter(Boolean).join(" "));
+                }
+                const previous = transition.from ?? status;
+                const category = previous === "done" && status !== "done"
+                    ? "regression"
+                    : "major_update";
+                const runLedger = await appendRunLedgerEntrySafe({
+                    tool: "update_todo",
+                    category,
+                    message: `Transitioned TODO node ${node_id}: ${previous} -> ${status}`,
+                    artifacts: [`${ACE_TASKS_ROOT_REL}/todo.md`, "agent-state/todo-state.json"],
+                    metadata: {
+                        mode: "transition",
+                        node_id,
+                        todo_id: node_id,
+                        from: previous,
+                        to: status,
+                        note: note ?? "",
                     },
-                ],
-            };
+                });
+                const kanban = refreshKanbanArtifacts("tool:update_todo");
+                const counts = kanban.counts;
+                return {
+                    structuredContent: { ...transition },
+                    content: [
+                        {
+                            type: "text",
+                            text: [
+                                `✅ TODO transition applied: ${node_id}`,
+                                `Transition: ${previous} -> ${status}`,
+                                `TODO state: ${transition.path}`,
+                                `TODO markdown: ${transition.todo_path}`,
+                                importNotes(transition),
+                                `Run ledger: ${runLedger.path} (${runLedger.entry.id})`,
+                                formatKanbanRefresh(kanban),
+                                `Kanban counts: backlog=${counts.backlog}, blocked=${counts.blocked}, in_progress=${counts.in_progress}, gated=${counts.gated}, done=${counts.done}`,
+                            ].join("\n"),
+                        },
+                    ],
+                };
+            }
+            return todoRefusal("todo_arguments_missing", "Provide append_title, new_content, delete_id, or node_id with status.");
+        }
+        catch (error) {
+            return todoRefusal("todo_write_failed", `Could not save the todo change: ${error instanceof Error ? error.message : String(error)}`);
         }
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: "❌ Provide either `new_content` (full replace) or `node_id` + `status` (transition mode).",
-                },
-            ],
-        };
     });
     server.tool("get_run_ledger", "Read run-ledger milestone/regression history", {
         limit: z

package/dist/vericify-bridge.d.ts

@@ -137,6 +137,14 @@ export declare function appendVericifyProcessPostSafe(input: {
     post?: VericifyProcessPost;
     error?: string;
 }>;
+/**
+ * Compatibility sink for ACE-generated summaries. Native Vericify owns process
+ * capture; these duplicate posts are disabled unless an operator explicitly
+ * requests the legacy recorder. Manual APIs above remain available unchanged.
+ */
+export declare function appendAutomaticVericifyProcessPostSafe(input: Parameters<typeof appendVericifyProcessPostSafe>[0]): Promise<Awaited<ReturnType<typeof appendVericifyProcessPostSafe>> & {
+    skipped?: boolean;
+}>;
 export declare function buildVericifyBridgeSnapshot(): VericifyBridgeSnapshot;
 export declare function refreshVericifyBridgeSnapshot(): {
     ok: boolean;

package/dist/vericify-bridge.js

@@ -95,11 +95,17 @@ function parseBridgeSnapshot(raw) {
 function readBridgeConfig() {
     const config = readRuntimeProfile().observability.vericify_bridge ?? {
         enabled: false,
+        legacy_auto_posts: false,
+        native: { enabled: false },
         bridge_path: VERICIFY_BRIDGE_SNAPSHOT_REL_PATH,
         process_post_path: VERICIFY_PROCESS_POST_LOG_REL_PATH,
     };
     return {
         enabled: Boolean(config.enabled),
+        // Older profiles only carried `enabled`, which controls bridge reads and
+        // explicit manual APIs. It does not opt into a second automatic recorder.
+        legacy_auto_posts: config.legacy_auto_posts === true,
+        native_enabled: config.native?.enabled === true,
         bridge_path: config.bridge_path || VERICIFY_BRIDGE_SNAPSHOT_REL_PATH,
         process_post_path: config.process_post_path || VERICIFY_PROCESS_POST_LOG_REL_PATH,
     };
@@ -426,6 +432,18 @@ export async function appendVericifyProcessPostSafe(input) {
         };
     }
 }
+/**
+ * Compatibility sink for ACE-generated summaries. Native Vericify owns process
+ * capture; these duplicate posts are disabled unless an operator explicitly
+ * requests the legacy recorder. Manual APIs above remain available unchanged.
+ */
+export async function appendAutomaticVericifyProcessPostSafe(input) {
+    const config = readBridgeConfig();
+    if (!config.enabled || !config.legacy_auto_posts || config.native_enabled) {
+        return { ok: true, skipped: true, path: processPostLogPath() };
+    }
+    return appendVericifyProcessPostSafe(input);
+}
 function buildActiveRunRefs() {
     const executorRegistryPath = "agent-state/runtime-executor-sessions.json";
     const raw = readConfiguredText(executorRegistryPath);

package/dist/vericify-context.d.ts

@@ -1,10 +1,14 @@
+import { createNativeObservationAdapter } from "./vericify-native.js";
 export declare function getVericifyContextPacket(input?: {
     workspaceRoot?: string;
     runId?: string;
+    mode?: "configured" | "legacy";
 }): Promise<Record<string, unknown>>;
 export declare function getVericifyDelta(input: {
     since: string;
     workspaceRoot?: string;
     runId?: string;
+    mode?: "configured" | "legacy";
 }): Promise<Record<string, unknown>>;
+export declare function configuredObservationAdapter(workspaceRoot: string): ReturnType<typeof createNativeObservationAdapter> | undefined;
 //# sourceMappingURL=vericify-context.d.ts.map

package/dist/vericify-context.js

@@ -2,7 +2,9 @@ import { createRequire } from "node:module";
 import { existsSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { resolveWorkspaceRoot } from "./helpers.js";
+import { resolveWorkspaceRoot, withWorkspaceRoot } from "./helpers.js";
+import { readRuntimeProfile } from "./runtime-profile.js";
+import { createNativeObservationAdapter, getNativeVericifyContext } from "./vericify-native.js";
 const requireFromModule = createRequire(import.meta.url);
 const PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 function tryResolveVericifyApi(searchFrom) {
@@ -47,8 +49,8 @@ function resolveVericifyApiPath(workspaceRoot) {
         "or set VERICIFY_API_PATH to an installed `vericify/api` entry file.",
     ].join(" "));
 }
-async function loadVericifyApi(workspaceRoot) {
-    const apiPath = resolveVericifyApiPath(workspaceRoot);
+async function loadVericifyApi(workspaceRoot, explicitPath) {
+    const apiPath = explicitPath ? resolve(explicitPath) : resolveVericifyApiPath(workspaceRoot);
     const loaded = await import(pathToFileURL(apiPath).href);
     if (typeof loaded.loadWorkspaceState !== "function" ||
         typeof loaded.buildCompactPacket !== "function" ||
@@ -62,7 +64,12 @@ export async function getVericifyContextPacket(input) {
     const workspaceRoot = input?.workspaceRoot
         ? resolve(input.workspaceRoot)
         : resolveWorkspaceRoot();
-    const api = await loadVericifyApi(workspaceRoot);
+    const configured = input?.mode === "configured" ? configuredVericify(workspaceRoot) : undefined;
+    if (configured?.native?.enabled)
+        return { ...(await getNativeVericifyContext({ config: configured.native, workspaceRoot })) };
+    if (input?.mode === "configured" && !configured?.apiPath)
+        return { status: "unavailable", reason_code: "vericify_not_configured", records: [] };
+    const api = await loadVericifyApi(workspaceRoot, configured?.apiPath);
     const workspaceState = api.loadWorkspaceState(workspaceRoot);
     const projected = api.projectWorkspaceState(workspaceState);
     return api.buildCompactPacket(projected, {
@@ -73,7 +80,12 @@ export async function getVericifyDelta(input) {
     const workspaceRoot = input.workspaceRoot
         ? resolve(input.workspaceRoot)
         : resolveWorkspaceRoot();
-    const api = await loadVericifyApi(workspaceRoot);
+    const configured = input.mode === "configured" ? configuredVericify(workspaceRoot) : undefined;
+    if (configured?.native?.enabled)
+        return { ...(await getNativeVericifyContext({ config: configured.native, workspaceRoot, since: input.since })) };
+    if (input.mode === "configured" && !configured?.apiPath)
+        return { status: "unavailable", reason_code: "vericify_not_configured", records: [] };
+    const api = await loadVericifyApi(workspaceRoot, configured?.apiPath);
     const workspaceState = api.loadWorkspaceState(workspaceRoot);
     const projected = api.projectWorkspaceState(workspaceState);
     return api.buildCompactDelta(projected, {
@@ -81,4 +93,13 @@ export async function getVericifyDelta(input) {
         since: input.since,
     });
 }
+/** Explicit public configuration; programmatic legacy helpers above retain historical discovery. */
+function configuredVericify(workspaceRoot) {
+    const bridge = withWorkspaceRoot(workspaceRoot, () => readRuntimeProfile().observability.vericify_bridge);
+    return { native: bridge?.native, apiPath: bridge?.api_path || process.env.VERICIFY_API_PATH?.trim() };
+}
+export function configuredObservationAdapter(workspaceRoot) {
+    const config = configuredVericify(workspaceRoot).native;
+    return config?.enabled ? createNativeObservationAdapter(config, workspaceRoot) : undefined;
+}
 //# sourceMappingURL=vericify-context.js.map