@voybio/ace-swarm 2.4.8 → 2.4.10

package/dist/learning-scorecard.js

@@ -0,0 +1,86 @@
+import { learningScopeKey } from './learning-policy.js';
+const ratio = (n, d) => d ? n / d : null;
+const phase = () => ({ done: 0, steps: 0, rate: null });
+function match(scope, e) {
+    return (scope.role === e.role ? 2 : 0) +
+        (scope.paths?.some(p => e.paths.some(q => q === p || q.startsWith(p + '/') || p.startsWith(q + '/'))) ? 3 : 0) +
+        (scope.task_tags?.filter(t => e.tags.includes(t)).length ?? 0) +
+        (scope.failure_signature && scope.failure_signature === e.failure_signature ? 5 : 0);
+}
+export function buildLearningScorecard(steps, episodes, lessons, artifacts, now = Date.now()) {
+    const skills = artifacts.filter(a => a.kind === 'skill');
+    const known = [...lessons, ...skills];
+    const byId = new Map(known.map(a => ['bullet_id' in a ? a.bullet_id : a.id, a]));
+    const work = new Map(steps.map(s => [`${s.goal}:${s.step.step_id}`, s.step]));
+    const signatures = new Set(), recurring = new Set();
+    const servedSizes = [];
+    let missingContext = 0;
+    for (const ep of episodes) {
+        const step = work.get(`${ep.goal_id}:${ep.step_id}`);
+        const attempt = ep.attempt ?? Number(ep.id.split(':').at(-1));
+        const fallback = step && step.attempt === attempt && step.served_learning ? {
+            items: step.served_learning.items,
+            rendered_bytes: Buffer.byteLength(step.served_learning.text),
+        } : undefined;
+        const context = ep.served_context ?? fallback;
+        if (!context) {
+            if (ep.served?.length)
+                missingContext++;
+            continue;
+        }
+        if (context.items.length)
+            servedSizes.push({ episode_id: ep.id, utf8_bytes: context.rendered_bytes, token_upper_bound: context.rendered_bytes });
+        for (const item of context.items.filter(i => i.kind === 'lesson' && i.scope.failure_signature)) {
+            signatures.add(item.scope.failure_signature);
+            if (ep.failure_signature === item.scope.failure_signature)
+                recurring.add(item.scope.failure_signature);
+        }
+    }
+    const scopes = new Map();
+    let missingFirst = 0, reconstructedScopes = 0;
+    const episodeMap = new Map(episodes.map(e => [`${e.goal_id}:${e.step_id}:${e.attempt ?? Number(e.id.split(':').at(-1))}`, e]));
+    for (const { goal, step } of steps) {
+        const first = episodeMap.get(`${goal}:${step.step_id}:1`);
+        if (!first) {
+            missingFirst++;
+            continue;
+        }
+        if (!first.scope_snapshot)
+            reconstructedScopes++;
+        const key = learningScopeKey({ role: first.role, paths: first.paths, task_tags: first.tags });
+        const group = scopes.get(key) ?? { scope: key, before: phase(), after: phase(), unclassified: phase(), unexposed: phase() };
+        const relevant = known.filter(a => a.ever_active !== false && (a.status === 'active' || a.ever_active) && match(a.scope, first) >= 3);
+        const dates = relevant.flatMap(a => a.activated_at && Number.isFinite(Date.parse(a.activated_at)) ? [Date.parse(a.activated_at)] : []);
+        const kind = !Number.isFinite(Date.parse(first.at)) ? 'unclassified' : !relevant.length ? 'unexposed' : dates.length !== relevant.length ? 'unclassified' : Date.parse(first.at) < Math.min(...dates) ? 'before' : 'after';
+        group[kind].steps++;
+        if (first.status === 'done')
+            group[kind].done++;
+        for (const p of [group.before, group.after, group.unclassified, group.unexposed])
+            p.rate = ratio(p.done, p.steps);
+        scopes.set(key, group);
+    }
+    const learning = steps.filter(({ step }) => !!step.learning_scope);
+    const submissions = steps.filter(({ step }) => !!step.learning_payload && !!step.learning_result);
+    const checked = submissions.filter(({ step }) => step.learning_result.ok);
+    const helpful = known.reduce((n, a) => n + a.helpful_count, 0), harmful = known.reduce((n, a) => n + a.harmful_count, 0);
+    const since = now - 30 * 86400000;
+    const recentActive = known.filter(a => a.status === 'active' || (a.ever_active && !!a.last_active_at && Date.parse(a.last_active_at) >= since));
+    const retired = recentActive.filter(a => a.status === 'retired' && !!a.retired_at && Date.parse(a.retired_at) >= since);
+    const unknownHistory = known.filter(a => a.status !== 'active' && (a.ever_active === undefined || (a.ever_active && !a.last_active_at)));
+    return {
+        active_learned_artifacts: { lessons: lessons.filter(a => a.status === 'active').length, skills: skills.filter(a => a.status === 'active').length, approved_instructions: artifacts.filter(a => a.kind === 'instruction' && a.status === 'active').length },
+        repeat_failure_rate: { signatures_served: signatures.size, signatures_recurred: recurring.size, rate: ratio(recurring.size, signatures.size), missing_context_attempts: missingContext, interpretation: 'Recurrence after serving is correlational; it is not proof the item was used or caused the outcome.' },
+        first_attempt_success_by_scope: [...scopes.values()],
+        first_attempt_coverage: { missing_first_attempts: missingFirst, reconstructed_scopes: reconstructedScopes, interpretation: 'Before/after uses known activation timestamps and retained first attempts. Unknown activation history stays unclassified.' },
+        served_helpfulness: { helpful, harmful, ratio: ratio(helpful, helpful + harmful), counter_scope: 'Existing artifact counters; legacy producer history is not retrospectively re-attributed.' },
+        distill_acceptance: { checked: checked.length, submitted: submissions.length, rate: ratio(checked.length, submissions.length), demonstrated_current_artifacts: known.filter(a => a.status === 'active' && a.label === 'demonstrated').length },
+        learning_overhead: { learning_steps: learning.length, all_steps: steps.length, ratio: ratio(learning.length, steps.length), opportunistic_payload_steps: submissions.filter(({ step }) => !step.learning_scope).length, assignments: servedSizes, max_served_token_upper_bound: servedSizes.length ? Math.max(...servedSizes.map(s => s.token_upper_bound)) : null, token_method: 'UTF-8 byte count is a conservative upper bound; no provider tokenizer count is claimed.' },
+        retirement_health: { window_days: 30, retired: retired.length, ever_active: recentActive.length, ratio: ratio(retired.length, recentActive.length), unknown_history: unknownHistory.length },
+        distillation_steps: submissions.map(({ goal, step }) => {
+            const eligible = (step.learning_result.ids ?? []).flatMap(id => { const a = byId.get(id); return a && (a.served_count ?? 0) >= 20 && a.helpful_count + a.harmful_count > 0 ? [a.helpful_count / (a.helpful_count + a.harmful_count)] : []; });
+            return { goal_id: goal, step_id: step.step_id, checked: step.learning_result.ok, items_after_20_serves: eligible.length, mean_strong_helpfulness: eligible.length ? eligible.reduce((sum, v) => sum + v, 0) / eligible.length : null };
+        }),
+        coverage: 'Retained plans, pinned episodes and existing artifacts only; missing history and insufficient samples are not treated as success.',
+    };
+}
+//# sourceMappingURL=learning-scorecard.js.map

