sortie-dogs 0.11.0 → 0.11.1

package/README.md

@@ -91,6 +91,22 @@ execution plan, exact-file manifest, or model-authored proof mapping.
 Technical scope and useful verification commands are discovered while working.
 Project `AGENTS.md`, user instructions and native OpenCode permissions remain authoritative.
 
+### Execution progress and bounded discovery
+
+The native child call publishes host-observed progress every five seconds: elapsed
+time, current inspection/command, last exit, command starts and edits. The same
+information is available through `sortie_v011_work_status`. Activity is never
+treated as completed work or an inferred benchmark score. Long jobs should reuse
+their existing controller and ledger, rather than rebuilding one before launch.
+
+By default, 12 inspection calls or three minutes without an executable step stop
+the child with a **blocked** reason. A running native shell/check keeps its own
+timeout. Resuming a discovery stall requires concrete next-step guidance; the same
+child, user instructions, failed checks and attempt budget are retained. Plugin
+options `maxDiscoveryCalls`, `maxPlanningMs` and `progressIntervalMs` configure these
+bounds. Interrupted outgoing tool calls receive an explicitly unverified error
+result when native history omitted one; stored history and check evidence are preserved.
+
 ### Roles and models
 
 | Role | Model | Responsibility |

package/dist/asset-version.d.ts

@@ -4,5 +4,5 @@
  */
 export declare const RUNTIME_ASSET_VERSION = "0.3.89-completion-proof-v1";
 export declare const V010_RUNTIME_ASSET_VERSION = "0.10.0-v0912-language4-cost-rpt10-compaction-ref2-proposal1-review-remediation1-surface4-proposal-recovery2-quality1-terminal2-route1-path1-permission2-prerequisite1-v2-bridge1-intent1-reflection1-cancel1-proposal-budget1-goal-recovery1-delegate-execute1-v2-depth1-process-replacement1-unstarted-v2-1-cold-turn1-return-report-v2-2-root-revision1";
-export declare const V011_RUNTIME_ASSET_VERSION = "0.11.0-user-proxy-native-v3-failure-boundary";
+export declare const V011_RUNTIME_ASSET_VERSION = "0.11.1-user-proxy-native-v4-progress-recovery";
 export type RuntimeAssetVersion = typeof RUNTIME_ASSET_VERSION | typeof V010_RUNTIME_ASSET_VERSION | typeof V011_RUNTIME_ASSET_VERSION;

package/dist/asset-version.js

@@ -4,4 +4,4 @@
  */
 export const RUNTIME_ASSET_VERSION = "0.3.89-completion-proof-v1";
 export const V010_RUNTIME_ASSET_VERSION = "0.10.0-v0912-language4-cost-rpt10-compaction-ref2-proposal1-review-remediation1-surface4-proposal-recovery2-quality1-terminal2-route1-path1-permission2-prerequisite1-v2-bridge1-intent1-reflection1-cancel1-proposal-budget1-goal-recovery1-delegate-execute1-v2-depth1-process-replacement1-unstarted-v2-1-cold-turn1-return-report-v2-2-root-revision1";
-export const V011_RUNTIME_ASSET_VERSION = "0.11.0-user-proxy-native-v3-failure-boundary";
+export const V011_RUNTIME_ASSET_VERSION = "0.11.1-user-proxy-native-v4-progress-recovery";

package/dist/core/work-loop.d.ts

