sortie-dogs 0.12.13 → 0.12.14

package/dist/asset-version.d.ts

@@ -3,5 +3,5 @@
  * installed project marker without importing every asset body.
  */
 export declare const RUNTIME_ASSET_VERSION = "0.3.89-completion-proof-v1";
-export declare const V010_RUNTIME_ASSET_VERSION = "0.12.13-mission-cold-recovery-v1";
+export declare const V010_RUNTIME_ASSET_VERSION = "0.12.14-worker-context-progress-v1";
 export type RuntimeAssetVersion = typeof RUNTIME_ASSET_VERSION | typeof V010_RUNTIME_ASSET_VERSION;

package/dist/asset-version.js

@@ -3,4 +3,4 @@
  * installed project marker without importing every asset body.
  */
 export const RUNTIME_ASSET_VERSION = "0.3.89-completion-proof-v1";
-export const V010_RUNTIME_ASSET_VERSION = "0.12.13-mission-cold-recovery-v1";
+export const V010_RUNTIME_ASSET_VERSION = "0.12.14-worker-context-progress-v1";

package/dist/core/operator-mission.js

@@ -358,6 +358,8 @@ export function missionPacket(mission, run) {
         ...(run ? { run_id: run.runID, status: run.phase, decision: run.decision,
             units: run.units.map(unit => ({ id: unit.unit.id, title: unit.unit.title, status: unit.status,
                 child_session_id: unit.childSessionID, result_class: unit.resultClass, evidence: unit.evidence,
+                handoff_path: unit.handoffPath, operation_manifest_path: unit.manifestPath,
+                scope_read: unit.unit.read, scope_write: unit.unit.write, validation: unit.unit.validation,
                 ...(unit.dispatchDenial ? { dispatch_denial: unit.dispatchDenial } : {}) })) } : {}),
         next_action: mission.phase === "completed" ? "Mission completed. Report the accepted result and retained review gaps; no further dispatch or completion call is needed."
             : mission.phase === "submitted" && mission.submission?.status === "ready"

package/dist/core/operator-runtime.d.ts

@@ -340,6 +340,8 @@ export declare class OperatorRuntime {
     completionGoalFingerprint(state: OperatorState): Promise<string>;
     verifyContinuityControls(state: OperatorState): Promise<void>;
     packet(state: OperatorState): unknown;
+    /** Reconstruct the admitted child's instructions without trusting a lossy conversation summary. */
+    workerContext(root: string, child: string): Promise<string | undefined>;
     continuationCheckpoint(root: string): Promise<string | undefined>;
     private verifyControls;
     /** Follow only the host's authorized parent-link repair; keep the durable control pin in sync. */

package/dist/core/operator-runtime.js

@@ -1919,6 +1919,26 @@ export class OperatorRuntime {
             throw new Error("operator-packet-too-large-no-evidence-truncated");
         return packet;
     }
+    /** Reconstruct the admitted child's instructions without trusting a lossy conversation summary. */
+    async workerContext(root, child) {
+        const state = await this.read(root);
+        if (!state || state.phase !== "running")
+            return undefined;
+        const unit = state.units.find(item => item.childSessionID === child && item.status === "running");
+        if (!unit)
+            return undefined;
+        // Keep this prefix stable across reads/edits: changing counters belong in status/tool results.
+        return `SORTIE_WORKER_CONTEXT\n${JSON.stringify({ root_session_id: root, run_id: state.runID,
+            unit_id: unit.unit.id, task_id: /^task_id: (.+)$/m.exec(unit.task.prompt)?.[1],
+            project_root: this.projectRoot, handoff_path: unit.handoffPath, operation_manifest: unit.manifestPath,
+            objective: unit.unit.objective, read: unit.unit.read, write: unit.unit.write,
+            validation: unit.unit.validation, acceptance: state.acceptance,
+            ...(unit.repairValidation === null ? {} : { validation_only: true }),
+        })}\nThis is the durable assignment for this same Worker, including after compaction or reload. ` +
+            "A missing path in a summary does not mean the handoff is missing. Read the retained handoff/manifest and inspect the actual diff and outputs before claiming no edits or replaying work. " +
+            `Use ${this.profile.toolPrefix}operator_status for observed validation and remaining work; do not repeat successful checks for an unchanged candidate. ` +
+            "This context is an assignment, not proof of execution or acceptance.";
+    }
     async continuationCheckpoint(root) {
         const state = await this.read(root);
         const cancelledRemediation = state?.phase === "cancelled" &&

package/dist/plugin/mission-progress.d.ts

@@ -1,5 +1,6 @@
-/** Display-only native Task progress. Never prompts a model or changes execution ownership. */
 type Sink = (value: Record<string, unknown>) => Promise<void>;
 export declare function bindMissionProgress(root: string, sink: Sink): () => void;
 export declare function publishMissionProgress(root: string, value: Record<string, unknown>): Promise<void>;
+/** Read durable transitions even when settlement ran in a different/reloaded plugin instance. */
+export declare function missionProgressReader(directory: string, root: string, callID: string): () => Promise<Record<string, unknown> | undefined>;
 export {};

package/dist/plugin/mission-progress.js

@@ -1,3 +1,7 @@
+/** Display-only native Task progress. Never prompts a model or changes execution ownership. */
+import { OperatorMissionRuntime } from "../core/operator-mission.js";
+import { OperatorRuntime } from "../core/operator-runtime.js";
+import { V010_RUNTIME_PROFILE } from "../core/runtime-profile.js";
 const sinks = new Map();
 export function bindMissionProgress(root, sink) {
     sinks.set(root, sink);
@@ -7,3 +11,27 @@ export function bindMissionProgress(root, sink) {
 export async function publishMissionProgress(root, value) {
     await sinks.get(root)?.(value).catch(() => undefined);
 }
+/** Read durable transitions even when settlement ran in a different/reloaded plugin instance. */
+export function missionProgressReader(directory, root, callID) {
+    const missions = new OperatorMissionRuntime(directory, V010_RUNTIME_PROFILE);
+    return async () => {
+        const mission = await missions.read(root);
+        if (!mission || mission.callID !== callID)
+            return undefined;
+        // OperatorRuntime caches its own writes; a display observer must read a fresh disk snapshot.
+        const run = await new OperatorRuntime(directory, V010_RUNTIME_PROFILE).read(root);
+        const units = run?.runID === mission.runID ? run.units : [];
+        const running = units.find(unit => unit.status === "running");
+        const last = mission.progress.at(-1);
+        const status = running ? "running" : last?.status ?? mission.phase;
+        const title = running?.unit.title ?? last?.title ?? mission.requirements[0]?.text ?? "Coordinator";
+        return { description: `🐾 ${status}: ${title}`, sortie_progress: {
+                mission_id: mission.id, phase: mission.phase, unit: running ? `${run.runID}/${running.unit.id}` : last?.unit ?? null,
+                title, status, child_session_id: running?.childSessionID ?? null,
+                completed_units: units.filter(unit => unit.status === "succeeded").length,
+                failed_units: units.filter(unit => unit.status === "failed").length,
+                historical_failed_attempts: mission.progress.filter(unit => unit.status === "failed").length,
+                accepted: mission.phase === "completed",
+            } };
+    };
+}

package/dist/plugin/profiled.js

@@ -2112,6 +2112,11 @@ export function createProfiledPlugin(profile, assetVersion) {
                 (output.system ??= []).push(`SORTIE_RUNTIME_PROFILE ${profile.id}; marker ${assetVersion}. ` +
                     `Shared MkII protocol role names are logical: ${protocolMap}. Use only ${profile.toolPrefix} tools for this profile. ` +
                     "Never rewrite user acceptance or evidence to rename protocol roles. Final acceptance belongs only to the root coordinator.");
+                if ((await identity(request.sessionID)).role === "dog-worker") {
+                    const context = await operators.workerContext(root, request.sessionID);
+                    if (context)
+                        (output.system ??= []).push(context);
+                }
                 const proposal = await proposals.read(root);
                 if (proposal?.phase !== "approved" && proposal?.proposal_session_id === request.sessionID) {
                     // Only immutable identity and the frozen budget caps belong here. Consumed counters move with
@@ -2166,6 +2171,12 @@ export function createProfiledPlugin(profile, assetVersion) {
                 const root = await rootFor(request.sessionID);
                 if (!root)
                     return;
+                if ((await identity(request.sessionID)).role === "dog-worker") {
+                    const context = await operators.workerContext(root, request.sessionID);
+                    if (context)
+                        (output.context ??= []).push(context +
+                            " Preserve the actual edits, tool outcomes and next action in the summary; do not replace them with an empty-work claim.");
+                }
                 if ((await identity(request.sessionID)).role === "dog-operator") {
                     const mission = await missions.read(root);
                     if (mission?.coordinator === request.sessionID) {

package/dist/plugin/v2.js

@@ -1,5 +1,5 @@
 import { SortieDogsV010Plugin } from "./profiled.js";
-import { bindMissionProgress } from "./mission-progress.js";
+import { bindMissionProgress, missionProgressReader } from "./mission-progress.js";
 import { owningServiceSessionList } from "./v2-session-history.js";
 import { createHash } from "node:crypto";
 import { readFileSync } from "node:fs";
@@ -332,18 +332,50 @@ async function registerV2Hooks(context, hooks) {
                     return execute(value, execution);
                 const report = execution.progress;
                 let metadata = {};
-                const unbind = bindMissionProgress(String(execution.sessionID), async (progress) => {
-                    metadata = { ...metadata, ...progress };
-                    await report(metadata);
-                });
+                let pending = Promise.resolve();
+                const update = (update) => {
+                    metadata = { ...metadata, ...update };
+                    const snapshot = { ...metadata };
+                    pending = pending.catch(() => undefined).then(() => report(snapshot));
+                    return pending;
+                };
+                const unbind = bindMissionProgress(String(execution.sessionID), update);
+                const readProgress = missionProgressReader(context.location.directory, String(execution.sessionID), String(execution.id));
+                let previous = "", reading;
+                const refresh = () => {
+                    if (reading)
+                        return reading;
+                    reading = (async () => {
+                        try {
+                            const progress = await readProgress(), key = JSON.stringify(progress);
+                            if (progress && key !== previous) {
+                                await update(progress);
+                                previous = key;
+                            }
+                        }
+                        catch (error) {
+                            console.warn("[sortie-dogs-v010] mission progress unavailable", error instanceof Error ? error.message : "unknown");
+                        }
+                    })().finally(() => { reading = undefined; });
+                    return reading;
+                };
+                // The native executor is a stable snapshot. Poll only local durable state, not models or
+                // session status APIs; this also recovers progress after another plugin instance settles work.
+                const timer = setInterval(() => { void refresh(); }, 1000);
+                timer.unref();
                 try {
-                    return await execute(value, { ...execution, progress: async (update) => {
-                            metadata = { ...metadata, ...update };
-                            await report(metadata);
-                        } });
+                    await refresh();
+                    const result = await execute(value, { ...execution, progress: update });
+                    await refresh();
+                    await pending.catch(() => undefined);
+                    // Native completion replaces metadata, so retain our display fields alongside its own.
+                    return { ...result, metadata: { ...metadata, ...(record(result.metadata) ? result.metadata : {}) } };
                 }
                 finally {
+                    clearInterval(timer);
                     unbind();
+                    await reading;
+                    await pending.catch(() => undefined);
                 }
             };
         });

package/dist/runtime-mission-assets.js

@@ -117,6 +117,11 @@ You are Coordinator. Own most of the practical work and dispatch within the save
 Read/search and confirmation shell commands are available; source edits belong to Worker. Do not edit
 through shell. There is no proposal/approval/contract-repair round trip in this route.
 
+For release/benchmark work, resolve the package from its release receipt and hash, not a matching version
+or filename. Record the runner's own revision separately. Before repairing infrastructure on an old branch,
+check current main for an existing fix; preserve local edits and use a current-main worktree when needed.
+Report setup/route failures as such, with observed inference count, instead of calling runner exits a score.
+
 Investigate only enough to start the first useful Worker. Prefer a targeted read/reproduction over a broad
 inventory or speculative full design. Call ${profile.toolPrefix}plan_units with concise units:
 title, objective, read/write file or directory scopes, validation commands, optionally requirement_ids.

package/package.json

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