package/dist/learning-serving.d.ts

@@ -0,0 +1,29 @@
+/** Match learning at assignment time; score only consequence with evidence of use. */
+import type { TaskPlan, TaskStep } from './orchestrator-supervisor.js';
+import type { GoalRecord } from './store/repositories/goal-repository.js';
+import { type PlaybookScope } from './store/repositories/playbook-repository.js';
+import type { StepOutcome } from './host-goal-engine.js';
+export interface ServedLearningItem {
+    id: string;
+    kind: 'lesson' | 'skill' | 'packaged';
+    scope: PlaybookScope;
+    text: string;
+    check?: string;
+    checks?: string[];
+    helpful: number;
+    harmful: number;
+    score: number;
+}
+export interface ServedLearning {
+    text: string;
+    items: ServedLearningItem[];
+}
+export declare function selectLearning(root: string, plan: TaskPlan, step: TaskStep): ServedLearning;
+export declare function recordSkillUse(root: string, ref: {
+    goal_id: string;
+    step_id: string;
+    attempt: number;
+    agent: string;
+}, id: string): Promise<void>;
+export declare function scoreLearning(root: string, goal: GoalRecord, step: TaskStep, outcome: StepOutcome): Promise<void>;
+//# sourceMappingURL=learning-serving.d.ts.map

