@voybio/ace-swarm 2.4.8 → 2.4.10

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,

package/dist/runtime-executor.js

@@ -12,7 +12,7 @@ import { renderAceContinuityPromptBlock, renderAceRecallPromptBlock, renderAceSn
 import { executeRuntimeTool, buildFilteredToolCatalog, SMALL_LOCAL_PRIORITY_TOOL_NAMES, } from "./runtime-tool-specs.js";
 import { validateRuntimeExecutorSessionRegistryPayload, } from "./schemas.js";
 import { appendStatusEventSafe } from "./status-events.js";
-import { appendVericifyProcessPostSafe, deriveVericifyRunRef, isVericifyBridgeEnabled, refreshVericifyBridgeSnapshotSafe, } from "./vericify-bridge.js";
+import { appendAutomaticVericifyProcessPostSafe, deriveVericifyRunRef, isVericifyBridgeEnabled, refreshVericifyBridgeSnapshotSafe, } from "./vericify-bridge.js";
 import { createWorkspaceSessionAsync, removeWorkspaceSession, runWorkspaceSessionHook, } from "./workspace-manager.js";
 import { buildAceContinuityPacket, buildAceRecallContext, normalizeAutonomyPolicy, normalizeContinuityPolicy, } from "./ace-autonomy.js";
 import { openStore } from "./store/ace-packed-store.js";
@@ -358,7 +358,7 @@ async function emitVericifyProcessPostForSession(session, kind, summary, toolRef
     if (!isVericifyBridgeEnabled())
         return;
     const refs = deriveVericifyRunRef(session);
-    await appendVericifyProcessPostSafe({
+    const posted = await appendAutomaticVericifyProcessPostSafe({
         run_id: refs.run_id,
         branch_id: refs.branch_id,
         lane_id: refs.lane_id,
@@ -368,7 +368,8 @@ async function emitVericifyProcessPostForSession(session, kind, summary, toolRef
         tool_refs: toolRefs,
         evidence_refs: evidenceRefs,
     }).catch(() => undefined);
-    refreshVericifyBridgeSnapshotSafe();
+    if (posted && !posted.skipped)
+        refreshVericifyBridgeSnapshotSafe();
 }
 async function touchRuntimeProgress(sessionId, _reason, at = Date.now()) {
     if (!storeExistsSync(workspaceRoot()))
@@ -664,12 +665,12 @@ async function runSessionLoop(sessionId, context, autoCleanup, runtimeProfileSna
         let consecutiveStallRestarts = runtimeStatus?.stall_restart_count ?? 0;
         let isStallRestart = false;
         let stallRestartContext = "";
-        // Liveness defaults are explicit runtime policy. The resolved model class
-        // only informs the default budget profile when the caller has not already
-        // supplied a workspace/session budget or status-seeded runtime budget.
+        // Overall deadlines come only from explicit profile/session policy.
+        // Default liveness checks measure silence, separately warning and killing.
         const livenessDefaults = getLivenessDefaults(effectiveModelClass);
         const effectiveTurnBudgetMs = runtimeStatus?.turn_budget_ms ?? registryStart.turn_timeout_ms ?? livenessDefaults.turn_budget_ms;
-        const effectiveStallWindowMs = runtimeStatus?.stall_window_ms ?? livenessDefaults.stall_window_ms;
+        const effectiveStallWindowMs = runtimeStatus?.stall_window_ms ?? runtimeProfileSnapshot.profile.executor.stall_window_ms ?? livenessDefaults.stall_window_ms;
+        const effectiveStallWarningMs = runtimeProfileSnapshot.profile.executor.stall_warning_ms ?? Math.min(livenessDefaults.stall_warning_ms, effectiveStallWindowMs);
         const maxStallRestarts = livenessDefaults.max_stall_restarts;
         const initialBackoffMs = livenessDefaults.initial_backoff_ms;
         const maxRetryBackoffMs = livenessDefaults.max_retry_backoff_ms;
@@ -698,7 +699,7 @@ async function runSessionLoop(sessionId, context, autoCleanup, runtimeProfileSna
         const flushProgress = async () => {
             await pumpProgressWrite().catch(() => undefined);
         };
-        for (let turnNumber = 1; turnNumber <= registryStart.max_turns; turnNumber += 1) {
+        for (let turnNumber = 1; (registryStart.max_turns === 0 || turnNumber <= registryStart.max_turns); turnNumber += 1) {
             if (active?.stop_requested) {
                 const stopped = await finalizeSession(sessionId, "stopped", `Unattended session ${sessionId} stopped by request.`);
                 if (stopped) {
@@ -910,6 +911,10 @@ async function runSessionLoop(sessionId, context, autoCleanup, runtimeProfileSna
                 },
                 timeout_ms: effectiveTurnBudgetMs,
                 stall_timeout_ms: effectiveStallWindowMs,
+                stall_warning_ms: effectiveStallWarningMs,
+                on_stall: (event) => {
+                    void emitExecutorEvent("RUNTIME_EXECUTOR_SUSPECTED_STALL", "in_progress", `Turn ${turnNumber} has no output for ${event.silence_ms}ms; work remains running until the configured final silence threshold.`, { session_id: sessionId, turn_number: turnNumber, last_progress_at: event.last_progress_at, stall_window_ms: effectiveStallWindowMs }).catch(() => undefined);
+                },
                 on_spawn: (child) => {
                     if (active)
                         active.child = child;
@@ -1433,8 +1438,8 @@ export async function startUnattendedSession(input) {
         });
     }
     const workspaceSession = workspace.session;
-    const maxTurns = Math.max(1, input.max_turns ?? runtimeProfileSnapshot.profile.executor.max_turns ?? 6);
-    const turnTimeout = Math.max(1_000, input.turn_timeout_ms ?? runtimeProfileSnapshot.profile.executor.turn_timeout_ms ?? 300_000);
+    const maxTurns = Math.max(0, input.max_turns ?? runtimeProfileSnapshot.profile.executor.max_turns ?? 0);
+    const turnTimeout = Math.max(0, input.turn_timeout_ms ?? runtimeProfileSnapshot.profile.executor.turn_timeout_ms ?? 0);
     const now = new Date().toISOString();
     const sessionRecord = {
         session_id: sessionId,
@@ -1581,7 +1586,24 @@ export async function stopUnattendedSession(sessionId) {
         };
     }
     active.stop_requested = true;
-    active.child?.kill("SIGTERM");
+    const child = active.child;
+    if (child?.pid) {
+        const killGroup = (signal) => {
+            try {
+                if (process.platform === "win32")
+                    child.kill(signal);
+                else
+                    process.kill(-child.pid, signal);
+            }
+            catch (error) {
+                if (error.code !== "ESRCH")
+                    throw error;
+            }
+        };
+        killGroup("SIGTERM");
+        const force = setTimeout(() => killGroup("SIGKILL"), 500);
+        force.unref?.();
+    }
     const waited = await waitForUnattendedSession(sessionId, 15_000);
     return {
         ok: waited.ok,

package/dist/runtime-profile-syntax.d.ts

@@ -0,0 +1,6 @@
+export declare function parseYamlFrontMatter(raw: string): Record<string, unknown>;
+export declare function extractFrontMatter(raw: string): {
+    front_matter: string;
+    body: string;
+};
+//# sourceMappingURL=runtime-profile-syntax.d.ts.map