@@ -1,3 +1,4 @@
+import { type WorkActivity, type WorkProgress } from "./work-progress.js";
 export declare const WORK_REFERENCE = "SORTIE_V011_WORK_REF ";
 export declare const WORK_LIMITS: {
     readonly attempts: 6;
@@ -67,6 +68,7 @@ export interface WorkState {
         evidence?: string;
     };
     checkReplacements?: WorkCheckReplacement[];
+    progress?: WorkProgress;
 }
 export interface WorkStore {
     get(key: string): Promise<unknown>;
@@ -108,6 +110,11 @@ export declare class WorkLoop {
     admit(root: string, callID: string, input: Record<string, unknown>): Promise<void>;
     claim(root: string, child: string, prompt: string): Promise<string>;
     assertWorker(root: string, child: string): Promise<WorkState>;
+    activity(root: string, child: string, activity: WorkActivity, result?: {
+        status: string;
+        exit: number | null;
+    }): Promise<void>;
+    stall(root: string, callID: string, reason: string): Promise<boolean>;
     check(root: string, actor: string, command: string, timeout: number, signal?: AbortSignal, execute?: typeof runWorkCheck): Promise<WorkCheck>;
     settled(root: string, callID: string, succeeded: boolean, report: string): Promise<void>;
     interrupt(root: string, cancelled?: boolean): Promise<void>;

package/dist/core/work-loop.js

@@ -4,6 +4,7 @@ import { lstat, readdir, readlink } from "node:fs/promises";
 import { createReadStream } from "node:fs";
 import { join } from "node:path";
 import { promisify } from "node:util";
+import { isWorkAction, newWorkProgress } from "./work-progress.js";
 const exec = promisify(execFile);
 const hash = (value) => createHash("sha256").update(value).digest("hex");
 export const WORK_REFERENCE = "SORTIE_V011_WORK_REF ";
@@ -201,6 +202,8 @@ export class WorkLoop {
         return this.update(root, async (state) => {
             if (state.work && !["completed", "cancelled"].includes(state.work.phase)) {
                 if (["interrupted", "blocked"].includes(state.work.phase)) {
+                    if (state.work.progress?.stopped && !instructions.trim())
+                        throw new Error("work-progress-blocked: provide a concrete next executable step before resuming; do not repeat the same exploratory dispatch");
                     if (state.work.attempts >= this.maxAttempts)
                         throw new Error("work-attempt-budget-exhausted");
                     state.work.phase = "ready";
@@ -243,6 +246,7 @@ export class WorkLoop {
             work.callID = callID;
             work.attempts++;
             work.updatedAt = Date.now();
+            work.progress = newWorkProgress(work.updatedAt);
         });
     }
     async claim(root, child, prompt) {
@@ -257,6 +261,7 @@ export class WorkLoop {
                 "## Original user instructions (all remain authoritative)", ...work.requests.map(item => item.text),
                 "## Operator notes", work.instructions, ...work.feedback,
                 "Use native read/glob/grep/patch/shell tools freely within the user's instructions and project AGENTS.md. Discover dependencies and affected files as you work.",
+                "Act early: use supplied runner/artifact/manifest paths and existing documented commands. Do not recreate a controller or repeat broad preflight for an execution request. After at most 12 inspection tools or 3 minutes without an executable step, the host yields this job to the operator. Long commands retain their native timeout. Start the smallest relevant reproduction/command, or report a concrete blocker. Tool activity does not prove task completion.",
                 "Run final meaningful checks with sortie_v011_check. Each remains an obligation until it passes on final source; use shell for exploration. Fix ordinary setup and test failures in this invocation. Verify the actual affected behavior and adjacent valid/invalid cases, not just syntax or one literal reproducer.",
                 "Return a concise account of changes, check IDs, requirements covered and anything genuinely unresolved. Never accept your own work or ask the user to fix a protocol field."].join("\n\n");
         });
@@ -267,6 +272,53 @@ export class WorkLoop {
             throw new Error("work-worker-inactive");
         return work;
     }
+    async activity(root, child, activity, result) {
+        await this.update(root, async (state) => {
+            const work = state.work;
+            if (!work || work.phase !== "running" || work.child !== child)
+                return;
+            const progress = work.progress ??= newWorkProgress();
+            if (result) {
+                const active = progress.active.find(item => item.id === activity.id);
+                if (!active)
+                    return;
+                progress.active = progress.active.filter(item => item.id !== activity.id);
+                progress.last = { ...active, ...result };
+                if (isWorkAction(activity.tool))
+                    progress.lastActionAt = Date.now();
+                if (result.status === "completed" && activity.tool === "patch")
+                    progress.edits++;
+            }
+            else if (!progress.active.some(item => item.id === activity.id)) {
+                if (progress.active.length >= 128)
+                    throw new Error("work-active-tool-limit");
+                progress.active.push(activity);
+                progress.tools++;
+                if (isWorkAction(activity.tool)) {
+                    progress.inspections = 0;
+                    progress.lastActionAt = Date.now();
+                    if (activity.tool !== "patch")
+                        progress.commands++;
+                }
+                else
+                    progress.inspections++;
+            }
+        });
+    }
+    async stall(root, callID, reason) {
+        return this.update(root, async (state) => {
+            const work = state.work;
+            if (!work || work.phase !== "running" || work.callID !== callID)
+                return false;
+            const progress = work.progress ??= newWorkProgress();
+            progress.stopped = { at: Date.now(), reason };
+            work.phase = "blocked";
+            work.assessment = reason;
+            work.updatedAt = Date.now();
+            work.feedback.push(`Host stopped unproductive discovery: ${reason}. Resume only with a concrete executable next step; preserve existing processes and results.`);
+            return true;
+        });
+    }
     async check(root, actor, command, timeout, signal, execute = runWorkCheck) {
         if (this.activeChecks.has(root))
             throw new Error("work-validation-already-running");

package/dist/core/work-progress.d.ts

@@ -0,0 +1,63 @@
+/** Host observations, not model-authored completion claims. */
+export interface WorkActivity {
+    id: string;
+    tool: string;
+    detail: string;
+    startedAt: number;
+}
+export interface WorkProgress {
+    startedAt: number;
+    lastActionAt: number;
+    inspections: number;
+    tools: number;
+    commands: number;
+    edits: number;
+    active: WorkActivity[];
+    last?: WorkActivity & {
+        status: string;
+        exit: number | null;
+    };
+    stopped?: {
+        at: number;
+        reason: string;
+    };
+}
+export declare const WORK_PROGRESS_LIMITS: {
+    readonly idleMs: 180000;
+    readonly inspections: 12;
+    readonly intervalMs: 5000;
+};
+export declare const isWorkAction: (tool: string) => boolean;
+export declare function newWorkProgress(now?: number): WorkProgress;
+export declare function progressLimit(progress: WorkProgress, now: number, idleMs: number, inspections: number): string | null;
+export declare function progressView(progress: WorkProgress, now?: number): {
+    phase: string;
+    elapsed_ms: number;
+    idle_ms: number;
+    summary: string;
+    note: string;
+    startedAt: number;
+    lastActionAt: number;
+    inspections: number;
+    tools: number;
+    commands: number;
+    edits: number;
+    active: WorkActivity[];
+    last?: WorkActivity & {
+        status: string;
+        exit: number | null;
+    };
+    stopped?: {
+        at: number;
+        reason: string;
+    };
+};
+type RecordValue = Record<string, any>;
+/** Repair only the outgoing context, including the trailing interrupted turn that native normalization misses.
+ * Persisted history/check receipts are never edited and a missing result is always an error, never success.
+ */
+export declare function repairWorkToolHistory(messages: RecordValue[]): {
+    messages: RecordValue[];
+    repaired: string[];
+};
+export {};

package/dist/core/work-progress.js

@@ -0,0 +1,55 @@
+export const WORK_PROGRESS_LIMITS = { idleMs: 180_000, inspections: 12, intervalMs: 5_000 };
+export const isWorkAction = (tool) => ["shell", "patch", "sortie_v011_check"].includes(tool);
+export function newWorkProgress(now = Date.now()) {
+    return { startedAt: now, lastActionAt: now, inspections: 0, tools: 0, commands: 0, edits: 0, active: [] };
+}
+export function progressLimit(progress, now, idleMs, inspections) {
+    // A running command/test has its native deadline; it is not model planning time.
+    if (progress.active.some(item => isWorkAction(item.tool)))
+        return null;
+    if (progress.inspections >= inspections)
+        return `discovery-limit: ${progress.inspections} inspection calls without an executable step`;
+    if (now - progress.lastActionAt >= idleMs)
+        return `planning-timeout: no executable step for ${Math.floor((now - progress.lastActionAt) / 1000)}s`;
+    return null;
+}
+export function progressView(progress, now = Date.now()) {
+    const active = progress.active.at(-1);
+    const phase = progress.stopped ? "blocked" : active ? isWorkAction(active.tool) ? "executing" : "inspecting" : "thinking";
+    return { ...progress, phase, elapsed_ms: Math.max(0, now - progress.startedAt),
+        idle_ms: Math.max(0, now - progress.lastActionAt),
+        summary: progress.stopped?.reason ?? (active ? `${active.tool}: ${active.detail}` :
+            progress.last ? `Last ${progress.last.tool}: ${progress.last.status}${progress.last.exit === null ? "" : ` (exit ${progress.last.exit})`}; awaiting next action` : "Waiting for first executable step"),
+        note: "Tool activity is not task completion. Command starts, edits and checks are observed separately; no benchmark score is inferred." };
+}
+/** Repair only the outgoing context, including the trailing interrupted turn that native normalization misses.
+ * Persisted history/check receipts are never edited and a missing result is always an error, never success.
+ */
+export function repairWorkToolHistory(messages) {
+    const result = [], pending = new Map(), repaired = [];
+    const flush = () => {
+        if (!pending.size)
+            return;
+        result.push({ role: "tool", content: [...pending.values()].map(call => {
+                repaired.push(call.id);
+                return { type: "tool-result", id: call.id, name: call.name, ...(call.namespace ? { namespace: call.namespace } : {}),
+                    result: { type: "error", value: "Native tool result unavailable after interruption. Execution/success is unverified. Inspect existing files and owned processes before retrying; do not duplicate a running job." } };
+            }) });
+        pending.clear();
+    };
+    for (const message of messages) {
+        if (["assistant", "user"].includes(message.role))
+            flush();
+        result.push(message);
+        for (const part of Array.isArray(message.content) ? message.content : []) {
+            if (part.providerExecuted === true)
+                continue;
+            if (message.role === "assistant" && part.type === "tool-call" && typeof part.id === "string")
+                pending.set(part.id, part);
+            if (message.role === "tool" && part.type === "tool-result")
+                pending.delete(part.id);
+        }
+    }
+    flush();
+    return { messages: repaired.length ? result : messages, repaired };
+}

package/dist/plugin/v2.d.ts

@@ -4,6 +4,9 @@ type Registration = {
     dispose(): Promise<void> | void;
 };
 interface V2ToolEditor {
+    update?(id: string, update: (tool: {
+        execute(input: unknown, context: JsonObject): Promise<JsonObject>;
+    }) => void): void;
     add(tool: {
         name: string;
         description: string;

package/dist/plugin/work-loop-v2.js

@@ -1,6 +1,7 @@
 import { WorkLoop, WORK_LIMITS, isRecord, workChanged, workCheckCurrent, workUnresolvedChecks } from "../core/work-loop.js";
 import { estimateModelUsageCost } from "./model-cost.js";
 import { resolve } from "node:path";
+import { WORK_PROGRESS_LIMITS, progressLimit, progressView, repairWorkToolHistory } from "../core/work-progress.js";
 export const V011_ROUTES = Object.freeze({
     operator: { providerID: "openai", id: "gpt-6-sol", variant: "xhigh" },
     worker: { providerID: "openai", id: "gpt-6-luna-fast", variant: "max" },
@@ -21,7 +22,17 @@ export function createUserProxyPlugin() {
             if (!Number.isInteger(configured) || Number(configured) < 1 || Number(configured) > 32)
                 throw new Error("work-max-attempts-invalid");
             const loop = new WorkLoop(context.location.directory, context.storage, Number(configured));
+            const option = (key, fallback, min, max) => {
+                const value = context.options?.[key] ?? fallback;
+                if (!Number.isInteger(value) || Number(value) < min || Number(value) > max)
+                    throw new Error(`work-${key}-invalid`);
+                return Number(value);
+            };
+            const planningMs = option("maxPlanningMs", WORK_PROGRESS_LIMITS.idleMs, 50, 3_600_000);
+            const discoveryCalls = option("maxDiscoveryCalls", WORK_PROGRESS_LIMITS.inspections, 1, 128);
+            const progressInterval = option("progressIntervalMs", WORK_PROGRESS_LIMITS.intervalMs, 10, 60_000);
             const controllers = new Map();
+            const monitors = new Set();
             const stopping = new Map();
             const lifetime = new AbortController();
             const info = async (id) => {
@@ -136,6 +147,8 @@ export function createUserProxyPlugin() {
                     unresolved_checks: unresolved.map(check => check.id),
                     check_results: work.checks.filter(check => checkIDs.includes(check.id)).map(check => ({ ...check })),
                     check_replacements: work.checkReplacements ?? [],
+                    child_session_id: work.child,
+                    progress: work.progress ? progressView(work.progress) : null,
                     ...(work.phase === "completed" ? { accepted_source_current: work.acceptedSource === source.fingerprint } : {}),
                     ...(work.phase === "ready" ? { task: loop.task(work), next: "Call the native subagent tool with this task unchanged, in the foreground." }
                         : { next: work.phase === "review" ? "Compare all original requests with actual changes and check evidence, then call review_work. Revise on any omission."
@@ -151,7 +164,7 @@ export function createUserProxyPlugin() {
                     for (const controller of controllers.get(id) ?? [])
                         controller.abort();
                     if (work?.child && !["completed", "cancelled"].includes(work.phase)) {
-                        await context.session.interrupt({ sessionID: work.child, resume: false });
+                        await context.session.interrupt({ sessionID: work.child, continue: false });
                     }
                 })();
                 stopping.set(id, operation);
@@ -169,6 +182,63 @@ export function createUserProxyPlugin() {
                 editor.update(worker, agent => { agent.model = { ...V011_ROUTES.worker }; });
             });
             await context.tool.transform(editor => {
+                // Keep the real native child card and executor. Publish host observations on that outstanding card,
+                // without synthetic prompts, a second model loop, or a hidden shell implementation.
+                editor.update?.("subagent", tool => {
+                    const execute = tool.execute;
+                    tool.execute = async (input, execution) => {
+                        if (!isRecord(input) || input.agent !== worker)
+                            return execute(input, execution);
+                        const id = String(execution.sessionID), session = await info(id);
+                        if (session.agent !== primary || session.parentID)
+                            return execute(input, execution);
+                        const work = await loop.current(id);
+                        if (!work || work.phase !== "running" || work.callID !== execution.id)
+                            throw new Error("work-dispatch-not-admitted");
+                        const report = typeof execution.progress === "function" ? execution.progress : async () => { };
+                        let metadata = {}, ended = false, pending;
+                        const publish = async () => {
+                            const current = await loop.current(id);
+                            if (!current || current.id !== work.id || current.callID !== work.callID || !current.progress)
+                                return;
+                            const progress = progressView(current.progress);
+                            await report({ ...metadata, ...(current.child ? { sessionID: current.child } : {}),
+                                description: `${progress.phase} · ${Math.floor(progress.elapsed_ms / 1000)}s · ${progress.summary}`,
+                                sortie_progress: progress });
+                            const reason = current.phase === "running" ? progressLimit(current.progress, Date.now(), planningMs, discoveryCalls) : null;
+                            if (reason && await loop.stall(id, work.callID, reason)) {
+                                // Mark blocked first, so the native interrupted event cannot turn this into a resumable blind retry.
+                                if (current.child)
+                                    await context.session.interrupt({ sessionID: current.child, continue: false });
+                                await report({ ...metadata, ...(current.child ? { sessionID: current.child } : {}),
+                                    description: `BLOCKED · ${reason}`, sortie_progress: progressView((await loop.current(id)).progress) });
+                            }
+                        };
+                        const tick = () => {
+                            if (ended || pending || lifetime.signal.aborted)
+                                return;
+                            pending = publish().catch(error => { console.warn("[sortie-dogs-v011] progress", error instanceof Error ? error.message : "unknown"); })
+                                .finally(() => { pending = undefined; });
+                        };
+                        const timer = setInterval(tick, progressInterval);
+                        monitors.add(timer);
+                        try {
+                            await publish();
+                            const result = await execute(input, { ...execution, progress: async (update) => {
+                                    metadata = { ...metadata, ...update };
+                                    await publish();
+                                } });
+                            return { ...result, metadata: { ...metadata, ...(isRecord(result.metadata) ? result.metadata : {}),
+                                    sortie_progress: (await loop.current(id))?.progress ? progressView((await loop.current(id)).progress) : null } };
+                        }
+                        finally {
+                            ended = true;
+                            clearInterval(timer);
+                            monitors.delete(timer);
+                            await pending;
+                        }
+                    };
+                });
                 const add = (name, description, input, execute) => editor.add({ name: `sortie_v011_${name}`, description, input, options: { codemode: false },
                     execute: async (args, execution) => ({ content: JSON.stringify(await execute(isRecord(args) ? args : {}, execution)) }) });
                 add("start_work", "Operator: delegate the user's actual request to the low-cost implementer. The host retains original instructions; supply only concise extra guidance. Also resumes interrupted work without resetting attempts.", objectSchema({ instructions: { type: "string", maxLength: 8000 } }), async (args, execution) => {
@@ -282,6 +352,9 @@ export function createUserProxyPlugin() {
                     await loop.assertWorker(owner, id);
                     if (event.tool === "subagent")
                         throw new Error("work-worker-does-not-delegate");
+                    const input = isRecord(event.input) ? event.input : {};
+                    await loop.activity(owner, id, { id: String(event.id), tool: String(event.tool), startedAt: Date.now(),
+                        detail: String(input.command ?? input.path ?? input.pattern ?? event.tool).replace(/\s+/gu, " ").slice(0, 240) });
                 }
                 else if (event.tool === "subagent" && isRecord(event.input)) {
                     if (event.input.agent === worker)
@@ -291,9 +364,15 @@ export function createUserProxyPlugin() {
                 }
             });
             await context.tool.hook("execute.after", async (event) => {
+                const id = String(event.sessionID), session = await info(id);
+                if (session.agent === worker) {
+                    const result = isRecord(event.result) ? event.result : {};
+                    const output = isRecord(result.output) ? result.output : result.metadata;
+                    await loop.activity(await root(id), id, { id: String(event.id), tool: String(event.tool), detail: "", startedAt: 0 }, { status: output?.status === "running" ? "background-started" : String(event.status), exit: Number.isInteger(output?.exit) ? output.exit : null });
+                    return;
+                }
                 if (event.tool !== "subagent")
                     return;
-                const id = String(event.sessionID), session = await info(id);
                 if (session.agent !== primary || session.parentID)
                     return;
                 const result = isRecord(event.result) ? event.result : {};
@@ -307,6 +386,8 @@ export function createUserProxyPlugin() {
                     throw new Error("Sortie v0.11 requires SOL6 or Luna6. Set the selected session and auxiliary compaction/title agents to these models; reviewer/advisor settings are independent.");
                 }
                 const owner = await root(String(event.sessionID)), work = await loop.current(owner);
+                if (Array.isArray(event.messages))
+                    event.messages = repairWorkToolHistory(event.messages).messages;
                 if (([V011_ROUTES.worker.id, "gpt-6-luna"].includes(event.model?.id) || (!event.model && session.agent === worker)) && isRecord(event.options)) {
                     // OpenAI documents priority as the backwards-compatible spelling of Fast mode.
                     event.options.serviceTier = "priority";
@@ -315,11 +396,16 @@ export function createUserProxyPlugin() {
                     event.system.push({ type: "text", text: `SORTIE v0.11 durable work ${work.id}; phase=${work.phase}. User intent survives compaction. ` +
                             (session.agent === primary ? "Your role is the user's proxy: delegate routine work, compare results with every original instruction, and accept only with review_work. " : "You own all routine investigation, edits, testing and corrections. ") +
                             "Use work_status after compaction for current evidence. Do not reconstruct a proposal or an execution manifest." });
+                if (session.agent === worker && work?.progress && Array.isArray(event.system)) {
+                    event.system.push({ type: "text", text: `Execution pacing: ${work.progress.inspections}/${discoveryCalls} inspection calls since the last executable step; planning limit ${planningMs / 1000}s. ` +
+                            "Reuse supplied paths and documented commands. Run the relevant reproduction or existing controller early. For long work, use the native shell/controller and its existing ledger; do not repeatedly poll or invent a replacement runner. If blocked, return the exact blocker promptly." });
+                }
                 if (session.agent === worker && work && Array.isArray(event.system) && work.requests.length > (work.deliveredRequests ?? 0)) {
                     event.system.push({ type: "text", text: "Additional original user instructions received during execution:\n" +
                             work.requests.slice(work.deliveredRequests ?? 0).map(request => request.text).join("\n\n") });
                 }
                 if (session.agent === worker && isRecord(event.tools)) {
+                    delete event.tools.subagent;
                     for (const name of Object.keys(event.tools))
                         if (name.startsWith("sortie_v011_") && !["sortie_v011_check", "sortie_v011_work_status", "sortie_v011_compact"].includes(name))
                             delete event.tools[name];
@@ -382,9 +468,15 @@ export function createUserProxyPlugin() {
                 }
             })().catch(error => { if (!lifetime.signal.aborted)
                 console.warn("[sortie-dogs-v011] event stream", error); });
-            return () => { lifetime.abort(); for (const active of controllers.values())
-                for (const controller of active)
-                    controller.abort(); };
+            return () => {
+                lifetime.abort();
+                for (const timer of monitors)
+                    clearInterval(timer);
+                monitors.clear();
+                for (const active of controllers.values())
+                    for (const controller of active)
+                        controller.abort();
+            };
         },
     };
 }

package/dist/runtime-assets-v011.d.ts

@@ -1,4 +1,4 @@
 import type { RuntimeAsset } from "./runtime-assets.js";
-export declare const OPERATOR_INSTRUCTIONS = "# Sortie-dogs v0.11 \u2014 the user's proxy\n\nYou are the only user-facing operator. Your job is to protect the user's actual intent and quality while a cheaper\nimplementer handles the work. Use the user's language. Preserve negative constraints, references and completion conditions.\n\nFor an action request:\n1. Give a plan of at most three lines. Call sortie_v011_start_work, adding only short useful guidance.\n   The host retains the original request automatically. Dispatch the returned task through subagent verbatim, foreground.\n2. Let dogs-coordinator investigate, implement, test and fix problems inside that one invocation. It has native search,\n   editing and shell tools. Do not perform routine reconnaissance yourself or precompute a list of files and commands.\n3. After the child returns, call sortie_v011_work_status. Inspect the actual changed source/diff and validation receipts.\n    Compare every original user instruction, including prohibitions and quality requirements, with the result.\n    A worker's confident summary and a passing irrelevant test are insufficient. Read any relevant source the packet omits.\n    Inspect stored check output with work_status(check_ids=[...]), especially failed/blocked checks and claimed behavior tests.\n    Confirm the reproduction exercises the actual changed library path, and nearby valid/invalid behavior is covered.\n    For an exception guard or fallback, challenge its failure boundary: can another ordinary failure of the guarded operation\n    still escape? Require evidence for distinct failure mechanisms, or a source-grounded reason why they should propagate.\n    Several variations that trigger the same failure are not evidence that the boundary is complete. Delegate missing probes.\n4. If anything is missing, call sortie_v011_review_work with decision=revise and precise correction feedback, then dispatch\n    its returned task. This resumes the same cheap child. If complete, use decision=accept with relevant current successful\n    check IDs and a substantive assessment of requirement coverage. Only its succeeded receipt means accepted completion.\n\nEvery formal check remains an obligation until it passes on the final source. Source edits and unrelated passing checks\ndo not erase failures. When a corrected or combined command truly covers an earlier check, use check_replacements with\nthe old check ID, the selected passing replacement ID, and the reason its behavioral coverage is equivalent or stronger.\nNever use that mechanism to excuse unavailable tests or substitute compilation/environment discovery for behavior tests.\nRepair ordinary dependency/setup/collection problems through the implementer within the user's limits. If required\nverification genuinely cannot run, report decision=blocked with the exact blocker; partial work is not succeeded completion.\nWhen the blocker is resolved, start_work resumes the same job and child. Do not restrict permitted dependency installation\nmerely because source browsing or solution retrieval is forbidden; preserve the user's actual permission boundaries.\n\nKeep this loop simple. You author neither a proposal nor a GoalDeclaration, manifest, milestone/proof mapping or speculative\nwhole-project plan. The implementer chooses technical steps as it learns. Keep all accepted scope; cost savings must never\njustify an easier objective, hidden omissions, changed oracles or unsupported success claims.\n\nAnswer ordinary questions directly. Request user decisions only for actual ambiguity, missing authority or external blockers.\nUse existing dog-reviewer-v010 / dog-advisor-v010 only when independent review or a material design question warrants it;\nprovide concrete source/evidence and preserve their existing role instructions. Do not create an extra mandatory review layer.\nKeep costs down by inspecting compact evidence rather than repeating the implementer's full investigation.\n\nOpenCode owns normal continuation and compaction. After compaction or restart, work_status restores authoritative state.\nAn interrupted job resumes with start_work without losing requests or resetting attempts. Respect cancellation; cancel_work\nstops the owned child. Never claim DONE on interruption or launch a second overlapping implementer.\n\nFinish concisely with \u2705 DONE, \u23F8 INTERRUPTED, \u26D4 BLOCKED or \u2753 NEED_DECISION, changes, verification and any next action.\nFor completed implementation cite the real receipt and checks. Include host-reported costs as estimates when available;\ndo not invent spend, scores or success. Follow project AGENTS.md.\n";
-export declare const IMPLEMENTER_INSTRUCTIONS = "# Sortie-dogs v0.11 \u2014 low-cost implementer\n\nYou handle the entire routine task for the user-facing operator: investigate, find files, edit, prepare dependencies,\nbuild, test, diagnose failures, correct them and report evidence. Use the user's language and follow project AGENTS.md.\nUse native glob/grep/read/patch/shell tools. Discover the correct implementation and verification commands as you work.\nThere is no proposal submission, pre-approved exact-file manifest, or milestone schema to fill in.\n\nTreat a reported example as an entry point to the affected behavior, not the entire specification. Inspect the surrounding\nimplementation, analogous paths and tests to identify nearby valid inputs, invalid inputs and boundary/error conditions.\nFor a bug fix, test that relevant family of behavior through the actual library/API, using repository-established semantics.\nDo not stop at the single reported exception or literal input, invent new behavior, or broaden exception handling blindly.\nWhen changing a fallback/exception boundary, first identify the guarded operation's ordinary failure modes from its public\ncontract, local implementation, analogous handlers or small runtime probes. Exercise distinct mechanisms such as missing\ninputs, invalid content and incompatible input types where applicable, then check whether each should take the same fallback\nor deliberately propagate. A syntactic variation of the original example does not test a different failure mechanism.\nReport the failure classes checked, their expected behavior and actual verification in a few lines, so the operator can\nchallenge omissions. Preserve successful behavior and avoid catching unrelated programmer/system errors indiscriminately.\nFor dependencies, follow the repository's declared build/runtime/test requirements and use permitted package registries.\nDiagnose the actual install failure before declaring a blocker; an unnecessary offline flag or conflicting local pin is\noften a repairable setup choice, not an external outage. Respect the user's setup time and authority limits.\n\nThe incoming host-expanded task includes every original user instruction and the operator's feedback. Preserve all of it,\nincluding negative constraints and quality requirements. Do not substitute easier deliverables or weaken tests to pass.\nDo not spawn other agents. Do not ask the user to repair protocol fields. Resolve ordinary technical problems yourself.\nReturn to the operator only for a real scope/authority decision, a genuine external blocker, or finished work.\n\nRun meaningful final verification through sortie_v011_check, which executes the command and records actual exit status\nand source identity. You may use shell for discovery and exploratory checks. Fix failing required checks and repeat affected\nchecks after the last edit. Generation/build may change source: run the final oracle after those outputs are stable.\nKeep a final check command stable when rerunning it. If it must change, explain which earlier check it replaces and why it\npreserves coverage. A collection/import failure is unverified behavior, not a passing test; syntax checks cannot replace it.\nNative compaction preserves the work; use work_status to recover it when needed. Keep working until the requested scope is\ncomplete. A returned correction task resumes this same session; apply the feedback and verify again.\n\nReturn a short report of changed files, requirement coverage, actual check IDs and unresolved items. Include relevant\ncommands/results, not a full tool transcript. Only the operator accepts work. Never say all requirements are met if any\nremain unverified. SOL6 and Luna6 Fast are the execution model families; this role uses Luna6 with Fast service tier.\n";
+export declare const OPERATOR_INSTRUCTIONS = "# Sortie-dogs v0.11 \u2014 the user's proxy\n\nYou are the only user-facing operator. Your job is to protect the user's actual intent and quality while a cheaper\nimplementer handles the work. Use the user's language. Preserve negative constraints, references and completion conditions.\n\nFor an action request:\n1. State the immediate action in at most three lines. Call sortie_v011_start_work, adding only short useful guidance.\n   Pass known runner, artifact, manifest and ledger paths from the conversation instead of making the child rediscover them.\n   The host retains the original request automatically. Dispatch the returned task through subagent verbatim, foreground.\n2. Let dogs-coordinator investigate, implement, test and fix problems inside that one invocation. It has native search,\n   editing and shell tools. Do not perform routine reconnaissance yourself or precompute a list of files and commands.\n3. After the child returns, call sortie_v011_work_status. Inspect the actual changed source/diff and validation receipts.\n    Compare every original user instruction, including prohibitions and quality requirements, with the result.\n    A worker's confident summary and a passing irrelevant test are insufficient. Read any relevant source the packet omits.\n    Inspect stored check output with work_status(check_ids=[...]), especially failed/blocked checks and claimed behavior tests.\n    Confirm the reproduction exercises the actual changed library path, and nearby valid/invalid behavior is covered.\n    For an exception guard or fallback, challenge its failure boundary: can another ordinary failure of the guarded operation\n    still escape? Require evidence for distinct failure mechanisms, or a source-grounded reason why they should propagate.\n    Several variations that trigger the same failure are not evidence that the boundary is complete. Delegate missing probes.\n4. If anything is missing, call sortie_v011_review_work with decision=revise and precise correction feedback, then dispatch\n    its returned task. This resumes the same cheap child. If complete, use decision=accept with relevant current successful\n    check IDs and a substantive assessment of requirement coverage. Only its succeeded receipt means accepted completion.\n\nEvery formal check remains an obligation until it passes on the final source. Source edits and unrelated passing checks\ndo not erase failures. When a corrected or combined command truly covers an earlier check, use check_replacements with\nthe old check ID, the selected passing replacement ID, and the reason its behavioral coverage is equivalent or stronger.\nNever use that mechanism to excuse unavailable tests or substitute compilation/environment discovery for behavior tests.\nRepair ordinary dependency/setup/collection problems through the implementer within the user's limits. If required\nverification genuinely cannot run, report decision=blocked with the exact blocker; partial work is not succeeded completion.\nWhen the blocker is resolved, start_work resumes the same job and child. Do not restrict permitted dependency installation\nmerely because source browsing or solution retrieval is forbidden; preserve the user's actual permission boundaries.\n\nKeep this loop simple. You author neither a proposal nor a GoalDeclaration, manifest, milestone/proof mapping or speculative\nwhole-project plan. The implementer chooses technical steps as it learns. Keep all accepted scope; cost savings must never\njustify an easier objective, hidden omissions, changed oracles or unsupported success claims.\n\nAnswer ordinary questions directly. Request user decisions only for actual ambiguity, missing authority or external blockers.\nUse existing dog-reviewer-v010 / dog-advisor-v010 only when independent review or a material design question warrants it;\nprovide concrete source/evidence and preserve their existing role instructions. Do not create an extra mandatory review layer.\nKeep costs down by inspecting compact evidence rather than repeating the implementer's full investigation.\n\nOpenCode owns normal continuation and compaction. After compaction or restart, work_status restores authoritative state.\nAn interrupted job resumes with start_work without losing requests or resetting attempts. Respect cancellation; cancel_work\nstops the owned child. Never claim DONE on interruption or launch a second overlapping implementer.\n\nThe host publishes observed activity on the native child call and work_status: current command/inspection, elapsed time,\nlast exit, command starts and edits. These are activity, not completed work or benchmark scores. A detached launch is not\ncompletion; use its existing native controller/ledger and actual terminal evidence. Do not poll while a background tool\nhas promised a completion notification. For a benchmark campaign, report queued/running/scored/pass/fail only from its ledger.\nThe host returns blocked after 12 inspection calls or 3 minutes without an executable step (configurable). Running native\ncommands keep their own timeout. When this happens, inspect the concrete blocker and give a specific next command, not\n\"continue investigating\". Do not blindly retry the same stalled child. Preserve its session, checks and attempt budget.\n\nFinish concisely with \u2705 DONE, \u23F8 INTERRUPTED, \u26D4 BLOCKED or \u2753 NEED_DECISION, changes, verification and any next action.\nFor completed implementation cite the real receipt and checks. Include host-reported costs as estimates when available;\ndo not invent spend, scores or success. Follow project AGENTS.md.\n";
+export declare const IMPLEMENTER_INSTRUCTIONS = "# Sortie-dogs v0.11 \u2014 low-cost implementer\n\nYou handle the entire routine task for the user-facing operator: investigate, find files, edit, prepare dependencies,\nbuild, test, diagnose failures, correct them and report evidence. Use the user's language and follow project AGENTS.md.\nUse native glob/grep/read/patch/shell tools. Discover the correct implementation and verification commands as you work.\nThere is no proposal submission, pre-approved exact-file manifest, or milestone schema to fill in.\n\nExecute early. Start with the supplied paths and the relevant documented entrypoint. In an execution-only task, reuse the\nexisting runner/controller and fixed inputs; do not build a replacement controller, redesign accounting or rerun unrelated\nfull suites before starting the requested work. For a fix, run a small reproduction early and interleave inspection with\nconcrete edits/checks. After 6 inspection tools, choose the next executable step; the host bounds discovery at 12 calls or\n3 minutes without one. If that step cannot run, report its exact prerequisite/blocker promptly. Do not use trivial shell\ncommands to reset the discovery counter. Long commands run through native shell/controller ownership with real progress\nand exit evidence, rather than repeated model turns. Do not poll when a background completion notification is pending.\n\nTreat a reported example as an entry point to the affected behavior, not the entire specification. Inspect the surrounding\nimplementation, analogous paths and tests to identify nearby valid inputs, invalid inputs and boundary/error conditions.\nFor a bug fix, test that relevant family of behavior through the actual library/API, using repository-established semantics.\nDo not stop at the single reported exception or literal input, invent new behavior, or broaden exception handling blindly.\nWhen changing a fallback/exception boundary, first identify the guarded operation's ordinary failure modes from its public\ncontract, local implementation, analogous handlers or small runtime probes. Exercise distinct mechanisms such as missing\ninputs, invalid content and incompatible input types where applicable, then check whether each should take the same fallback\nor deliberately propagate. A syntactic variation of the original example does not test a different failure mechanism.\nReport the failure classes checked, their expected behavior and actual verification in a few lines, so the operator can\nchallenge omissions. Preserve successful behavior and avoid catching unrelated programmer/system errors indiscriminately.\nFor dependencies, follow the repository's declared build/runtime/test requirements and use permitted package registries.\nDiagnose the actual install failure before declaring a blocker; an unnecessary offline flag or conflicting local pin is\noften a repairable setup choice, not an external outage. Respect the user's setup time and authority limits.\n\nThe incoming host-expanded task includes every original user instruction and the operator's feedback. Preserve all of it,\nincluding negative constraints and quality requirements. Do not substitute easier deliverables or weaken tests to pass.\nDo not spawn other agents. Do not ask the user to repair protocol fields. Resolve ordinary technical problems yourself.\nReturn to the operator only for a real scope/authority decision, a genuine external blocker, or finished work.\n\nRun meaningful final verification through sortie_v011_check, which executes the command and records actual exit status\nand source identity. You may use shell for discovery and exploratory checks. Fix failing required checks and repeat affected\nchecks after the last edit. Generation/build may change source: run the final oracle after those outputs are stable.\nKeep a final check command stable when rerunning it. If it must change, explain which earlier check it replaces and why it\npreserves coverage. A collection/import failure is unverified behavior, not a passing test; syntax checks cannot replace it.\nNative compaction preserves the work; use work_status to recover it when needed. Keep working until the requested scope is\ncomplete. A returned correction task resumes this same session; apply the feedback and verify again.\n\nReturn a short report of changed files, requirement coverage, actual check IDs and unresolved items. Include relevant\ncommands/results, not a full tool transcript. Only the operator accepts work. Never say all requirements are met if any\nremain unverified. SOL6 and Luna6 Fast are the execution model families; this role uses Luna6 with Fast service tier.\n";
 export declare const runtimeAssets: readonly RuntimeAsset[];

package/dist/runtime-assets-v011.js

@@ -6,7 +6,8 @@ You are the only user-facing operator. Your job is to protect the user's actual
 implementer handles the work. Use the user's language. Preserve negative constraints, references and completion conditions.
 
 For an action request:
-1. Give a plan of at most three lines. Call sortie_v011_start_work, adding only short useful guidance.
+1. State the immediate action in at most three lines. Call sortie_v011_start_work, adding only short useful guidance.
+   Pass known runner, artifact, manifest and ledger paths from the conversation instead of making the child rediscover them.
    The host retains the original request automatically. Dispatch the returned task through subagent verbatim, foreground.
 2. Let dogs-coordinator investigate, implement, test and fix problems inside that one invocation. It has native search,
    editing and shell tools. Do not perform routine reconnaissance yourself or precompute a list of files and commands.
@@ -44,6 +45,14 @@ OpenCode owns normal continuation and compaction. After compaction or restart, w
 An interrupted job resumes with start_work without losing requests or resetting attempts. Respect cancellation; cancel_work
 stops the owned child. Never claim DONE on interruption or launch a second overlapping implementer.
 
+The host publishes observed activity on the native child call and work_status: current command/inspection, elapsed time,
+last exit, command starts and edits. These are activity, not completed work or benchmark scores. A detached launch is not
+completion; use its existing native controller/ledger and actual terminal evidence. Do not poll while a background tool
+has promised a completion notification. For a benchmark campaign, report queued/running/scored/pass/fail only from its ledger.
+The host returns blocked after 12 inspection calls or 3 minutes without an executable step (configurable). Running native
+commands keep their own timeout. When this happens, inspect the concrete blocker and give a specific next command, not
+"continue investigating". Do not blindly retry the same stalled child. Preserve its session, checks and attempt budget.
+
 Finish concisely with ✅ DONE, ⏸ INTERRUPTED, ⛔ BLOCKED or ❓ NEED_DECISION, changes, verification and any next action.
 For completed implementation cite the real receipt and checks. Include host-reported costs as estimates when available;
 do not invent spend, scores or success. Follow project AGENTS.md.
@@ -55,6 +64,14 @@ build, test, diagnose failures, correct them and report evidence. Use the user's
 Use native glob/grep/read/patch/shell tools. Discover the correct implementation and verification commands as you work.
 There is no proposal submission, pre-approved exact-file manifest, or milestone schema to fill in.
 
+Execute early. Start with the supplied paths and the relevant documented entrypoint. In an execution-only task, reuse the
+existing runner/controller and fixed inputs; do not build a replacement controller, redesign accounting or rerun unrelated
+full suites before starting the requested work. For a fix, run a small reproduction early and interleave inspection with
+concrete edits/checks. After 6 inspection tools, choose the next executable step; the host bounds discovery at 12 calls or
+3 minutes without one. If that step cannot run, report its exact prerequisite/blocker promptly. Do not use trivial shell
+commands to reset the discovery counter. Long commands run through native shell/controller ownership with real progress
+and exit evidence, rather than repeated model turns. Do not poll when a background completion notification is pending.
+
 Treat a reported example as an entry point to the affected behavior, not the entire specification. Inspect the surrounding
 implementation, analogous paths and tests to identify nearby valid inputs, invalid inputs and boundary/error conditions.
 For a bug fix, test that relevant family of behavior through the actual library/API, using repository-established semantics.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sortie-dogs",
-  "version": "0.11.0",
+  "version": "0.11.1",
   "description": "Bounded agent harness and validated orchestration loop plugin for OpenCode",
   "keywords": [
     "opencode",