@voybio/ace-swarm 2.4.9 → 2.4.10

package/dist/playbook-curator.js

@@ -1,7 +1,7 @@
 import { calculateJaccard, getShingles } from "./semantic-hash.js";
 import { appendStatusEventSafe } from "./status-events.js";
 function scopeEqualOrBroader(candidate, incoming) {
-    return Object.entries(candidate).every(([key, value]) => value === undefined || incoming[key] === value);
+    return Object.entries(candidate).every(([key, value]) => value === undefined || JSON.stringify(incoming[key]) === JSON.stringify(value));
 }
 function mergeEvidence(a, b) {
     return [...new Set([...a, ...b])].slice(0, 5);
@@ -43,7 +43,7 @@ export async function curate(repo, ops, config = {}) {
         }
         const incomingShingles = getShingles(op.content, 3);
         const match = repo
-            .listBullets({ section: op.section, status: "active" })
+            .listBullets({ section: op.section, ...(op.status === "quarantined" ? {} : { status: "active" }) })
             .filter((bullet) => scopeEqualOrBroader(bullet.scope, op.scope))
             .map((bullet) => ({
             bullet,
@@ -55,6 +55,7 @@ export async function curate(repo, ops, config = {}) {
                 ...match.bullet,
                 observed_count: match.bullet.observed_count + 1,
                 evidence_refs: mergeEvidence(match.bullet.evidence_refs, op.evidence_refs),
+                evidence_snapshots: [...new Map([...(match.bullet.evidence_snapshots ?? []), ...(op.evidence_snapshots ?? [])].map(e => [e.id, e])).values()],
             });
             result.merged += 1;
         }
@@ -69,13 +70,14 @@ export async function curate(repo, ops, config = {}) {
     }
     result.pruned += pruneOverflow(repo, config);
     const eventWorkspaceRoot = config.workspaceRoot ?? repo.root;
-    await appendStatusEventSafe({
-        event_type: "PLAYBOOK_CURATED",
-        source_module: "capability-build",
-        status: "done",
-        summary: `Playbook curated: added=${result.added} merged=${result.merged} tagged=${result.tagged} quarantined=${result.quarantined} pruned=${result.pruned}`,
-        payload: { ...result },
-    }, eventWorkspaceRoot ? { workspaceRoot: eventWorkspaceRoot } : {});
+    if (config.emitEvent !== false && Object.values(result).some(n => n > 0))
+        await appendStatusEventSafe({
+            event_type: "PLAYBOOK_CURATED",
+            source_module: "capability-build",
+            status: "done",
+            summary: `Playbook curated: added=${result.added} merged=${result.merged} tagged=${result.tagged} quarantined=${result.quarantined} pruned=${result.pruned}`,
+            payload: { ...result },
+        }, eventWorkspaceRoot ? { workspaceRoot: eventWorkspaceRoot } : {});
     return result;
 }
 function pruneOverflow(repo, config) {

package/dist/process-identity.d.ts

@@ -0,0 +1,8 @@
+export interface ProcessIdentity {
+    pid: number;
+    started_at: string;
+    hostname: string;
+}
+export declare function readProcessIdentity(pid: number): ProcessIdentity | undefined;
+export declare function probeProcess(identity: ProcessIdentity): 'alive' | 'dead' | 'unknown';
+//# sourceMappingURL=process-identity.d.ts.map

package/dist/process-identity.js

@@ -0,0 +1,38 @@
+/** OS identity, not just a PID: do not signal a reused or unverifiable process. */
+import { execFileSync } from 'node:child_process';
+import { hostname } from 'node:os';
+export function readProcessIdentity(pid) {
+    if (!Number.isSafeInteger(pid) || pid <= 1)
+        return undefined;
+    try {
+        const row = execFileSync('ps', ['-p', String(pid), '-o', 'lstart=', '-o', 'stat='], { encoding: 'utf8', timeout: 2000 }).trim();
+        const match = row.match(/^(.+?)\s+(\S+)$/);
+        if (!match || /^[ZX]/.test(match[2]))
+            return undefined;
+        return { pid, started_at: match[1].trim().replace(/\s+/g, ' '), hostname: hostname() };
+    }
+    catch {
+        return undefined;
+    }
+}
+export function probeProcess(identity) {
+    if (identity.hostname !== hostname())
+        return 'unknown';
+    const observed = readProcessIdentity(identity.pid);
+    if (observed)
+        return observed.started_at === identity.started_at ? 'alive' : 'dead';
+    try {
+        const stat = execFileSync('ps', ['-p', String(identity.pid), '-o', 'stat='], { encoding: 'utf8', timeout: 2000 }).trim();
+        if (/^[ZX]/.test(stat))
+            return 'dead';
+    }
+    catch { /* Permission and transient OS errors are not proof of death. */ }
+    try {
+        process.kill(identity.pid, 0);
+        return 'unknown';
+    }
+    catch (error) {
+        return error.code === 'ESRCH' ? 'dead' : 'unknown';
+    }
+}
+//# sourceMappingURL=process-identity.js.map

package/dist/progress-command.d.ts

@@ -0,0 +1,34 @@
+import { type ProcessIdentity } from './process-identity.js';
+export interface CommandPolicy {
+    stall_min?: number;
+    kill_min?: number;
+    deadline_min?: number;
+}
+export interface CommandProgress {
+    pid?: number;
+    started_at: string;
+    last_output_at?: string;
+    last_progress_at: string;
+    elapsed_ms: number;
+    silence_ms: number;
+    output_tail: string;
+    status: 'running' | 'suspected_stall' | 'terminating' | 'done' | 'failed';
+    reason_code?: string;
+}
+export interface CommandOptions extends CommandPolicy {
+    signal?: AbortSignal;
+    log_path?: string;
+    poll_interval_ms?: number;
+    onProgress?: (progress: CommandProgress) => void | Promise<void>;
+    onSpawn?: (identity: ProcessIdentity) => void | Promise<void>;
+}
+export interface CommandResult {
+    ok: boolean;
+    output: string;
+    exit_code: number | null;
+    duration_ms: number;
+    reason_code?: string;
+}
+export declare function resolveCommandPolicy(options?: CommandPolicy): Required<Omit<CommandPolicy, 'deadline_min'>> & Pick<CommandPolicy, 'deadline_min'>;
+export declare function runProgressCommand(command: string, root: string, options?: CommandOptions): Promise<CommandResult>;
+//# sourceMappingURL=progress-command.d.ts.map

package/dist/progress-command.js

@@ -0,0 +1,153 @@
+/** One process-group command runner shared by verification, tests and staged checks. */
+import { spawn } from 'node:child_process';
+import { appendFileSync, mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { readProcessIdentity } from './process-identity.js';
+export function resolveCommandPolicy(options = {}) {
+    const stall = options.stall_min ?? 10;
+    const kill = stall === 0 ? 0 : options.kill_min ?? Math.max(60, stall);
+    for (const [key, value] of Object.entries({ stall_min: stall, kill_min: kill, deadline_min: options.deadline_min })) {
+        if (value !== undefined && (!Number.isFinite(value) || value < 0 || (key === 'deadline_min' && value === 0)))
+            throw new Error(`${key} must be finite and ${key === 'deadline_min' ? 'positive' : 'nonnegative'}.`);
+    }
+    if (stall > 0 && kill > 0 && kill < stall)
+        throw new Error('The kill silence window must not precede the stall warning.');
+    return { stall_min: stall, kill_min: kill, ...(options.deadline_min !== undefined ? { deadline_min: options.deadline_min } : {}) };
+}
+export async function runProgressCommand(command, root, options = {}) {
+    const policy = resolveCommandPolicy(options);
+    if (options.signal?.aborted)
+        return { ok: false, output: '', exit_code: null, duration_ms: 0, reason_code: 'command_canceled' };
+    const started = Date.now();
+    let lastOutput = started;
+    let outputAt;
+    let output = '';
+    let stopping;
+    let closed = false;
+    let force;
+    if (options.log_path)
+        mkdirSync(dirname(options.log_path), { recursive: true });
+    // Register process ownership before releasing the command. If the runner
+    // dies during registration, EOF exits the waiting shell without side effects.
+    const child = spawn('sh', ['-c', 'IFS= read -r ace_start || exit 125; exec sh -c "$1"', 'ace-command', command], { cwd: root, detached: process.platform !== 'win32', stdio: ['pipe', 'pipe', 'pipe'] });
+    const notify = (final) => {
+        const now = Date.now(), silence = now - lastOutput;
+        const value = { pid: child.pid, started_at: new Date(started).toISOString(), last_output_at: outputAt,
+            last_progress_at: new Date(lastOutput).toISOString(), elapsed_ms: now - started, silence_ms: silence, output_tail: output.slice(-2000),
+            status: final ?? (stopping ? 'terminating' : policy.stall_min > 0 && silence >= policy.stall_min * 60000 ? 'suspected_stall' : 'running'),
+            ...(stopping ? { reason_code: stopping } : {}) };
+        try {
+            Promise.resolve(options.onProgress?.(value)).catch(() => { });
+        }
+        catch { /* Observer failure cannot kill work. */ }
+    };
+    const signalGroup = (signal) => {
+        if (!child.pid)
+            return;
+        try {
+            if (process.platform === 'win32')
+                child.kill(signal);
+            else
+                process.kill(-child.pid, signal);
+        }
+        catch (error) {
+            if (error.code !== 'ESRCH')
+                output = `${output}\nUnable to signal process group: ${String(error)}`.slice(-64000);
+        }
+    };
+    const stop = (reason) => {
+        if (closed || stopping)
+            return;
+        stopping = reason;
+        signalGroup('SIGTERM');
+        notify();
+        force = setTimeout(() => signalGroup('SIGKILL'), 1000);
+    };
+    const abort = () => stop('command_canceled');
+    options.signal?.addEventListener('abort', abort, { once: true });
+    const capture = (chunk) => {
+        const value = chunk.toString();
+        output = (output + value).slice(-64000);
+        lastOutput = Date.now();
+        outputAt = new Date(lastOutput).toISOString();
+        if (options.log_path) {
+            try {
+                appendFileSync(options.log_path, value);
+            }
+            catch (error) {
+                stop('command_log_failed');
+            }
+        }
+        notify();
+    };
+    child.stdout.on('data', capture);
+    child.stderr.on('data', capture);
+    child.once('spawn', async () => {
+        const identity = child.pid && readProcessIdentity(child.pid);
+        try {
+            if (options.onSpawn && !identity)
+                throw new Error('Command process identity unavailable.');
+            if (identity)
+                await options.onSpawn?.(identity);
+            child.stdin.end(closed || stopping ? '' : 'run\n');
+        }
+        catch (error) {
+            output = `${output}\n${String(error)}`.trim();
+            stop('command_ownership_failed');
+            child.stdin.end();
+        }
+        notify();
+        if (options.signal?.aborted)
+            abort();
+    });
+    child.stdin.on('error', () => { });
+    const timer = setInterval(() => {
+        const now = Date.now();
+        if (policy.deadline_min !== undefined && now - started >= policy.deadline_min * 60000)
+            stop('command_deadline_exceeded');
+        else if (policy.kill_min > 0 && now - lastOutput >= policy.kill_min * 60000)
+            stop('command_stalled');
+        else
+            notify();
+    }, options.poll_interval_ms ?? 1000);
+    let deadlineTimer;
+    const armDeadline = () => {
+        if (policy.deadline_min === undefined || closed)
+            return;
+        const remaining = policy.deadline_min * 60000 - (Date.now() - started);
+        if (remaining <= 0) {
+            stop('command_deadline_exceeded');
+            return;
+        }
+        // Node clamps overflowing timers to 1ms. Long explicit deadlines must not
+        // accidentally become immediate cancellations.
+        deadlineTimer = setTimeout(armDeadline, Math.min(remaining, 2147483647));
+    };
+    armDeadline();
+    return await new Promise(resolve => {
+        const finish = (code, error) => {
+            if (closed)
+                return;
+            closed = true;
+            clearInterval(timer);
+            if (force)
+                clearTimeout(force);
+            if (deadlineTimer)
+                clearTimeout(deadlineTimer);
+            options.signal?.removeEventListener('abort', abort);
+            if (error)
+                output = `${output}\n${error.message}`.trim();
+            // Descendants may have ignored TERM and closed inherited output. Ensure
+            // cancellation cleans the entire original group before reporting terminal.
+            if (stopping)
+                signalGroup('SIGKILL');
+            const ok = !stopping && !error && code === 0;
+            notify(ok ? 'done' : 'failed');
+            resolve({ ok, output, exit_code: code, duration_ms: Date.now() - started,
+                ...(stopping ? { reason_code: stopping } : error ? { reason_code: 'command_spawn_failed' } : {}) });
+        };
+        child.once('error', error => finish(null, error));
+        child.once('close', code => finish(code));
+    });
+}
+//# sourceMappingURL=progress-command.js.map

package/dist/prompts.js

@@ -89,7 +89,7 @@ function renderRuntimeRecallSections(input) {
 export function registerPrompts(server) {
     // ── Token-budget mode ─────────────────────────────────────────────
     const BRIEF_SCHEMA = z
-        .boolean()
+        .union([z.boolean(), z.enum(['true', 'false']).transform(value => value === 'true')])
         .optional()
         .describe("Token-budget mode: true = role instructions only (no kernel/task-packs). Default: false (full context).");
     // ── 1. Per-agent activation prompts ─────────────────────────────────
@@ -171,7 +171,7 @@ export function registerPrompts(server) {
                         "You are now operating as ACE-Orchestrator.",
                         "",
                         "## Orchestrator Instructions",
-                        readAgentInstructions("orchestrator"),
+                        readAgentInstructions("orchestrator", { includeLearned: true }),
                         "",
                         ...(brief ? ["## ACE Preflight", formatAceRecallMarkdown(buildAceRecallContext())] : [formatRecallSlices(task)]),
                         ...(brief
@@ -214,7 +214,7 @@ export function registerPrompts(server) {
                         "You are now operating as ACE-VOS.",
                         "",
                         "## VOS Instructions",
-                        readAgentInstructions("vos"),
+                        readAgentInstructions("vos", { includeLearned: true }),
                         ...(brief
                             ? []
                             : [
@@ -249,7 +249,7 @@ export function registerPrompts(server) {
                         "You are now operating as ACE-UI.",
                         "",
                         "## UI Instructions",
-                        readAgentInstructions("ui"),
+                        readAgentInstructions("ui", { includeLearned: true }),
                         ...(brief
                             ? []
                             : [
@@ -284,7 +284,7 @@ export function registerPrompts(server) {
                         "You are now operating as ACE-Coders.",
                         "",
                         "## Coders Instructions",
-                        readAgentInstructions("coders"),
+                        readAgentInstructions("coders", { includeLearned: true }),
                         ...(brief
                             ? []
                             : [
@@ -316,10 +316,10 @@ export function registerPrompts(server) {
                         "You are now operating as ACE-ASTGrep.",
                         "",
                         "## ASTGrep Agent Instructions",
-                        readAgentInstructions("astgrep"),
+                        readAgentInstructions("astgrep", { includeLearned: true }),
                         "",
                         "## AST-grep Command Pack",
-                        readSkillInstructions("astgrep-index"),
+                        readSkillInstructions("astgrep-index", { includeLearned: true }),
                         "",
                         task
                             ? `## Current Task\n${task}`
@@ -341,7 +341,7 @@ export function registerPrompts(server) {
                         "You are now operating as ACE-Memory.",
                         "",
                         "## Memory Agent Instructions",
-                        readAgentInstructions("memory"),
+                        readAgentInstructions("memory", { includeLearned: true }),
                         "",
                         "## Shared Kernel",
                         readKernelArtifact("directive_kernel"),
@@ -366,7 +366,7 @@ export function registerPrompts(server) {
                         "You are now operating as ACE-Security.",
                         "",
                         "## Security Agent Instructions",
-                        readAgentInstructions("security"),
+                        readAgentInstructions("security", { includeLearned: true }),
                         "",
                         "## Shared Kernel",
                         readKernelArtifact("directive_kernel"),
@@ -391,7 +391,7 @@ export function registerPrompts(server) {
                         "You are now operating as ACE-Observability.",
                         "",
                         "## Observability Agent Instructions",
-                        readAgentInstructions("observability"),
+                        readAgentInstructions("observability", { includeLearned: true }),
                         "",
                         "## Shared Kernel",
                         readKernelArtifact("directive_kernel"),
@@ -416,7 +416,7 @@ export function registerPrompts(server) {
                         "You are now operating as ACE-Eval.",
                         "",
                         "## Eval Agent Instructions",
-                        readAgentInstructions("eval"),
+                        readAgentInstructions("eval", { includeLearned: true }),
                         "",
                         "## Shared Kernel",
                         readKernelArtifact("directive_kernel"),
@@ -441,7 +441,7 @@ export function registerPrompts(server) {
                         "You are now operating as ACE-Release.",
                         "",
                         "## Release Agent Instructions",
-                        readAgentInstructions("release"),
+                        readAgentInstructions("release", { includeLearned: true }),
                         "",
                         "## Shared Kernel",
                         readKernelArtifact("directive_kernel"),
@@ -563,7 +563,7 @@ export function registerPrompts(server) {
                     text: [
                         `# ACE Skill Activation: ${skill}`,
                         "",
-                        readSkillInstructions(skill),
+                        readSkillInstructions(skill, { includeLearned: true }),
                         "",
                         task ? `## Task\n${task}` : "## Task\nApply this skill to the current workspace objective.",
                     ].join("\n"),
@@ -580,7 +580,7 @@ export function registerPrompts(server) {
                     text: [
                         "# CodeMunch Activation",
                         "",
-                        readSkillInstructions("codemunch"),
+                        readSkillInstructions("codemunch", { includeLearned: true }),
                         "",
                         task
                             ? `## Objective\n${task}`
@@ -599,7 +599,7 @@ export function registerPrompts(server) {
                     text: [
                         "# CodeSnipe Activation",
                         "",
-                        readSkillInstructions("codesnipe"),
+                        readSkillInstructions("codesnipe", { includeLearned: true }),
                         "",
                         task
                             ? `## Objective\n${task}`

package/dist/resources.js

@@ -26,7 +26,7 @@ export function registerResources(server) {
             contents: [
                 {
                     uri: `ace://agents/${role}/instructions`,
-                    text: readAgentInstructions(role),
+                    text: readAgentInstructions(role, { includeLearned: true }),
                     mimeType: "text/markdown",
                 },
             ],
@@ -154,7 +154,7 @@ export function registerResources(server) {
             contents: [
                 {
                     uri: uri.href,
-                    text: readSkillInstructions(name),
+                    text: readSkillInstructions(name, { includeLearned: true }),
                     mimeType: "text/markdown",
                 },
             ],

package/dist/runtime-command.d.ts

@@ -16,8 +16,15 @@ export interface ShellCommandProgressEvent {
 export interface RunShellCommandOptions {
     cwd: string;
     env?: NodeJS.ProcessEnv;
-    timeout_ms: number;
+    timeout_ms?: number;
+    /** Final silence threshold; 0 disables stall detection. */
     stall_timeout_ms?: number;
+    stall_warning_ms?: number;
+    on_stall?: (event: {
+        at: number;
+        last_progress_at: number;
+        silence_ms: number;
+    }) => void;
     max_output_bytes?: number;
     on_spawn?: (child: ChildProcess) => void;
     on_progress?: (event: ShellCommandProgressEvent) => void;

package/dist/runtime-command.js

@@ -9,6 +9,12 @@ function appendChunk(buffer, chunk, maxBytes) {
     return clipped.subarray(0, maxBytes).toString("utf8");
 }
 export async function runShellCommand(command, options) {
+    for (const [name, value] of Object.entries({ timeout_ms: options.timeout_ms, stall_timeout_ms: options.stall_timeout_ms, stall_warning_ms: options.stall_warning_ms })) {
+        if (value !== undefined && (!Number.isFinite(value) || value < 0))
+            throw new Error(`${name} must be finite and nonnegative; 0 disables the limit.`);
+    }
+    if (options.stall_timeout_ms && options.stall_warning_ms && options.stall_warning_ms > options.stall_timeout_ms)
+        throw new Error("The stall warning must not follow the final silence limit.");
     const startedAt = Date.now();
     const maxOutputBytes = Math.max(4 * 1024, options.max_output_bytes ?? 256 * 1024);
     return new Promise((resolve, reject) => {
@@ -19,6 +25,7 @@ export async function runShellCommand(command, options) {
         let finished = false;
         let lastProgressAt = startedAt;
         let stallTimer;
+        let warningTimer;
         let forcedKillTimer;
         let child;
         try {
@@ -26,6 +33,7 @@ export async function runShellCommand(command, options) {
                 cwd: options.cwd,
                 env: options.env,
                 stdio: ["ignore", "pipe", "pipe"],
+                detached: process.platform !== "win32",
             });
         }
         catch (error) {
@@ -33,23 +41,48 @@ export async function runShellCommand(command, options) {
             return;
         }
         options.on_spawn?.(child);
+        const signalGroup = (signal) => {
+            if (!child.pid)
+                return;
+            try {
+                if (process.platform === "win32")
+                    child.kill(signal);
+                else
+                    process.kill(-child.pid, signal);
+            }
+            catch (error) {
+                if (error.code !== "ESRCH")
+                    stderr = appendChunk(stderr, String(error), maxOutputBytes);
+            }
+        };
         const requestTimeout = (reason) => {
             if (finished || timedOut)
                 return;
             timedOut = true;
             timeoutReason = reason;
-            child.kill("SIGTERM");
+            signalGroup("SIGTERM");
             forcedKillTimer = setTimeout(() => {
                 if (!finished)
-                    child.kill("SIGKILL");
+                    signalGroup("SIGKILL");
             }, 500);
         };
         const resetStallTimer = () => {
             if (stallTimer)
                 clearTimeout(stallTimer);
-            const stallTimeoutMs = options.stall_timeout_ms;
+            if (warningTimer)
+                clearTimeout(warningTimer);
+            const stallTimeoutMs = options.stall_timeout_ms ?? 60 * 60_000;
             if (!stallTimeoutMs || stallTimeoutMs <= 0)
                 return;
+            const warningMs = options.stall_warning_ms ?? Math.min(10 * 60_000, stallTimeoutMs);
+            if (warningMs > 0)
+                warningTimer = setTimeout(() => {
+                    const at = Date.now();
+                    try {
+                        options.on_stall?.({ at, last_progress_at: lastProgressAt, silence_ms: at - lastProgressAt });
+                    }
+                    catch { /* Warning observers do not own execution. */ }
+                }, warningMs);
             stallTimer = setTimeout(() => requestTimeout("stall"), stallTimeoutMs + STALL_TIMEOUT_SCHEDULER_GRACE_MS);
         };
         const recordProgress = (source) => {
@@ -65,11 +98,15 @@ export async function runShellCommand(command, options) {
                 clearTimeout(stallTimer);
             if (forcedKillTimer)
                 clearTimeout(forcedKillTimer);
+            if (warningTimer)
+                clearTimeout(warningTimer);
+            if (timedOut)
+                signalGroup("SIGKILL");
             resolve(result);
         };
-        const timeout = setTimeout(() => {
+        const timeout = options.timeout_ms && options.timeout_ms > 0 ? setTimeout(() => {
             requestTimeout("turn_budget");
-        }, options.timeout_ms);
+        }, options.timeout_ms) : undefined;
         recordProgress("spawn");
         child.stdout?.setEncoding("utf8");
         child.stdout?.on("data", (chunk) => {
@@ -82,16 +119,20 @@ export async function runShellCommand(command, options) {
             recordProgress("stderr");
         });
         child.on("error", (error) => {
-            clearTimeout(timeout);
+            if (timeout)
+                clearTimeout(timeout);
             if (stallTimer)
                 clearTimeout(stallTimer);
             if (forcedKillTimer)
                 clearTimeout(forcedKillTimer);
+            if (warningTimer)
+                clearTimeout(warningTimer);
             if (!finished)
                 reject(error);
         });
         child.on("close", (code, signal) => {
-            clearTimeout(timeout);
+            if (timeout)
+                clearTimeout(timeout);
             finish({
                 exit_code: code,
                 signal,