sortie-dogs 0.13.12 → 0.13.13

package/README.md

@@ -19,8 +19,8 @@ evidence-backed result, not more agents for their own sake.
 [![Node.js](https://img.shields.io/node/v/sortie-dogs)](https://www.npmjs.com/package/sortie-dogs)
 [![MIT License](https://img.shields.io/npm/l/sortie-dogs)](LICENSE)
 
-**Current release: [v0.13.12](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.13.12)**
-· [Release notes](docs/release-v0.13.12.md)
+**Current release: [v0.13.13](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.13.13)**
+· [Release notes](docs/release-v0.13.13.md)
 
 [Quick start](#quick-start) · [Workflow](#mission-workflow) · [Models](#default-models) ·
 [Measured results](#measured-results) · [Configuration](#configuration) · [Documentation](#documentation)
@@ -57,7 +57,7 @@ Use an existing Codex CLI signed in with **ChatGPT**. On Windows, PowerShell **7
 available; POSIX uses bash. Sortie does not install Codex, start login or use a metered API fallback.
 
 ```sh
-npm install --save-dev sortie-dogs@0.13.12
+npm install --save-dev sortie-dogs@0.13.13
 npx --no-install sortie-dogs codex init .
 ```
 
@@ -86,7 +86,7 @@ bridge. [Codex guide: SDK, permissions, progress, resume and manifest route](doc
 Use **OpenCode V2**. In the target project:
 
 ```sh
-npm install --save-dev sortie-dogs@0.13.12
+npm install --save-dev sortie-dogs@0.13.13
 npx --no-install sortie-dogs init .
 ```
 
@@ -188,7 +188,7 @@ known expense. Official local evaluation and leaderboard acceptance are separate
 **8/23 (34.8%)**, versus v0.12.25's 7/23; all seven prior resolutions retained, no empty patches or
 official evaluation errors. [Fixed conditions, stopped-run accounting and costs](docs/benchmarks/swebench-lite-history.md#v0131-dev23-2026-09-30).
 
-All scores belong to their fixed candidates, **not v0.13.12**. SWE-bench remains an optional
+All scores belong to their fixed candidates, **not v0.13.13**. SWE-bench remains an optional
 measurement, not a release gate. Different budgets, models and conditions are not controlled comparisons.
 
 ## Configuration
@@ -211,7 +211,7 @@ Install the desired package version and rerun **your host's** initializer:
 
 An OpenCode config-local bridge may resolve a separate package; npm-global update alone does not
 update it. [Global/update instructions](docs/configuration.md#global-availability).
-The current Mission asset marker is `0.13.12-validation-paths-v1`; the unchanged Codex skill marker is
+The current Mission asset marker is `0.13.13-mission-context-v1`; the unchanged Codex skill marker is
 `0.13.11-codex-skill-v2`. Installed markers alone do not prove a running host reloaded the new version.
 
 There is no supported uninstall command. Remove the dependency and only known Sortie-owned paths;
@@ -227,7 +227,7 @@ follow the [manual removal guide](docs/uninstall.md), never delete the entire `.
   [SWE-bench history](docs/benchmarks/swebench-lite-history.md) · [Historical local case study](docs/benchmark-reference.md).
 - **Development:** [Testing](docs/testing.md) · [CLI testing](docs/cli-testing.md) ·
   [Windows tests](docs/windows-tests.md) · [Release routine](docs/release-batch.md).
-- **Releases:** [v0.13.12](docs/release-v0.13.12.md) · [v0.13.11](docs/release-v0.13.11.md) · [v0.13.10](docs/release-v0.13.10.md) ·
+- **Releases:** [v0.13.13](docs/release-v0.13.13.md) · [v0.13.12](docs/release-v0.13.12.md) · [v0.13.11](docs/release-v0.13.11.md) · [v0.13.10](docs/release-v0.13.10.md) ·
   [v0.13.9](docs/release-v0.13.9.md) · [All GitHub releases](https://github.com/zufall-upon/Sortie-dogs/releases).
 
 ## Community

package/dist/asset-version.d.ts

@@ -3,6 +3,6 @@
  * 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.13.12-validation-paths-v1";
+export declare const V010_RUNTIME_ASSET_VERSION = "0.13.13-mission-context-v1";
 export declare const CODEX_SKILL_ASSET_VERSION = "0.13.11-codex-skill-v2";
 export type RuntimeAssetVersion = typeof RUNTIME_ASSET_VERSION | typeof V010_RUNTIME_ASSET_VERSION | typeof CODEX_SKILL_ASSET_VERSION;

package/dist/asset-version.js

@@ -3,5 +3,5 @@
  * 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.13.12-validation-paths-v1";
+export const V010_RUNTIME_ASSET_VERSION = "0.13.13-mission-context-v1";
 export const CODEX_SKILL_ASSET_VERSION = "0.13.11-codex-skill-v2";

package/dist/core/mission-context.d.ts

@@ -0,0 +1,73 @@
+export interface PublicMissionContext {
+    id: string;
+    role: "user" | "assistant";
+    text: string;
+    tools: {
+        call_id?: string;
+        tool: string;
+        status?: string;
+        input?: unknown;
+        output?: string;
+        error?: string;
+        exit?: number;
+        time?: unknown;
+    }[];
+}
+export interface MissionContextSource {
+    session_id: string;
+    path: string;
+    sha256: string;
+    entries: number;
+    observed_at: string;
+    history_available: boolean;
+}
+export interface MissionContinuity {
+    sources: MissionContextSource[];
+    notes?: {
+        text: string;
+        session_id: string;
+        recorded_at: string;
+    }[];
+}
+/** Public task data only. Keep exact text/results in a lazy snapshot, not private reasoning. */
+export declare function publicMissionContext(messages: readonly Record<string, unknown>[]): PublicMissionContext[];
+/** Preserve earlier available entries when the host later returns a compacted/partial history. */
+export declare function retainMissionContext(directory: string, sessionID: string, messages: readonly Record<string, unknown>[], previous?: MissionContextSource): Promise<{
+    source: MissionContextSource;
+    entries: PublicMissionContext[];
+}>;
+/** Small inline view, with explicit pointers to every omitted byte in the exact snapshot. */
+export declare function missionContextView(source: MissionContextSource, entries: readonly PublicMissionContext[], suppliedRequestIDs?: readonly string[]): {
+    omitted_text_entries: number;
+    conversation: {
+        truncated?: boolean | undefined;
+        original_characters?: number | undefined;
+        id: string;
+        role: "user" | "assistant";
+        text: string;
+    }[];
+    omitted_tool_entries: number;
+    recent_tools: {
+        input: string | undefined;
+        output: string | undefined;
+        error: string | undefined;
+        truncated: boolean;
+        detail_ref: {
+            path: string;
+            message_id: string;
+            call_id: string | undefined;
+        };
+        call_id?: string;
+        tool: string;
+        status?: string;
+        exit?: number;
+        time?: unknown;
+        message_id: string;
+    }[];
+    session_id: string;
+    path: string;
+    sha256: string;
+    entries: number;
+    observed_at: string;
+    history_available: boolean;
+};

package/dist/core/mission-context.js

@@ -0,0 +1,66 @@
+import { createHash } from "node:crypto";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+/** Public task data only. Keep exact text/results in a lazy snapshot, not private reasoning. */
+export function publicMissionContext(messages) {
+    return messages.flatMap(message => {
+        const info = record(message.info) ? message.info : message;
+        if ((info.role !== "user" && info.role !== "assistant") || typeof info.id !== "string" || !Array.isArray(message.parts))
+            return [];
+        const parts = message.parts.filter(record);
+        const text = parts.filter(part => part.type === "text" && part.synthetic !== true && typeof part.text === "string")
+            .map(part => part.text).join("\n");
+        const tools = parts.flatMap(part => {
+            if (part.type !== "tool" || typeof part.tool !== "string" || !record(part.state))
+                return [];
+            const state = part.state, metadata = record(state.metadata) ? state.metadata : {};
+            return [{ tool: part.tool, ...(typeof part.callID === "string" ? { call_id: part.callID } : {}),
+                    ...(typeof state.status === "string" ? { status: state.status } : {}),
+                    ...(state.input !== undefined ? { input: state.input } : {}),
+                    ...(typeof state.output === "string" ? { output: state.output } : {}),
+                    ...(typeof state.error === "string" ? { error: state.error } : {}),
+                    ...(typeof metadata.exit === "number" ? { exit: metadata.exit } : {}),
+                    ...(part.time !== undefined ? { time: part.time } : {}) }];
+        });
+        return text.trim() || tools.length ? [{ id: info.id, role: info.role, text, tools }] : [];
+    });
+}
+/** Preserve earlier available entries when the host later returns a compacted/partial history. */
+export async function retainMissionContext(directory, sessionID, messages, previous) {
+    const current = publicMissionContext(messages);
+    const retained = previous ? await readFile(previous.path, "utf8")
+        .then(content => JSON.parse(content).entries).catch(() => undefined) : undefined;
+    const merged = new Map((retained ?? []).map(entry => [entry.id, entry]));
+    for (const entry of current)
+        merged.set(entry.id, entry);
+    const entries = [...merged.values()];
+    const content = JSON.stringify({ session_id: sessionID, entries }, null, 2) + "\n";
+    const sha256 = createHash("sha256").update(content).digest("hex");
+    const path = join(directory, `context-${sha256}.json`);
+    if (!retained || previous?.sha256 !== sha256) {
+        await mkdir(directory, { recursive: true });
+        await writeFile(path, content);
+    }
+    return { source: { session_id: sessionID, path, sha256, entries: entries.length,
+            observed_at: new Date().toISOString(), history_available: current.length > 0 }, entries };
+}
+/** Small inline view, with explicit pointers to every omitted byte in the exact snapshot. */
+export function missionContextView(source, entries, suppliedRequestIDs = []) {
+    const textEntries = entries.filter(entry => entry.text.trim() && !suppliedRequestIDs.includes(entry.id));
+    const selected = textEntries.slice(-8);
+    const tools = entries.flatMap(entry => entry.tools.map(tool => ({ message_id: entry.id, ...tool })));
+    const recentTools = tools.filter(tool => !tool.tool.startsWith("sortie_") && ["completed", "error"].includes(tool.status ?? "")).slice(-8);
+    return { ...source, omitted_text_entries: textEntries.length - selected.length,
+        conversation: selected.map(entry => ({ id: entry.id, role: entry.role, text: entry.text.slice(0, 4000),
+            ...(entry.text.length > 4000 ? { truncated: true, original_characters: entry.text.length } : {}) })),
+        omitted_tool_entries: tools.length - recentTools.length,
+        recent_tools: recentTools
+            .map(tool => {
+            const input = tool.input === undefined ? undefined : JSON.stringify(tool.input);
+            return { ...tool, input: input?.slice(0, 1000), output: tool.output?.slice(0, 1000), error: tool.error?.slice(0, 1000),
+                truncated: [input, tool.output, tool.error].some(value => value !== undefined && value.length > 1000),
+                detail_ref: { path: source.path, message_id: tool.message_id, call_id: tool.call_id } };
+        }),
+    };
+}

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

@@ -1,5 +1,6 @@
 import { type OperatorPlan, type OperatorState, type OperatorTask, type OperatorRuntime } from "./operator-runtime.js";
 import { type RuntimeProfile } from "./runtime-profile.js";
+import { type MissionContinuity } from "./mission-context.js";
 export { missionValidationCommand } from "./mission-validation-command.js";
 export declare const MISSION_REFERENCE = "SORTIE_MISSION_REF ";
 export declare const MISSION_REVIEW_REFERENCE = "SORTIE_MISSION_REVIEW_REF ";
@@ -192,6 +193,8 @@ export interface OperatorMission {
     requests: MissionRequest[];
     /** Prior public conversation context, not additional immutable requirements. */
     context?: MissionContext[];
+    /** Shared public context/working notes; observations, never extra requirements or acceptance. */
+    continuity?: MissionContinuity;
     /** Explicit continue deliveries, keyed by the original real turn. */
     steering?: {
         requestID: string;
@@ -321,6 +324,10 @@ export declare class OperatorMissionRuntime {
     constructor(projectRoot: string, profile: RuntimeProfile);
     private file;
     correctionReference(root: string, reviewIdentity: string): string;
+    /** Stage context for a proposed handoff; publish Mission metadata only after plan preparation succeeds. */
+    contextSnapshot(state: OperatorMission, sessionID: string, messages: readonly Record<string, unknown>[], notes?: string): Promise<OperatorMission>;
+    retainContext(root: string, sessionID: string, messages: readonly Record<string, unknown>[], notes?: string): Promise<OperatorMission>;
+    handoffContext(state: OperatorMission): Promise<Record<string, unknown>>;
     private load;
     /** Recover non-replacement continuations only; an explicit replacement must link the current cancelled run. */
     private loadMission;

package/dist/core/operator-mission.js

@@ -6,6 +6,7 @@ import { parseOperatorPlan } from "./operator-runtime.js";
 import { profileAgent } from "./runtime-profile.js";
 import { normalizeCommand } from "../plugin/gate.js";
 import { missionValidationCommand } from "./mission-validation-command.js";
+import { retainMissionContext, missionContextView } from "./mission-context.js";
 export { missionValidationCommand } from "./mission-validation-command.js";
 const digest = (value) => createHash("sha256").update(value).digest("hex");
 const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
@@ -184,6 +185,47 @@ export class OperatorMissionRuntime {
     correctionReference(root, reviewIdentity) {
         return JSON.stringify({ path: this.file(root), field: "corrections[]", review_identity: reviewIdentity });
     }
+    /** Stage context for a proposed handoff; publish Mission metadata only after plan preparation succeeds. */
+    async contextSnapshot(state, sessionID, messages, notes) {
+        const next = structuredClone(state);
+        const previous = next.continuity?.sources.find(source => source.session_id === sessionID);
+        const snapshot = await retainMissionContext(join(this.projectRoot, this.profile.stateDirectory, "missions"), sessionID, messages, previous);
+        next.continuity ??= { sources: [] };
+        next.continuity.sources = [...next.continuity.sources.filter(source => source.session_id !== sessionID), snapshot.source];
+        if (typeof notes === "string" && notes.trim())
+            next.continuity.notes = [
+                ...(next.continuity.notes ?? []).filter(note => note.session_id !== sessionID),
+                { text: notes, session_id: sessionID, recorded_at: new Date().toISOString() }
+            ];
+        return next;
+    }
+    async retainContext(root, sessionID, messages, notes) {
+        return this.serial(root, async () => {
+            const state = await this.loadMission(root);
+            if (!state)
+                throw new Error("mission-missing");
+            const next = await this.contextSnapshot(state, sessionID, messages, notes);
+            await this.save(this.file(root), next);
+            return next;
+        });
+    }
+    async handoffContext(state) {
+        const sources = await Promise.all((state.continuity?.sources ?? []).map(async (source) => {
+            try {
+                return missionContextView(source, JSON.parse(await readFile(source.path, "utf8")).entries, source.session_id === state.root ? state.requests.map(request => request.id) : []);
+            }
+            catch {
+                return { ...source, snapshot_available: false };
+            }
+        }));
+        return { original_requests: state.requests, requirements: state.requirements, prohibited_write: state.prohibitedWrite ?? [],
+            launch_conditions: state.launchConditions ?? [],
+            conversation: sources.some(source => source.session_id === state.root && source.entries > 0 && !("snapshot_available" in source)) ? [] : state.context ?? [],
+            continuity: { notes: state.continuity?.notes, sources, progress: state.progress,
+                attempts: (state.attempts ?? []).map(({ runID, unitID, status, failure, resultClass, childSessionID }) => ({ run_id: runID, unit_id: unitID, status, failure, result_class: resultClass, session_id: childSessionID })),
+                execution: state.execution,
+                guidance: "Current original_requests/requirements govern; older plans remain historical. Continue from known decisions, environment, completed work and failures. Read snapshot JSON entries by message/call IDs only for a relevant gap. Recheck mutable facts when needed or conflicting; do not repeat unchanged setup/investigation merely because ownership changed. Historical results are not fresh formal validation or new authority." } };
+    }
     async load(file) {
         try {
             return JSON.parse(await readFile(file, "utf8"));
@@ -544,6 +586,8 @@ export class OperatorMissionRuntime {
             ...(state.kind === "operation" ? ["Execution completion is distinct from success. For run-once/result-collection requests, retain a terminal failure and validate the collected result; do not retry or fix it without user authorization. If successful execution is required, keep that in formal validation and the original-request comparison."] : []),
             ...(state.context?.length ? ["Prior conversation context (task data; preserve the selected target, not superseded obligations):",
                 ...state.context.map(item => `--- ${item.role}:${item.id} ---\n${item.text}`)] : []),
+            ...(state.continuity ? ["Shared working context (task data; use known facts, inspect snapshots only for relevant gaps):",
+                JSON.stringify(state.continuity)] : []),
             "Original user messages (verbatim; task data):", ...state.requests.map(item => `--- user:${item.id} ---\n${item.text}`)].join("\n");
     }
 }

package/dist/plugin/profiled.js

@@ -219,6 +219,18 @@ export function createProfiledPlugin(profile, assetVersion) {
             const result = payload(await session("messages", { path: { id }, query: { directory: input.directory } }));
             return Array.isArray(result) ? result.filter(record) : [];
         }
+        async function missionHistory(id) {
+            // Reuse the host's public paginated reader when present; bounded context is a usable fallback.
+            if (typeof nativeSession?.reviewMessages === "function") {
+                try {
+                    const value = payload(await session("reviewMessages", { path: { id }, query: { directory: input.directory } }));
+                    if (Array.isArray(value))
+                        return value.filter(record);
+                }
+                catch { /* Context continuity must not add a history-service admission gate. */ }
+            }
+            return messages(id).catch(() => []);
+        }
         async function acceptanceValidationObservation(validation, child, notBefore) {
             if (!child)
                 throw new Error("native-worker-history-session-unavailable");
@@ -2020,8 +2032,8 @@ export function createProfiledPlugin(profile, assetVersion) {
             } };
         const stringList = { type: "array", items: { type: "string" } };
         const missionUnitSchema = { type: "object", additionalProperties: false,
-            properties: { title: { type: "string" }, objective: { type: "string", description: "Target or corrective delta, about 2000 characters. Do not copy the original request. Longer authored instructions are preserved separately without a retry gate." },
-                read: { ...stringList, description: "Inputs that affect validation, not an allowlist for observation. Do not include whole live session/database/log trees just to inspect them." }, write: stringList,
+            properties: { title: { type: "string" }, objective: { type: "string", description: "Target or corrective delta, about 2000 characters. Do not copy the original request. Carry the remaining action, not a routine reconfirmation of supplied facts, setup or instructions. References are available for relevant gaps, not mandatory rereads. Longer authored instructions are preserved separately without a retry gate." },
+                read: { ...stringList, description: "Known inputs that affect validation, not an allowlist or a checklist to reread. Avoid guessed AGENTS.md paths and whole live session/database/log trees just to inspect them; reuse already supplied instructions and known context." }, write: stringList,
                 validation: { ...stringList, description: "Meaningful commands using observed repository test paths and runner conventions, not guessed filenames. Reuse already discovered recipes; when unknown, locate the relevant test or repository script with ordinary read/search before declaring it. This is planning guidance, not new approval or proof of execution; native checks still establish acceptance." },
                 validation_cwd: { type: "object", additionalProperties: { type: "string" }, description: "Exact cwd per declared command; omitted commands use project_root. Registration-only correction of your active direct unit keeps the same admission and budget and requires new native checks, not historical proof." },
                 requirement_ids: { ...stringList, description: "Related requirement IDs. A single unit inherits all requirements when omitted; specify coverage when splitting work across units." } },
@@ -2043,10 +2055,13 @@ export function createProfiledPlugin(profile, assetVersion) {
         const missionExecutionSchema = { type: "object", properties: { commands: stringList, directory: { type: "string" } },
             required: ["commands", "directory"], additionalProperties: false,
             description: "For an operation: the actual run/grade commands, not a preflight or NO_START check. Host observes their native shell completion separately from successful exits; no handwritten proof file is needed. For run-once/result collection, validate the collected result without rerunning the operation.", "x-sortie-optional": true };
+        const handoffContextSchema = { type: "string", "x-sortie-optional": true,
+            description: "Optional current working notes: intent/rationale, known environment and paths, completed setup/checks with results, failed approaches and remaining work. Reuse known facts with source references; no required form or new approval. Public history and Mission observations are also supplied automatically. Omit when already sufficient; do not recopy the original request." };
         tools[startMission] = { description: `Operator: save current requirements; the host retains the original request verbatim. With a meaningful formal check known from user, project or task context and one useful unit, include unit NOW (and execution for an operation) and dispatch its Worker directly; plan_units remains available after start. A literal command in the original request is not required. Worker owns investigation/edit/check/requested commit before independent Review; no routine preparation or commit-only handoff. ${MISSION_GIT_SCOPE} Unknown checks or real unit decomposition use Coordinator. intent=replace follows an actual user requirement change, retaining unchanged constraints and cumulative spend; for mission-source-reconciliation-required use the saved requirements when they reflect that change. intent=new is separate work in another location.`,
             args: { requirements: { ...stringList, minItems: 1, maxItems: 64 },
                 unit: { ...missionUnitSchema, description: "When the meaningful check and single-unit scope are already known, include this unit now. Returns its configured Worker directly, combining start_mission and plan_units without another model round trip.", "x-sortie-optional": true },
                 execution: missionExecutionSchema,
+                handoff_context: handoffContextSchema,
                 confirmed_conditions: conditionsSchema,
                 prohibited_write: { ...stringList, description: "Only explicit path prohibitions from the user or applicable instructions. Never infer a parent glob from project/repository names, semantic 'do not modify the product', or the complement of estimated unit.write. Preserve the authorized clone and exact prohibited paths; semantic constraints stay in requirements.", "x-sortie-optional": true },
                 kind: { type: "string", enum: ["implementation", "operation"], description: "Use operation for running an existing benchmark, command or procedure. The host records its actual execution separately from setup and checks.", "x-sortie-optional": true },
@@ -2092,11 +2107,13 @@ export function createProfiledPlugin(profile, assetVersion) {
                             return JSON.stringify({ ...relocated, budget: await control.currentBudget(context.sessionID) });
                     }
                     const cancelled = await operators.read(context.sessionID);
+                    const history = await missionHistory(context.sessionID);
                     let mission = await missions.start(context.sessionID, requirements, args.intent === "replace" || args.intent === "new", {
                         kind: args.kind === "operation" ? "operation" : "implementation", executionHost: input.executionHost,
-                        context: missionConversationContext(await messages(context.sessionID)),
+                        context: missionConversationContext(history),
                         ...(args.intent === "replace" && cancelled?.phase === "cancelled" ? { cancelledRunID: cancelled.runID } : {}),
                     });
+                    mission = await missions.retainContext(context.sessionID, context.sessionID, history, args.handoff_context);
                     const prohibited = args.prohibited_write;
                     if (prohibited !== undefined) {
                         if (!Array.isArray(prohibited) || !prohibited.every(path => typeof path === "string"))
@@ -2298,7 +2315,7 @@ export function createProfiledPlugin(profile, assetVersion) {
             const commands = [...new Set(execution.commands.map(missionValidationCommand).map(normalizeCommand))];
             return { commands, directory: resolve(input.directory, execution.directory), observations: operation?.observations ?? [] };
         }
-        async function declareMissionUnits(root, actor, mission, raw, reason, execution, planningCallID) {
+        async function declareMissionUnits(root, actor, mission, raw, reason, execution, planningCallID, handoffNotes) {
             await control.currentBudget(root);
             mission = await missions.required(root);
             let previous = await operators.read(root);
@@ -2452,13 +2469,16 @@ export function createProfiledPlugin(profile, assetVersion) {
                     },
                 }) : [];
             const dispatcher = actor === root ? undefined : { sessionID: actor, callID: mission.callID };
-            const context = { original_requests: mission.requests, requirements: mission.requirements, prohibited_write: mission.prohibitedWrite ?? [],
-                launch_conditions: mission.launchConditions ?? [] };
+            const histories = await Promise.all([...new Set([root, actor])].map(async (id) => ({ id, messages: await missionHistory(id) })));
+            for (const history of histories)
+                mission = await missions.contextSnapshot(mission, history.id, history.messages, history.id === actor ? handoffNotes : undefined);
+            const context = await missions.handoffContext(mission);
             const state = replanning && previous ? await operators.replanMission(root, previous.runID, plan, dispatcher, context)
                 : await operators.prepareMission(root, plan, dispatcher, mission.supersededRunID, terminalChildren, mission.requirementsReplaced, context);
             await control.registerGoalDeclaration(root, state.units[0].task.prompt, true);
             control.enableUnits(root, state.units.filter(unit => unit.status === "pending").length);
             await missions.update(root, item => {
+                item.continuity = mission.continuity;
                 item.reviewScope = missionReviewScope(item.reviewScope, ...(previous && item.runID === previous.runID ? [previous] : []), state);
                 if (item.runID !== state.runID)
                     item.plans++;
@@ -2484,6 +2504,7 @@ export function createProfiledPlugin(profile, assetVersion) {
         tools[planUnits] = { description: `Coordinator or single-unit Fast-lane Operator: declare useful work with estimated read/write scope and meaningful formal checks. executor=self starts implementation/correction and formal validation HERE without a Worker or handoff read; otherwise dispatch the returned configured Worker promptly. Keep investigation/edit/check/requested commit with the same author before independent Review, not a commit-only handoff. ${MISSION_GIT_SCOPE} Native scope reconciliation/expand_unit retain host permissions and explicit path prohibitions. Objective is the target or corrective delta: aim for 2000 characters; the full original request/public reproduction is supplied separately, not copied here. Oversized unit instructions are retained verbatim in handoff Mission context, not rejected for another planning round. Keep every requirement covered. Final validation proves the unit; empty or dummy checks do not qualify. Diagnostics need no registration. write: [] is read-only; dir/** and native absolute paths support actual outputs. reason replans settled work, or ends your own quiescent direct unit without acceptance to correct its declaration, in the same requirements/budget; same-scope failed validation uses retry_mission_unit. Reviewer FINDINGS stay with the same Reviewer for correction, formal validation and self-recheck.`,
             args: { units: { type: "array", minItems: 1, maxItems: 32, items: missionUnitSchema },
                 execution: missionExecutionSchema,
+                handoff_context: handoffContextSchema,
                 reason: { type: "string", "x-sortie-optional": true },
                 executor: { type: "string", enum: ["worker", "self"], description: "Use self to implement/correct and formally validate here without a Worker handoff. Default worker retains configured Worker routing.", "x-sortie-optional": true } }, execute: async (args, context) => {
                 const { root, mission } = await missionAuthority(context.sessionID);
@@ -2491,7 +2512,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                     throw new Error("mission-executor-invalid");
                 try {
                     return await serializeDispatchTransition(root, async () => {
-                        const planned = await declareMissionUnits(root, context.sessionID, mission, args.units, args.reason, args.execution, context.callID);
+                        const planned = await declareMissionUnits(root, context.sessionID, mission, args.units, args.reason, args.execution, context.callID, args.handoff_context);
                         return args.executor === "self" && record(JSON.parse(planned).task) ? startDirect(root, context.sessionID) : planned;
                     });
                 }
@@ -2695,7 +2716,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                     const baseline = await missionReviewBaseline(input.directory);
                     const dispatcher = mission.coordinator ? { sessionID: mission.coordinator, callID: mission.callID } : undefined;
                     const prepared = await operators.prepareReviewerCorrection(root, run.runID, correctedPlan, authorID, reviewIdentity, retainedPlan.units[0].write, dispatcher, {
-                        original_requests: mission.requests, requirements: mission.requirements, prohibited_write: mission.prohibitedWrite ?? [],
+                        ...await missions.handoffContext(mission),
                         correction_context: { findings: recovery ? existing.findings : review.result,
                             retained_findings_ref: JSON.parse(missions.correctionReference(root, reviewIdentity)),
                             mission_id: mission.id, prior_run_id: run.runID, review_identity: reviewIdentity,

package/dist/runtime-mission-assets.js

@@ -429,6 +429,12 @@ run/grade commands and working directory. Setup, launch and result collection no
 do not forbid execution while assigning that Worker the requirement to execute.
 Write objective as a target or corrective delta: aim for 2000 characters.
 The Worker reads the original requests verbatim from the handoff once; do not copy them into objective.
+Public conversation, recent tool results and Mission progress are supplied automatically in continuity.
+When useful, include handoff_context in start_mission/plan_units: current intent and rationale, known environment,
+completed setup/checks, failed approaches and remaining work with existing references. It is optional working
+context, not a form or approval. Preserve useful knowledge instead of assigning unchanged discovery again.
+Assign the remaining action. Reference paths support relevant gaps, not a mandatory reread checklist; avoid
+routine environment/instruction reconfirmation and guessed AGENTS.md paths when that context is already supplied.
 Keep investigation, edits, formal checks and any requested commit in the same Worker before independent Review;
 do not invent a review-before-commit gate or a commit-only handoff. Preserve explicit user ordering.
 ${MISSION_GIT_SCOPE}
@@ -549,8 +555,8 @@ mode: subagent
 
 Implement, test and requested commit in this Task.
 Reuse supplied AGENTS.md; for gaps prefer exact ancestor files/affected subtrees over parent globs.
-Read handoff_path in full first: task.objective, verbatim original_requests/unit_instruction, Mission constraints,
-coverage indices. Preserve user scope and ordering; prove assigned criteria, not Mission completion.
+Read handoff_path in full first: task.objective, verbatim original_requests/unit_instruction, constraints/continuity,
+coverage. Preserve user scope and ordering; prove assigned criteria, not Mission completion.
 Denied: reason/remedy. No routine manifest/goal/status/bind.
 Recovery: ${profile.toolPrefix}bind_write_gate with exact project_root and manifest_path=operation_manifest.
 Treat cwd/project_root and paths as opaque; never shorten or normalize segments.

package/package.json

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