package/dist/learning-serving.js

@@ -0,0 +1,134 @@
+import { readLearningPolicy } from './learning-policy.js';
+import { GoalRepository } from './store/repositories/goal-repository.js';
+import { PlaybookRepository, withPlaybookTransaction } from './store/repositories/playbook-repository.js';
+import { listLearnedArtifacts, updateLearnedArtifact, ensureLearningStep } from './learned-artifacts.js';
+import { listSkillCatalogEntries } from './skill-catalog.js';
+import { withWorkspaceRoot } from './helpers/workspace-root.js';
+import { withStoreWriteCoordinator } from './store/write-coordinator.js';
+import { failureSignature, learningTaskText } from './experience-reflector.js';
+import { curate } from './playbook-curator.js';
+const tags = ['test', 'build', 'store', 'todo', 'handoff', 'scheduler', 'migration', 'docs', 'release', 'mcp', 'hook', 'schema'];
+export function selectLearning(root, plan, step) {
+    const policy = readLearningPolicy(root);
+    if (!policy.enabled || step.learning_scope)
+        return { text: '', items: [] };
+    const all = [step, ...plan.steps.filter(s => step.depends_on?.includes(s.step_id))];
+    const signatures = new Set(all.flatMap(s => s.attempts_log?.flatMap(a => a.failure_signature ? [a.failure_signature] : []) ?? []));
+    const paths = all.flatMap(s => [...(s.expected_artifacts ?? []).map(a => a.path), ...(s.evidence_refs ?? [])]).map(p => p.replace(/\\/g, '/').replace(/^\.\//, ''));
+    const taskTags = tags.filter(tag => learningTaskText(step).toLowerCase().includes(tag));
+    const score = (scope, helpful, harmful) => (scope.failure_signature && signatures.has(scope.failure_signature) ? 5 : 0) + (scope.paths?.some(p => paths.some(q => q === p || q.startsWith(p + '/') || p.startsWith(q + '/'))) ? 3 : 0) + (scope.role === step.role ? 2 : 0) + (scope.task_tags?.filter(t => taskTags.includes(t)).length ?? 0) - (harmful > helpful ? 3 : 0);
+    const candidates = new PlaybookRepository(root).listBulletsReadOnly({ status: 'active' }).map(b => ({ id: b.bullet_id, kind: 'lesson', scope: b.scope, text: `[${b.bullet_id}] (learned, ${b.label ?? 'checked'}) ${b.content} (helped ${b.helpful_count}×; harmful ${b.harmful_count}×)`, check: b.content.match(/Check:\s*(.+)$/)?.[1]?.trim(), helpful: b.helpful_count, harmful: b.harmful_count, score: score(b.scope, b.helpful_count, b.harmful_count) }));
+    for (const a of listLearnedArtifacts(root).filter(a => a.kind === 'skill' && a.status === 'active'))
+        candidates.push({ id: a.id, kind: 'skill', scope: a.scope, text: `[${a.id}] (${a.label}) ${typeof a.description === 'string' ? a.description : 'Use for ' + JSON.stringify(a.scope)}`, checks: [...(a.body.match(/^## Validation[^\n]*\n([\s\S]*?)(?=^## |$(?![\s\S]))/m)?.[1] ?? '').matchAll(/```bash\s*\n([\s\S]*?)```/g)].map(m => m[1].replace(/\n$/, '')), helpful: a.helpful_count, harmful: a.harmful_count, score: score(a.scope, a.helpful_count, a.harmful_count) });
+    const packaged = withWorkspaceRoot(root, () => listSkillCatalogEntries()).filter(s => s.source === 'package-defaults');
+    for (const skill of packaged) {
+        const scope = { task_tags: tags.filter(t => skill.description.toLowerCase().includes(t)) };
+        candidates.push({ id: skill.name, kind: 'packaged', scope, text: `[${skill.name}] ${skill.description} — load with get_skill_instructions`, helpful: 0, harmful: 0, score: score(scope, 0, 0) });
+    }
+    const picked = [];
+    let text = '';
+    for (const item of candidates.filter(c => c.score >= 3).sort((a, b) => b.score - a.score || b.helpful - a.helpful || a.id.localeCompare(b.id))) {
+        if (picked.filter(i => i.kind === 'lesson').length >= policy.serve_max_lessons && item.kind === 'lesson')
+            continue;
+        if (picked.filter(i => i.kind !== 'lesson').length >= policy.serve_max_skills && item.kind !== 'lesson')
+            continue;
+        const rendered = text + (text ? '\n' : 'Known pitfalls and relevant skills (load when useful):\n') + item.text;
+        if (Buffer.byteLength(rendered, 'utf8') > policy.serve_max_tokens)
+            continue;
+        picked.push(item);
+        text = rendered;
+    }
+    return { text, items: picked };
+}
+export async function recordSkillUse(root, ref, id) {
+    if (!readLearningPolicy(root).enabled)
+        return;
+    const repo = new GoalRepository(root);
+    await withStoreWriteCoordinator(repo.planPath(ref.goal_id), async () => {
+        const p = repo.getPlan(ref.goal_id), s = p?.steps.find(s => s.step_id === ref.step_id);
+        if (!p || !s || s.status !== 'running' || s.attempt !== ref.attempt || s.assignee !== ref.agent || !s.served_learning?.items.some(i => i.id === id && i.kind !== 'lesson'))
+            return;
+        s.loaded_learning ??= [];
+        if (!s.loaded_learning.some(i => i.id === id)) {
+            s.loaded_learning.push({ id, at: new Date().toISOString() });
+            repo.savePlan(ref.goal_id, p);
+        }
+    }, { operation_label: 'served_skill_use' });
+}
+export async function scoreLearning(root, goal, step, outcome) {
+    const policy = readLearningPolicy(root);
+    if (!policy.enabled || !step.served_learning?.items.length)
+        return;
+    const episode = step.attempts_log?.at(-1);
+    if (!episode || episode.attempt !== step.attempt)
+        return;
+    const key = `${goal.goal_id}:${step.step_id}:${episode.attempt}`, runs = episode.observed_runs ?? [], forces = [];
+    for (const served of step.served_learning.items) {
+        if (served.kind === 'packaged')
+            continue;
+        const feedback = step.learning_feedback?.find(f => f.id === served.id);
+        const checkRuns = runs.filter(r => r.attribution === 'Linked' && (r.command === served.check || served.checks?.includes(r.command)));
+        const loaded = step.loaded_learning?.find(i => i.id === served.id);
+        const used = feedback !== undefined || !!loaded || (served.kind === 'lesson' && checkRuns.length > 0);
+        const usedAt = loaded?.at ?? checkRuns[0]?.at;
+        const recurrence = !!served.scope.failure_signature && (runs.some(r => r.attribution === 'Linked' && r.outcome === 'failed' && failureSignature(r.output_tail ?? '') === served.scope.failure_signature && (!usedAt || r.at >= usedAt)) || (!runs.length && episode.status !== 'done' && episode.failure_signature === served.scope.failure_signature));
+        const commands = served.check ? [served.check] : (served.checks ?? []);
+        const passed = episode.status === 'done' && commands.length > 0 && commands.every(command => checkRuns.some(r => r.command === command && r.outcome === 'ok' && r.exit_code === 0));
+        const tag = feedback ? (feedback.helpful ? 'helpful' : 'harmful') : used && recurrence ? 'harmful' : used && passed ? 'helpful' : undefined;
+        const weak = !used ? (episode.status === 'done' && episode.attempt === 1 ? 'done_first_attempt' : recurrence ? 'failed_same_signature' : 'other') : undefined;
+        if (served.kind === 'lesson') {
+            await withPlaybookTransaction(root, async (repo) => {
+                let b = repo.getBullet(served.id);
+                if (!b || b.scored_attempts?.includes(key))
+                    return;
+                if (tag) {
+                    await curate(repo, [{ type: 'TAG', bullet_id: b.bullet_id, tag }], { quarantine_harmful_min: 2, emitEvent: false });
+                    b = repo.getBullet(served.id);
+                }
+                const counts = b.served_outcomes ?? { done_first_attempt: 0, failed_same_signature: 0, other: 0 };
+                if (weak)
+                    counts[weak]++;
+                const next = { ...b, served_count: (b.served_count ?? 0) + 1, used_count: (b.used_count ?? 0) + (used ? 1 : 0), served_outcomes: counts, scored_attempts: [...(b.scored_attempts ?? []), key], used_goals: used ? [...new Set([...(b.used_goals ?? []), goal.goal_id])] : b.used_goals };
+                if (next.served_count >= policy.retire_unhelpful_after_serves && !next.used_count) {
+                    next.status = 'retired';
+                    next.retired_reason = 'Served at least 40 times without evidence of use.';
+                }
+                repo.saveBullet(next);
+                if (tag === 'harmful' && recurrence)
+                    forces.push(b.scope);
+            });
+        }
+        else {
+            const found = listLearnedArtifacts(root).find(a => a.id === served.id && a.kind === 'skill');
+            if (!found)
+                continue;
+            await updateLearnedArtifact(root, found.key, a => {
+                if (a.scored_attempts?.includes(key))
+                    return;
+                a.served_count = (a.served_count ?? 0) + 1;
+                a.used_count = (a.used_count ?? 0) + (used ? 1 : 0);
+                a.scored_attempts = [...(a.scored_attempts ?? []), key];
+                a.used_goals = used ? [...new Set([...(a.used_goals ?? []), goal.goal_id])] : a.used_goals;
+                if (tag === 'helpful')
+                    a.helpful_count++;
+                if (tag === 'harmful')
+                    a.harmful_count++;
+                a.served_outcomes ??= { done_first_attempt: 0, failed_same_signature: 0, other: 0 };
+                if (weak)
+                    a.served_outcomes[weak]++;
+                if (a.harmful_count >= 2 && a.harmful_count > a.helpful_count)
+                    a.status = 'quarantined';
+                if (a.served_count >= policy.retire_unhelpful_after_serves && !a.used_count) {
+                    a.status = 'retired';
+                    a.retired_reason = 'Served at least 40 times without evidence of use.';
+                }
+                if (tag === 'harmful' && recurrence)
+                    forces.push(a.scope);
+                return a;
+            });
+        }
+    }
+    for (const scope of forces)
+        await ensureLearningStep(root, { scope, reason: 'An applied artifact\'s own failure recurred. Compare the served attempts and repair the advice.' });
+}
+//# sourceMappingURL=learning-serving.js.map

package/dist/linked-work.d.ts

@@ -0,0 +1,9 @@
+import type { TodoNode } from './store/repositories/todo-repository.js';
+import type { TaskPlan } from './orchestrator-supervisor.js';
+export declare function deriveLinkedTodo<T extends TodoNode>(todo: T, root: string, snapshot?: {
+    goal: {
+        goal_id: string;
+    };
+    plan: TaskPlan;
+}): T;
+//# sourceMappingURL=linked-work.d.ts.map

package/dist/linked-work.js

@@ -0,0 +1,28 @@
+/** Read-only derivation: a linked todo is a view of its existing goal step. */
+import { GoalRepository } from './store/repositories/goal-repository.js';
+export function deriveLinkedTodo(todo, root, snapshot) {
+    const repo = new GoalRepository(root);
+    let ref = todo.step_ref;
+    if (!ref) {
+        const current = snapshot?.plan.steps.find(s => s.todo_id === todo.id);
+        if (current)
+            ref = { goal_id: snapshot.goal.goal_id, step_id: current.step_id };
+        else
+            for (const goal of repo.listGoals()) {
+                const linked = repo.getPlan(goal.goal_id)?.steps.find(s => s.todo_id === todo.id);
+                if (linked) {
+                    ref = { goal_id: goal.goal_id, step_id: linked.step_id };
+                    break;
+                }
+            }
+    }
+    if (!ref)
+        return todo;
+    const plan = snapshot?.goal.goal_id === ref.goal_id ? snapshot.plan : repo.getPlan(ref.goal_id);
+    const step = plan?.steps.find(s => s.step_id === ref.step_id);
+    if (!step)
+        return todo;
+    const status = step.status === 'running' ? 'in_progress' : step.status === 'done' || step.status === 'skipped' ? 'done' : step.status === 'failed' || step.status === 'blocked' ? 'blocked' : 'pending';
+    return { ...todo, step_ref: ref, status, ...(step.assignee ? { assigned_to: step.assignee } : {}) };
+}
+//# sourceMappingURL=linked-work.js.map

package/dist/local-model-runtime.js

@@ -159,7 +159,7 @@ export async function runLocalModelTask(options) {
         requested_tier: options.tier,
         requested_model_class: options.modelClass,
     });
-    const maxTurns = options.maxTurns ?? defaultTurnsForPolicy(role, policy);
+    const maxTurns = options.maxTurns ?? (runtime.executionEngine === 'hermes_local' ? defaultTurnsForPolicy(role, policy) : 0);
     const requestedToolScope = options.toolScope ?? defaultToolScopeForPolicy(role, policy);
     const filteredToolCatalog = buildFilteredToolCatalog(policy.model_class, requestedToolScope, {
         mutation_lane: policy.mutation_lane,

package/dist/mcp-command-progress.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+import type { CommandProgress } from "./progress-command.js";
+/** MCP liveness messages keep opted-in requests alive without claiming output progress. */
+export declare function withMcpCommandProgress<T>(extra: {
+    _meta?: {
+        progressToken?: string | number;
+    };
+    signal?: AbortSignal;
+    sendNotification?: (notification: any) => Promise<unknown>;
+} | undefined, label: string, work: (onProgress: (progress: CommandProgress) => void, signal: AbortSignal) => Promise<T>, connectionIsOpen?: () => boolean): Promise<T>;
+export declare const commandPolicySchema: z.ZodObject<{
+    stall_min: z.ZodOptional<z.ZodNumber>;
+    kill_min: z.ZodOptional<z.ZodNumber>;
+    deadline_min: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+//# sourceMappingURL=mcp-command-progress.d.ts.map

package/dist/mcp-command-progress.js

@@ -0,0 +1,70 @@
+import { z } from "zod";
+/** MCP liveness messages keep opted-in requests alive without claiming output progress. */
+export async function withMcpCommandProgress(extra, label, work, connectionIsOpen) {
+    // The SDK cancels a request when its client stops waiting. That cancellation
+    // owns the response channel, not the command's lifetime. Explicit operator
+    // cancellation and ACE's explicitly configured tool deadlines still propagate.
+    const sourceSignal = extra?.signal;
+    const workController = new AbortController();
+    const beganConnected = connectionIsOpen?.() ?? false;
+    const forwardCancellation = () => {
+        const reason = sourceSignal?.reason;
+        const text = String(reason ?? "");
+        const code = reason && typeof reason === "object" && "code" in reason ? reason.code : undefined;
+        const clientWaitExpired = code === -32001 || /(?:McpError|MCP error).*Request timed out/i.test(text);
+        const transportClosed = /(?:connection|transport|stream)(?: was)? closed|\bdisconnected\b|ECONNRESET|EPIPE/i.test(text);
+        if (clientWaitExpired || transportClosed)
+            return;
+        const genericAbort = (reason instanceof Error && reason.name === "AbortError") || /^AbortError:/i.test(text);
+        if (genericAbort && beganConnected) {
+            // SDK _onclose aborts handlers before clearing its transport. Check after
+            // that synchronous close sequence; an operator abort leaves transport open.
+            queueMicrotask(() => {
+                if (connectionIsOpen?.() === false)
+                    return;
+                workController.abort(reason);
+            });
+        }
+        else
+            workController.abort(reason);
+    };
+    if (sourceSignal?.aborted) {
+        forwardCancellation();
+        await Promise.resolve();
+    }
+    else
+        sourceSignal?.addEventListener("abort", forwardCancellation, { once: true });
+    const token = extra?._meta?.progressToken;
+    let sequence = 0;
+    let latest = "running";
+    const notify = () => {
+        if (token === undefined || !extra?.sendNotification)
+            return;
+        try {
+            void Promise.resolve(extra.sendNotification({
+                method: "notifications/progress",
+                params: { progressToken: token, progress: ++sequence, message: `${label}: ${latest}` },
+            })).catch(() => undefined);
+        }
+        catch { /* A closed notification channel must not change command outcomes. */ }
+    };
+    notify();
+    const heartbeat = setInterval(notify, 15_000);
+    heartbeat.unref?.();
+    try {
+        return await work((progress) => {
+            latest = `${progress.status}; running ${Math.floor(progress.elapsed_ms / 1000)}s, last output ${Math.floor(progress.silence_ms / 1000)}s ago`;
+            notify();
+        }, workController.signal);
+    }
+    finally {
+        clearInterval(heartbeat);
+        sourceSignal?.removeEventListener("abort", forwardCancellation);
+    }
+}
+export const commandPolicySchema = z.object({
+    stall_min: z.number().nonnegative().finite().optional().describe("Silence before suspected stall; default 10 minutes, 0 disables stall detection"),
+    kill_min: z.number().nonnegative().finite().optional().describe("Total silence before terminating stalled process group; default 60 minutes"),
+    deadline_min: z.number().positive().finite().optional().describe("Explicit overall deadline in minutes; omitted means no overall deadline"),
+});
+//# sourceMappingURL=mcp-command-progress.js.map

package/dist/model-bridge.d.ts

@@ -10,7 +10,7 @@ export interface BridgeToolResult {
     ok: boolean;
     summary: string;
     isError: boolean;
-    /** Set when a tool fails for a classified reason (e.g. "tool_timeout"). */
+    /** Classified failure or nonterminal state (for example "still_running"). */
     reason_code?: string;
 }
 export interface BridgeUsageTotals {
@@ -83,20 +83,20 @@ export declare function verifyCompletionArtifacts(result: BridgeResult, context:
     requiredEvidenceRefs?: string[];
     forceCompletionVerification?: boolean;
 }): Promise<BridgeResult>;
-/**
- * Per-tool-call deadline (E12). A hung validation/test subprocess must never
- * wedge a turn indefinitely — and under Promise.all one stuck call also holds
- * every parallel sibling's feedback hostage. On timeout we resolve a classified
- * `tool_timeout` failure that then feeds the WS-C doom-loop brake.
- */
-export declare function executeToolWithDeadline(tool: string, args: Record<string, unknown>, sessionId: string, opts: {
-    workspace_path: string;
-}, deadlineMs: number, exec?: (tool: string, args: Record<string, unknown>, sessionId: string, opts: {
+type InternalToolOptions = {
     workspace_path: string;
-}) => Promise<unknown>): Promise<{
+    signal?: AbortSignal;
+};
+type ToolDeadlineOutcome = {
     rawToolResult: unknown;
-    timedOut: boolean;
-}>;
+    timedOut: false;
+    stillRunning?: boolean;
+    operationId?: string;
+};
+/** No implicit cutoff. An explicit deadline requests cancellation; unconfirmed
+ * cancellation is reported as still running. Identical retries collect the same
+ * operation instead of launching a duplicate side effect. */
+export declare function executeToolWithDeadline(tool: string, args: Record<string, unknown>, sessionId: string, opts: InternalToolOptions, deadlineMs?: number, exec?: (tool: string, args: Record<string, unknown>, sessionId: string, opts: InternalToolOptions) => Promise<unknown>): Promise<ToolDeadlineOutcome>;
 export declare class ModelBridge {
     private clients;
     private activeProviderClient;
@@ -108,4 +108,5 @@ export declare class ModelBridge {
     private selectToolScope;
     run(options: ModelBridgeRunOptions): Promise<BridgeResult>;
 }
+export {};
 //# sourceMappingURL=model-bridge.d.ts.map