sortie-dogs 0.13.22 → 0.14.1

package/README.md

@@ -19,13 +19,13 @@ 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.21](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.13.21)**
-· [Release notes](docs/release-v0.13.21.md)
+**Current release: [v0.14.1](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.14.1)**
+· [Release notes](docs/release-v0.14.1.md) · [Execution vision](docs/v0.14.0-execution-vision.md)
 
 [Quick start](#quick-start) · [Workflow](#mission-workflow) · [Models](#default-models) ·
 [Measured results](#measured-results) · [Configuration](#configuration) · [Documentation](#documentation)
 
-> **Beta:** the v0.13.x package is still stabilizing before 1.0. Both host integrations are
+> **Beta:** the package is still stabilizing before 1.0. Both host integrations are
 > implemented; Codex Missions have completed implementation, validation, correction and acceptance.
 > [Host-specific execution boundaries](docs/codex.md#native-permissions-and-approval) remain explicit.
 
@@ -35,9 +35,9 @@ evidence-backed result, not more agents for their own sake.
 
 - **Autonomy:** retain the original request across delegation, correction, compaction and restart.
   Finish in-request work through the existing host authority instead of routine approval round trips.
-- **Efficiency:** small work stays small. Use a direct Worker for a known single unit; add
-  Coordinator, Scout or Advisor only when discovery or task shape calls for them. Reuse valid
-  unchanged evidence instead of repeating successful work.
+- **Efficiency:** Operator recommends an initial author from the instruction and known context.
+  Coordinator can implement substantial work directly or delegate remaining work as execution makes
+  that useful. Continue the same unit with its edits, valid evidence and cumulative budget.
 - **Visibility:** show real commands, exits, timing, model routes, review disposition and final
   acceptance. Unknown execution or cost stays unknown, not an invented success or zero.
 - **Quality:** meaningful formal checks and risk-based review establish completion, not model prose.
@@ -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.21
+npm install --save-dev sortie-dogs@0.14.1
 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.21
+npm install --save-dev sortie-dogs@0.14.1
 npx --no-install sortie-dogs init .
 ```
 
@@ -108,14 +108,16 @@ v0.10 is installed. [OpenCode setup and configuration](docs/configuration.md) ·
 
 ```text
 Known unit: User → Operator → Worker → Validation → Review / Correction → Acceptance
-Discovery:  User → Operator → Coordinator → Worker → Validation → Review / Correction → Acceptance
+Direct:     User → Operator → Coordinator → Validation → Review / Correction → Acceptance
+Handoff:    Coordinator → Worker (same unit, retained edits/context/checks/budget)
 ```
 
-1. **Operator** saves original requirements and owns user decisions and final acceptance.
+1. **Operator** saves original requirements, recommends an initial executor from already-known
+   context, and owns user decisions and final acceptance. No routing-only investigation is required.
 2. **Worker** investigates, implements, runs meaningful checks and performs requested Git delivery
    in the same useful unit. A known unit/check can go directly to Worker without a planning handoff.
-3. **Coordinator**, when needed, investigates or decomposes work, reconciles in-request scope and
-   dispatches units. It can also implement and validate directly.
+3. **Coordinator** starts useful work, implements and validates directly when efficient, and
+   delegates remaining work when useful. The Operator recommendation is advisory, not an execution lock.
 4. **Review** is initially independent for high-risk changes; low-risk skips are explicit.
    Findings can be corrected and validated by the same Reviewer, followed by recorded author
    self-recheck. That is not a second independent PASS.
@@ -176,6 +178,30 @@ general speed or success-rate guarantee.
 
 ### SWE-bench evaluation
 
+#### v0.14.0 dev23 (2026-10-15 UTC)
+
+**Official resolution: 10/23 (43.48%); Mission completion: 22/23.** One pass through the normal
+OpenCode CLI + Sortie Mission path, using the fixed released v0.14.0 package.
+
+- All 23 frozen patches were officially scored: **10 resolved, 13 unresolved**, zero empty patches,
+  evaluation errors or infrastructure failures. The cost-stopped `sqlfluff__sqlfluff-2419` patch
+  resolved officially, but its Mission remains incomplete; official correctness does not imply acceptance.
+- Pinned public Lite dev rows; one inference attempt per task, no retries. Official grading:
+  `split=dev`, `max_workers=1`, `retry_count=0`. Inference concurrency was **1** due to low host memory.
+- Actual Operator/Coordinator/Reviewer model: `openai/gpt-6.1-sol#xhigh`;
+  Worker: `openai/gpt-6-luna-fast#max`. Ten cases used Workers; 13 used Coordinator direct execution.
+- Inference wall time **2h53m28s**; separate official grading **7m19s**.
+- Known estimated inference cost **$16.76**, with one pending usage record. Separate holds:
+  **$2** for unresolved usage and **$5** for implementation/supervision; these are not known expenses.
+  Costs are API-equivalent estimates, not invoices; the $2/task monitor is not an exact billing cap.
+- Release/runner commit `e69a3b2317a76eeea1229034f52902812ff1d580`;
+  package SHA-256 `120922c31dd6d85040210d68456192b4e6aa45dc87a11451476f3ed576a68e30`.
+
+Local evidence (generated artifacts are not committed):
+`_testenv/autodev/sortie-dogs-dev23/benchmark-v0140-20261015/one-pass-summary.json`.
+
+#### Historical v0.12.24 test300
+
 **SWE-bench Lite test300: 170/300 (56.67%)**, fixed **v0.12.24**, one pass@1 campaign.
 Nine empty patches, zero official evaluation errors, frozen predictions and trajectories for all
 300 instances. Workers ran Luna Fast/max; management/review ran GPT-6 Sol/xhigh.
@@ -193,8 +219,8 @@ 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.21**. SWE-bench remains an optional
-measurement, not a release gate. Different budgets, models and conditions are not controlled comparisons.
+Each score belongs to its fixed candidate. SWE-bench remains an optional measurement, not a release
+gate. Different splits, budgets, models and conditions are not controlled comparisons or proof of a fix's effect.
 
 ## Configuration
 
@@ -216,7 +242,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.21-operation-recovery-v1`; the unchanged Codex skill marker is
+The current Mission asset marker is `0.14.1-review-continuation-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;
@@ -232,7 +258,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.21](docs/release-v0.13.21.md) · [v0.13.20](docs/release-v0.13.20.md) · [v0.13.19](docs/release-v0.13.19.md) · [v0.13.18](docs/release-v0.13.18.md) · [v0.13.17](docs/release-v0.13.17.md) · [v0.13.16](docs/release-v0.13.16.md) · [v0.13.15](docs/release-v0.13.15.md) · [v0.13.14](docs/release-v0.13.14.md) · [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) ·
+- **Releases:** [v0.14.1](docs/release-v0.14.1.md) · [v0.14.0](docs/release-v0.14.0.md) · [v0.13.22](docs/release-v0.13.22.md) · [v0.13.21](docs/release-v0.13.21.md) · [v0.13.20](docs/release-v0.13.20.md) · [v0.13.19](docs/release-v0.13.19.md) · [v0.13.18](docs/release-v0.13.18.md) · [v0.13.17](docs/release-v0.13.17.md) · [v0.13.16](docs/release-v0.13.16.md) · [v0.13.15](docs/release-v0.13.15.md) · [v0.13.14](docs/release-v0.13.14.md) · [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.22-owned-task-lifecycle-v1";
+export declare const V010_RUNTIME_ASSET_VERSION = "0.14.1-review-continuation-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.22-owned-task-lifecycle-v1";
+export const V010_RUNTIME_ASSET_VERSION = "0.14.1-review-continuation-v1";
 export const CODEX_SKILL_ASSET_VERSION = "0.13.11-codex-skill-v2";

package/dist/core/goal-bound.d.ts

@@ -204,6 +204,12 @@ export type GoalFlightEvent = (GoalEventBase & {
     readonly cost_usd: number | null;
     readonly native_session_id?: string;
     readonly native_started_at?: string;
+    /** Multiple actual authors of one handed-off unit; missing usage stays unknown. */
+    readonly native_usage_segments?: readonly {
+        readonly sessionID: string;
+        readonly startedAt: string;
+        readonly endedAt?: string;
+    }[];
     /** Host-native validation identity retained in this same goal ledger; never model-authored evidence. */
     readonly native_validation_observations?: readonly {
         readonly thread_id: string;

package/dist/core/initialize.js

@@ -136,10 +136,12 @@ function classifyVersionTransition(installedValue, currentValue, v010Restore = f
     const adjacentPreOneLine = installed.major === 0 && current.major === 0 &&
         current.minor === installed.minor + 1;
     // v0.11 used a different runtime. The v010 asset migration restores the 0.10
-    // preview into the 0.12/0.13 Mission line without selecting a v0.11 execution path.
+    // preview into the 0.12–0.14 Mission line without selecting a v0.11 execution path.
     const restoredPreview = v010Restore && installed.major === 0 && installed.minor === 10 &&
-        current.major === 0 && (current.minor === 12 || current.minor === 13);
-    return sameLine || adjacentPreOneLine || restoredPreview ? "compatible-update" : "incompatible";
+        current.major === 0 && [12, 13, 14].includes(current.minor);
+    const retainedMission = v010Restore && installed.major === 0 && installed.minor === 12 &&
+        current.major === 0 && current.minor === 14;
+    return sameLine || adjacentPreOneLine || restoredPreview || retainedMission ? "compatible-update" : "incompatible";
 }
 async function metadata(path) {
     try {

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

@@ -62,7 +62,7 @@ export interface MissionAttempt {
     /** Fingerprint of the settled scoped candidate against which a later Rescue is proposed. */
     candidateID?: string;
     kind: "implementation" | "normal_remediation" | "astra_rescue" | "reviewer_correction" | "direct_execution";
-    status: "pending" | "dispatched" | "succeeded" | "failed" | "cancelled" | "unconfirmed";
+    status: "pending" | "dispatched" | "succeeded" | "failed" | "cancelled" | "unconfirmed" | "handed-off";
     callID?: string;
     childSessionID?: string;
     dispatchFingerprint?: string;
@@ -217,6 +217,10 @@ export interface OperatorMission {
     context?: MissionContext[];
     /** Shared public context/working notes; observations, never extra requirements or acceptance. */
     continuity?: MissionContinuity;
+    /** Operator recommendation from already-known context; not a requirement or execution lock. */
+    preferredExecutor?: "coordinator" | "worker";
+    /** Known unit facts passed to the Coordinator without pre-starting a Worker. */
+    suggestedUnit?: Record<string, unknown>;
     /** Explicit continue deliveries, keyed by the original real turn. */
     steering?: {
         requestID: string;
@@ -315,6 +319,11 @@ export interface OperatorMission {
             admittedAt: number;
             reviewIdentity: string;
         };
+        /** Exact terminal of an unused inline grant; no implementation calls followed admission. */
+        noWriteReceipt?: {
+            promptID: string;
+            messageID: string;
+        };
         status: "prepared" | "running" | "ready" | "failed" | "cancelled";
         selfRecheck?: MissionSelfRecheck;
     }[];

package/dist/core/operator-mission.js

@@ -328,6 +328,7 @@ export class OperatorMissionRuntime {
             }
         }));
         return { original_requests: state.requests, requirements: state.requirements, prohibited_write: state.prohibitedWrite ?? [],
+            ...(state.preferredExecutor ? { preferred_executor: state.preferredExecutor } : {}),
             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,
@@ -709,6 +710,9 @@ export class OperatorMissionRuntime {
         return [`mission_id: ${state.id}`, `project_root: ${this.projectRoot}`, "Use the user's language below for all replies and Task titles.",
             "Own investigation, implementation, formal validation, corrections and Worker/Scout/Advisor/independent Reviewer dispatch.",
             "Use plan_units with executor=self for direct work in this session, or delegate promptly when useful. finish_direct_unit records native checks without a Worker handoff. No proposal/approval phase; root alone accepts completion.",
+            "Start useful work from the supplied context. Reconsider the recommendation through normal execution, not a separate routing investigation. You may implement substantial work here or delegate remaining work without asking Operator again; explicit user choices still govern.",
+            ...(state.preferredExecutor ? [`Operator recommendation (advisory): ${state.preferredExecutor}. This is not an immutable requirement or a model override.`] : []),
+            ...(state.suggestedUnit ? [`Known unit facts (reuse or adapt during actual work): ${JSON.stringify(state.suggestedUnit)}`] : []),
             "Escalate only a completion candidate, a user-only decision, or an extension of original requirements/budget. Unit progress is published without stopping you.",
             "Requirements:", ...state.requirements.map(item => `${item.id}: ${item.text}`),
             `Confirmed launch conditions (fixed limits, not consumption or remaining budget): ${JSON.stringify(state.launchConditions ?? [])}`,
@@ -887,7 +891,8 @@ export async function missionAcceptanceSummary(mission, run, operators, observe)
 }
 export function missionReviewIndependent(mission, child) {
     return child !== undefined && !mission.sourceAuthors?.includes(child) &&
-        !(mission.corrections ?? []).some(correction => correction.author === child);
+        !(mission.corrections ?? []).some(correction => correction.author === child &&
+            !(correction.status === "failed" && correction.noWriteReceipt));
 }
 export function missionPacket(mission, run, includeWorkQuantity = true) {
     const predecessor = run && mission.runID !== run.runID && (mission.supersededRunID === run.runID || run.phase === "cancelled") ? run : undefined;
@@ -932,6 +937,7 @@ export function missionPacket(mission, run, includeWorkQuantity = true) {
                 normal_remediation_used: unit.normalRemediationUsed ?? false,
                 ...(unit.failure ? { failure: { outcome: unit.failure.outcome, exit_code: unit.failure.exitCode } } : {}),
                 ...(unit.dispatchDenial ? { dispatch_denial: unit.dispatchDenial } : {}) })) } : {}),
+        ...(mission.preferredExecutor ? { preferred_executor: mission.preferredExecutor } : {}),
         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"
                 ? "Operator: use acceptance_summary to compare the submitted candidate with the verbatim original requests and actual evidence, inspect concrete gaps only, then complete_mission if satisfied. Do not routinely search archives or reread all source. Historical PASS is not current PASS. Report remaining evidence gaps; they are not a review PASS."

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

@@ -141,6 +141,12 @@ interface UnitState {
         validationCwd?: Readonly<Record<string, string>>;
         validationRegisteredAt?: Readonly<Record<string, string>>;
     };
+    /** Actual direct author segments retained when the same unit is handed to a Worker. */
+    directHandoffs?: (NonNullable<UnitState["directExecution"]> & {
+        callID: string;
+        handedOffAt: string;
+        settledCallID?: string;
+    })[];
     resultClass: string | null;
     failure?: SerialDispatchSettlement["failure"];
     normalRemediationUsed?: boolean;
@@ -372,6 +378,8 @@ export declare class OperatorRuntime {
     private nextOnce;
     admitWorker(root: string, actor: string, callID: string, args: unknown): Promise<OperatorTask>;
     admitDirect(root: string, actor: string, callID: string): Promise<OperatorState>;
+    /** Yield an unfinished ordinary direct unit; keep its contract, reservation and source history. */
+    handoffDirect(root: string, actor: string, context: Record<string, unknown>): Promise<OperatorState>;
     /** Continue an admitted independent Review in-place; no second native Task or prompt. */
     admitReviewerDirect(root: string, author: string, callID: string, promptID: string): Promise<OperatorState>;
     private admitWorkerOnce;

package/dist/core/operator-runtime.js

@@ -1454,6 +1454,37 @@ export class OperatorRuntime {
             return state;
         });
     }
+    /** Yield an unfinished ordinary direct unit; keep its contract, reservation and source history. */
+    handoffDirect(root, actor, context) {
+        return this.serial(root, async () => {
+            const state = await this.required(root);
+            const unit = state.units.find(item => item.status !== "succeeded");
+            if (actor !== (state.operatorSessionID ?? root) || state.phase !== "running" || !unit ||
+                unit.status !== "running" || unit.directExecution?.actor !== actor || !unit.callID ||
+                unit.directExecution.finishedAt || unit.reviewerCorrection || unit.repairValidation || unit.terminalRescue) {
+                throw new Error("mission-direct-handoff-unavailable");
+            }
+            await this.verifyControls(unit);
+            const segment = { ...structuredClone(unit.directExecution), callID: unit.callID, handedOffAt: new Date().toISOString() };
+            // Keep the original controls immutable. Publish continuation context and the new
+            // Task reference together in the atomic run save, so a crash has no half-updated pins.
+            const continuation = { actor, unit_id: unit.unit.id, at: segment.handedOffAt,
+                instruction: "Continue existing changes and remaining action. The authoritative handoff retains the exact original requirements. Reuse current source-bound checks; inspect missing facts only. Handoff itself is not validation.",
+                continuity: context.continuity,
+                checks: segment.checks.map(({ callID, command, directory, exitCode, startedAt, endedAt }) => ({ callID, command, directory, exitCode, startedAt, endedAt })),
+                validation_cwd: segment.validationCwd ?? unit.unit.validation_cwd, details_ref: this.statePath(root) };
+            unit.task = { ...unit.task, prompt: `${unit.task.prompt.replace(/\ndirect_handoff: .+$/mu, "")}\ndirect_handoff: ${JSON.stringify(continuation)}` };
+            (unit.directHandoffs ??= []).push(segment);
+            delete unit.directExecution;
+            unit.status = "pending";
+            unit.childSessionID = null;
+            state.units[state.units.indexOf(unit)] = { ...unit,
+                unit: segment.validationCwd ? { ...unit.unit, validation_cwd: segment.validationCwd } : unit.unit };
+            // Keep the original call as the reservation anchor until Worker admission replaces it.
+            await this.save(state);
+            return state;
+        });
+    }
     /** Continue an admitted independent Review in-place; no second native Task or prompt. */
     admitReviewerDirect(root, author, callID, promptID) {
         return this.serial(root, async () => {
@@ -1848,6 +1879,8 @@ export class OperatorRuntime {
         else
             delete unit.failure;
         unit.status = result.disposition;
+        for (const segment of unit.directHandoffs ?? [])
+            segment.settledCallID ??= result.callID;
         if (unit.directExecution)
             unit.directExecution.finishedAt = new Date().toISOString();
         if (unit.terminalRescue) {

package/dist/plugin/index.js

@@ -1553,17 +1553,26 @@ export const SortieDogsPlugin = async (input, options) => {
             });
         }
     }
-    async function nativeUnitCost(child, startedAt) {
+    async function nativeUnitCost(child, startedAt, endedAt) {
         if (!child || !input.client?.session?.messages)
             return null;
         try {
             const response = await input.client.session.messages({ path: { id: child }, query: { directory: input.directory } });
-            return isRecord(response) && Array.isArray(response.data) ? settledUnitUsage(response.data, startedAt) : null;
+            return isRecord(response) && Array.isArray(response.data) ? settledUnitUsage(response.data, startedAt, endedAt) : null;
         }
         catch {
             return null;
         }
     }
+    async function unitUsageSegments(root, taskID, callID, child) {
+        const origin = await input.runtimeBridge?.missionDispatchOrigin?.(root, taskID, callID);
+        return origin ? [...origin.segments, ...(child ? [{ sessionID: child,
+                    startedAt: origin.segments.at(-1).endedAt }] : [])] : undefined;
+    }
+    async function priceUsageSegments(segments) {
+        const costs = await Promise.all(segments.map(segment => nativeUnitCost(segment.sessionID, segment.startedAt, segment.endedAt)));
+        return costs.length && costs.every((cost) => cost !== null) ? costs.reduce((sum, cost) => sum + cost, 0) : null;
+    }
     async function reconcileUnitUsage(root) {
         const ledger = await goalLedger(root), snapshot = await ledger.readGoal();
         const reconciled = new Set(snapshot.records.flatMap(({ event }) => event.kind === "unit.usage-reconciled" ? [event.reservation_id] : []));
@@ -1571,7 +1580,8 @@ export const SortieDogsPlugin = async (input, options) => {
             if (event.kind !== "unit.settled" || event.goal_id !== snapshot.state.goal_id || event.cost_usd !== null ||
                 !event.native_session_id || reconciled.has(event.reservation_id))
                 continue;
-            const cost = await nativeUnitCost(event.native_session_id, event.native_started_at);
+            const cost = event.native_usage_segments ? await priceUsageSegments(event.native_usage_segments)
+                : await nativeUnitCost(event.native_session_id, event.native_started_at);
             if (cost === null)
                 continue;
             await ledger.appendGoal({ kind: "unit.usage-reconciled", at: new Date().toISOString(), goal_id: event.goal_id,
@@ -1594,8 +1604,9 @@ export const SortieDogsPlugin = async (input, options) => {
             const pending = state.outstanding_reservations;
             for (const reservation of pending) {
                 const dispatch = await input.runtimeBridge?.recoverMissionDispatch?.(root, reservation.unit_id);
+                const origin = dispatch && await input.runtimeBridge?.missionDispatchOrigin?.(root, reservation.unit_id, dispatch.callID);
                 if (!dispatch || !state.goal_id || goalFingerprint({ goal_id: state.goal_id, unit_id: reservation.unit_id,
-                    call_id: dispatch.callID }) !== reservation.reservation_id)
+                    call_id: origin?.callID ?? dispatch.callID }) !== reservation.reservation_id)
                     continue;
                 if (!dispatch.cancelled && dispatch.nativeOutcome === "completed" && goalReservations.get(dispatch.callID)?.reservationID === reservation.reservation_id) {
                     // Reuse host-observed command exits/bindings when still present. A terminal outcome alone
@@ -1616,13 +1627,16 @@ export const SortieDogsPlugin = async (input, options) => {
                 }
                 const startedAt = (await ledger.readGoal()).records.find(({ event }) => event.kind === "dispatch.reserved" &&
                     event.reservation_id === reservation.reservation_id)?.event.at;
+                const usageSegments = await unitUsageSegments(root, reservation.unit_id, dispatch.callID, dispatch.childSessionID);
                 await ledger.appendGoal({ kind: "unit.settled", at: new Date().toISOString(),
                     reservation_id: reservation.reservation_id,
                     receipt_id: goalFingerprint({ recovered_host_task: dispatch.callID, reservation: reservation.reservation_id }),
                     goal_id: state.goal_id, unit_id: reservation.unit_id,
                     disposition: dispatch.cancelled ? "cancelled" : "failed", result_class: dispatch.cancelled ? "interrupted" : "process-defect",
                     progress_fingerprint: null, evidence: [], elapsed_ms: null,
-                    cost_usd: await nativeUnitCost(dispatch.childSessionID, startedAt),
+                    cost_usd: usageSegments ? await priceUsageSegments(usageSegments) : await nativeUnitCost(dispatch.childSessionID, startedAt),
+                    ...(usageSegments ? { native_usage_segments: usageSegments,
+                        native_session_id: dispatch.childSessionID ?? usageSegments.at(-1)?.sessionID } : {}),
                     ...(dispatch.childSessionID ? { native_session_id: dispatch.childSessionID, native_started_at: startedAt } : {}) });
                 // A missed after hook closes execution, but cannot turn unobserved validation into acceptance.
                 await input.runtimeBridge?.onSerialSettlement?.({ rootSessionID: root, callID: dispatch.callID,
@@ -2317,13 +2331,28 @@ export const SortieDogsPlugin = async (input, options) => {
         if (state.phase === "terminal" || state.receipt !== null) {
             throw new Error("SORTIE_GOAL_CONTROL_DENIED: terminal");
         }
+        const inheritedTaskID = handoffValue(handoffEntries(prompt), ["task_id"]);
+        const origin = inheritedTaskID && await input.runtimeBridge?.missionDispatchOrigin?.(goalRoot(sessionID), inheritedTaskID, callID);
+        const retainHandoffReservation = () => {
+            if (!origin)
+                return;
+            const reservationID = goalFingerprint({ goal_id: state.goal_id, unit_id: inheritedTaskID, call_id: origin.callID });
+            const retained = state.outstanding_reservations.find(item => item.reservation_id === reservationID && item.unit_id === inheritedTaskID);
+            if (!retained)
+                throw new Error("mission-handoff-reservation-unavailable");
+            for (const [previousCall, reservation] of goalReservations) {
+                if (reservation.reservationID === reservationID)
+                    goalReservations.delete(previousCall);
+            }
+            goalReservations.set(callID, { root: goalRoot(sessionID), reservationID, unitID: inheritedTaskID, started: Date.parse(origin.startedAt) });
+        };
         if (state.replan_required && !state.replan_used) {
             state = await ledger.appendGoal({ kind: "goal.replanned", at: new Date().toISOString(),
                 goal_id: state.goal_id, revision: state.revision, reason: "no-progress" });
         }
         // No-progress is diagnostic, not another implicit execution budget. Useful
         // repair can continue within the same explicit unit/time/cost limits below.
-        if (state.budget !== null && state.consumed_units + state.outstanding_reservations.length >= state.budget.max_units) {
+        if (!origin && state.budget !== null && state.consumed_units + state.outstanding_reservations.length >= state.budget.max_units) {
             await terminalGoal(sessionID, "stop_budget", "stopped");
             throw budgetDenied("units");
         }
@@ -2337,6 +2366,10 @@ export const SortieDogsPlugin = async (input, options) => {
             await terminalGoal(sessionID, "stop_budget", "stopped");
             throw budgetDenied("cost_usd");
         }
+        if (origin) {
+            retainHandoffReservation();
+            return;
+        }
         if (state.goal_id === null)
             return;
         const unitID = handoffValue(handoffEntries(prompt), ["task_id"]) ?? callID;
@@ -2400,7 +2433,16 @@ export const SortieDogsPlugin = async (input, options) => {
                 ...execution, immutableRef: execution.immutableRef, endedAt: execution.endedAt, fresh: execution.fresh,
                 exitCode: execution.exitCode, outcome: execution.outcome
             }, state, reservation.unitID));
-        const hostEvidence = [...new Map((directEvidence ?? observedEvidence).map(entry => [entry.evidence_id, entry])).values()];
+        const handedChecks = await input.runtimeBridge?.missionHandoffChecks?.(reservation.root, reservation.unitID, callID) ?? [];
+        const inherited = handedChecks.flatMap(check => {
+            const laterFailure = [...hostGoalExecutions.values()].some(execution => execution.root === reservation.root &&
+                execution.sessionID === childSessionID && execution.endedAt && execution.outcome !== "pass" && execution.outcome !== "skip" &&
+                Date.parse(execution.startedAt) >= Date.parse(check.startedAt));
+            return laterFailure ? [] : observedHostGoalEvidence({ ...check, owner: "coordinator", outcome: "pass",
+                immutableRef: goalFingerprint({ direct_check: check }),
+                correction: { taskID: reservation.unitID, dispatchCallID: check.dispatchCallID, commands: check.command } }, state, reservation.unitID);
+        });
+        const hostEvidence = [...new Map((directEvidence ?? [...observedEvidence, ...inherited]).map(entry => [entry.evidence_id, entry])).values()];
         // A worker may return after a user scope epoch changed. Settle its spend/reservation, but only
         // adopt observations still bound to the current accepted source/candidate/criterion contract.
         const acceptedEvidence = hostEvidence.filter((entry) => validGoalEvidence(entry, state) &&
@@ -2432,13 +2474,16 @@ export const SortieDogsPlugin = async (input, options) => {
         const processDefect = !correctionChecks?.failure && failedAcceptanceExecution === undefined && (childSessionID === undefined || hostBindingDefect ||
             goalValidationDefects.has(childSessionID) || !validated);
         const resultClass = validated ? "acceptance" : interrupted ? "interrupted" : processDefect ? "process-defect" : "acceptance";
+        const usageSegments = await unitUsageSegments(reservation.root, reservation.unitID, callID, childSessionID);
         await ledger.appendGoal({ kind: "unit.settled", at: new Date().toISOString(),
             reservation_id: reservation.reservationID, receipt_id: goalFingerprint({ call_id: callID, output: outputText.slice(0, 2048) }),
             goal_id: state.goal_id, unit_id: reservation.unitID,
             disposition: validated ? "succeeded" : interrupted ? "cancelled" : "failed", result_class: resultClass,
             progress_fingerprint: progress && validated ? goalFingerprint(settlementEvidence) : null,
             evidence: settlementEvidence, elapsed_ms: Math.max(0, Date.now() - reservation.started),
-            cost_usd: await nativeUnitCost(childSessionID, new Date(reservation.started).toISOString()),
+            cost_usd: usageSegments ? await priceUsageSegments(usageSegments) : await nativeUnitCost(childSessionID, new Date(reservation.started).toISOString()),
+            ...(usageSegments ? { native_usage_segments: usageSegments,
+                native_session_id: childSessionID ?? usageSegments.at(-1)?.sessionID } : {}),
             ...(childSessionID ? { native_session_id: childSessionID, native_started_at: new Date(reservation.started).toISOString() } : {}) });
         const result = {
             rootSessionID: reservation.root, callID, unitID: reservation.unitID,
@@ -2484,9 +2529,10 @@ export const SortieDogsPlugin = async (input, options) => {
         }
         if (request.direct) {
             const direct = request.direct;
+            const origin = await input.runtimeBridge?.missionDispatchOrigin?.(root, request.unitID, direct.callID);
             const defect = [...snapshot.records].reverse().map(record => record.event).find(event => event.kind === "unit.settled" &&
                 event.unit_id === request.unitID && event.evidence.length === 0 && event.native_session_id === request.childSessionID &&
-                event.reservation_id === goalFingerprint({ goal_id: goal.goal_id, unit_id: request.unitID, call_id: direct.callID }) &&
+                event.reservation_id === goalFingerprint({ goal_id: goal.goal_id, unit_id: request.unitID, call_id: origin?.callID ?? direct.callID }) &&
                 event.receipt_id === goalFingerprint({ call_id: direct.callID,
                     output: "Host-observed direct unit finished; controller session remains active." }));
             if (defect?.kind !== "unit.settled" || Math.abs(Date.parse(defect.at) - Date.parse(direct.finishedAt)) > 1000) {
@@ -8287,7 +8333,7 @@ export const SortieDogsPlugin = async (input, options) => {
                 cost_status: state.consumed_cost_usd === null ? "unknown-usage" : reserved > 0 ? "in-flight-not-final" : "settled",
                 cost_source: "native-usage-price-table",
                 cost_scope: "worker-only", campaign_remaining_usd: null,
-                cost_note: "Implementation token-price estimates from complete native usage; scoped Reviewer corrections use this same Worker-unit ledger. Missing requests remain unknown and are reconciled on later status. Excludes orchestration/read-only review and external campaign spend. Zero settled cost does not mean free execution." };
+                cost_note: "Implementation token-price estimates from complete native usage; direct-author segments and scoped Reviewer corrections use this same Worker-unit ledger. Missing requests remain unknown and are reconciled on later status. Excludes orchestration/read-only review and external campaign spend. Zero settled cost does not mean free execution." };
             return snapshot;
         },
         extendMissionUnitBudget: (root, maxUnits) => serializeChatTransition(root, async () => {
@@ -8353,12 +8399,17 @@ export const SortieDogsPlugin = async (input, options) => {
             activateSession(actor);
             if (!goalReservations.has(direct.callID)) {
                 const snapshot = await (await goalLedger(root)).readGoal();
-                const reservationID = goalFingerprint({ goal_id: snapshot.state.goal_id, unit_id: direct.taskID, call_id: direct.callID });
-                if (snapshot.state.outstanding_reservations.some(item => item.reservation_id === reservationID)) {
-                    goalReservations.set(direct.callID, { root, reservationID, unitID: direct.taskID, started: Date.parse(direct.startedAt) });
-                }
-                else
+                const origin = await input.runtimeBridge?.missionDispatchOrigin?.(root, direct.taskID, direct.callID);
+                if (origin)
                     await reserveGoalDispatch(root, direct.callID, prompt);
+                else {
+                    const reservationID = goalFingerprint({ goal_id: snapshot.state.goal_id, unit_id: direct.taskID, call_id: direct.callID });
+                    if (snapshot.state.outstanding_reservations.some(item => item.reservation_id === reservationID)) {
+                        goalReservations.set(direct.callID, { root, reservationID, unitID: direct.taskID, started: Date.parse(direct.startedAt) });
+                    }
+                    else
+                        await reserveGoalDispatch(root, direct.callID, prompt);
+                }
             }
             const binding = await input.runtimeBridge?.missionReadBinding?.(root, actor, handoffPath);
             if (!binding)
@@ -8395,6 +8446,10 @@ export const SortieDogsPlugin = async (input, options) => {
             await releaseWriteGate(actor);
             releaseSessionEnforcement(actor);
         },
+        assertDirectUnitQuiescent: async (actor) => {
+            if (activeSessions.get(actor)?.inFlightCalls.size)
+                throw new Error("mission-direct-tools-running");
+        },
         failDirectUnit: async (root, actor) => {
             const direct = await input.runtimeBridge?.directMissionExecution?.(actor);
             if (!direct || direct.root !== root)
@@ -8404,7 +8459,8 @@ export const SortieDogsPlugin = async (input, options) => {
             // Cold terminal recovery can happen before the actor's next tool/context hook.
             if (!goalReservations.has(direct.callID)) {
                 const snapshot = await (await goalLedger(root)).readGoal();
-                const reservationID = goalFingerprint({ goal_id: snapshot.state.goal_id, unit_id: direct.taskID, call_id: direct.callID });
+                const origin = await input.runtimeBridge?.missionDispatchOrigin?.(root, direct.taskID, direct.callID);
+                const reservationID = goalFingerprint({ goal_id: snapshot.state.goal_id, unit_id: direct.taskID, call_id: origin?.callID ?? direct.callID });
                 if (snapshot.state.outstanding_reservations.some(item => item.reservation_id === reservationID) ||
                     snapshot.records.some(({ event }) => event.kind === "unit.settled" && event.reservation_id === reservationID)) {
                     goalReservations.set(direct.callID, { root, reservationID, unitID: direct.taskID, started: Date.parse(direct.startedAt) });
@@ -8449,7 +8505,8 @@ export const SortieDogsPlugin = async (input, options) => {
         missionWorkerTerminal: async (root, terminal, writeScopes) => {
             const childSessionID = terminal.childSessionID;
             const snapshot = await (await goalLedger(root)).readGoal();
-            const reservationID = goalFingerprint({ goal_id: snapshot.state.goal_id, unit_id: terminal.taskID, call_id: terminal.callID });
+            const origin = await input.runtimeBridge?.missionDispatchOrigin?.(root, terminal.taskID, terminal.callID);
+            const reservationID = goalFingerprint({ goal_id: snapshot.state.goal_id, unit_id: terminal.taskID, call_id: origin?.callID ?? terminal.callID });
             if (snapshot.state.outstanding_reservations.some(item => item.reservation_id === reservationID) ||
                 !snapshot.records.some(({ event }) => event.kind === "unit.settled" && event.goal_id === snapshot.state.goal_id &&
                     event.unit_id === terminal.taskID && event.reservation_id === reservationID)) {

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

@@ -115,6 +115,8 @@ export declare function reviewerCorrectionValidationFresh(validation: readonly s
     }[];
     nextOccurrence?: number;
 }>;
+/** Preserve a current ordered prefix while the next author executes the remaining recipe. */
+export declare function directHandoffValidationChecks(...args: Parameters<typeof reviewerCorrectionValidationFresh>): Promise<readonly ReviewerCorrectionCheck[]>;
 /** Summary-only native reader: unavailable API/error is not a successfully observed empty history. */
 export declare function observedMissionValidationSummary(validation: readonly string[], childSessionID: string, read?: () => Promise<unknown>, notBefore?: number, directory?: string, directories?: Readonly<Record<string, string>>): Promise<Record<string, unknown>>;
 export declare function missionReviewBaseline(directory: string): Promise<string | undefined>;

package/dist/plugin/mission-review.js

@@ -199,6 +199,14 @@ export function reviewerCorrectionValidation(validation, child, history, notBefo
                 continue;
             }
             previousEnd = attempt.completed;
+            // A final-check-only refresh must replace its old binding, not force the
+            // unchanged prefix to run again. Repeated declarations stay ambiguous;
+            // preserve their existing occurrence rules and validate every saved input.
+            if (completed && partial.length === required.length && members.length === 1 &&
+                members[0].command === required.at(-1) && required.indexOf(members[0].command) === required.length - 1) {
+                partial.splice(0, partial.length, ...completed.slice(0, -1));
+                completed = undefined;
+            }
             if (members[0].command !== required[partial.length] || partial.length === required.length)
                 partial.length = 0;
             failed = undefined;
@@ -268,6 +276,16 @@ export async function reviewerCorrectionValidationFresh(validation, child, histo
     }
     return checked;
 }
+/** Preserve a current ordered prefix while the next author executes the remaining recipe. */
+export async function directHandoffValidationChecks(...args) {
+    const [validation, child, history, started, checks, root, directories, registeredAt] = args;
+    for (let count = validation.length; count > 0; count--) {
+        const result = await reviewerCorrectionValidationFresh(validation.slice(0, count), child, history, started, checks, root, directories, registeredAt);
+        if (result.ready)
+            return checks.filter(check => result.matched?.some(item => item.callID === check.callID));
+    }
+    return [];
+}
 /** Summary-only native reader: unavailable API/error is not a successfully observed empty history. */
 export async function observedMissionValidationSummary(validation, childSessionID, read, notBefore, directory, directories) {
     if (!read)
@@ -356,7 +374,7 @@ export async function missionDeliveryObservation(directory, runID) {
 }
 /** A child ID alone cannot establish the initial phase after a restart or failed dispatch. */
 export function initialMissionReviewPrompt(mission, prompts) {
-    return [mission.review?.initialPrompt, ...prompts].find(prompt => typeof prompt === "string" &&
+    return [mission.review?.initialPrompt, ...(mission.corrections ?? []).map(item => item.initialPrompt), ...prompts].find(prompt => typeof prompt === "string" &&
         prompt.startsWith(`candidate_id: ${mission.id}\n`) && /^review_phase: initial$/mu.test(prompt) &&
         /^canonical_validation_exit: 0$/mu.test(prompt));
 }
@@ -367,8 +385,9 @@ export async function completedMissionReviewPrompts(mission, profile, root, requ
         return [];
     // The completion hook has already bound this prompt to a real independent Reviewer child.
     // Avoid a second V2 history read when its page/list API is temporarily unavailable.
-    if (initialMissionReviewPrompt(mission, []))
-        return [mission.review.initialPrompt];
+    const initial = initialMissionReviewPrompt(mission, []);
+    if (initial)
+        return [initial];
     const owner = mission.coordinator ?? root;
     if (mission.coordinator !== null) {
         const coordinator = await host.get(owner);

package/dist/plugin/profiled.js

@@ -18,7 +18,7 @@ import { publishMissionProgress } from "./mission-progress.js";
 import { formatWorkQuantity, planWorkQuantity } from "../core/work-quantity.js";
 import { cachedWorkProgress, forgetWorkSession, observeActorWork, workRootForActor } from "../core/work-quantity-observations.js";
 import { serializeOperatorStatus } from "./operator-status-output.js";
-import { completedMissionReviewPrompts, initialMissionReviewPrompt, missionDeliveryObservation, missionReviewBaseline, missionReviewSource, observedMissionValidation, observedMissionValidationSummary, missionReviewValidation, reviewerCorrectionValidation, reviewerCorrectionValidationFresh, validationDirectoryMatches } from "./mission-review.js";
+import { completedMissionReviewPrompts, initialMissionReviewPrompt, missionDeliveryObservation, missionReviewBaseline, missionReviewSource, observedMissionValidation, observedMissionValidationSummary, missionReviewValidation, reviewerCorrectionValidation, reviewerCorrectionValidationFresh, directHandoffValidationChecks, validationDirectoryMatches } from "./mission-review.js";
 import { missionLocations, missionLocationPacket } from "./mission-location.js";
 import { prepareValidationScratch } from "./validation-scratch.js";
 import { SOURCE_REVIEW_RISK_TAGS } from "../core/consultation.js";
@@ -355,6 +355,47 @@ export function createProfiledPlugin(profile, assetVersion) {
             return who.role === "dog-reviewer" && who.parent === (mission.coordinator ?? root);
         }
         async function restoreReviewAuthorship(root, mission, id) {
+            // An inline correction admission can end without any implementation: the
+            // controller may be the designated writer. Recover that exact native return
+            // rather than permanently treating the unused grant as source authorship.
+            const unused = mission.sourceAuthors?.includes(id) ? [] : (mission.corrections ?? []).filter(item => item.author === id && item.inlineReview && item.status === "failed" && !item.noWriteReceipt);
+            if (unused.length) {
+                const history = await reviewMessages(id);
+                const receipts = unused.flatMap(correction => {
+                    const inline = correction.inlineReview;
+                    const prompt = history.findIndex(message => record(message.info) && message.info.id === inline.promptID &&
+                        message.info.role === "user" && message.info.sessionID === id);
+                    if (prompt < 0)
+                        return [];
+                    const response = reviewResponseMessages(history, prompt);
+                    const last = [...response].reverse().find(message => record(message.info) && message.info.role === "assistant");
+                    const info = record(last?.info) ? last.info : undefined;
+                    if (!info || info.sessionID !== id || info.finish !== "stop" || info.error || typeof info.id !== "string" ||
+                        !record(info.time) || typeof info.time.completed !== "number" || info.time.completed < inline.admittedAt)
+                        return [];
+                    const parts = response.flatMap(message => Array.isArray(message.parts) ? message.parts.filter(record) : []);
+                    const admitted = parts.findIndex(part => part.type === "tool" && part.tool === repairReview && record(part.state) &&
+                        part.state.status === "completed" && record(part.state.time) && typeof part.state.time.end === "number" &&
+                        part.state.time.end >= inline.admittedAt);
+                    // Before admission this Reviewer was read-only. After it, require the
+                    // observed terminal and only read/search calls; unknown tools or failed
+                    // writes cannot establish that no implementation occurred.
+                    if (admitted < 0 || parts.slice(admitted + 1).some(part => part.type === "tool" &&
+                        (!["read", "grep", "glob"].includes(String(part.tool)) || !record(part.state) ||
+                            !["completed", "error"].includes(String(part.state.status)))))
+                        return [];
+                    return [{ runID: correction.runID, promptID: inline.promptID, messageID: info.id }];
+                });
+                if (receipts.length)
+                    mission = await missions.update(root, current => {
+                        for (const receipt of receipts) {
+                            const correction = current.corrections?.find(item => item.runID === receipt.runID && item.author === id &&
+                                item.status === "failed" && item.inlineReview?.promptID === receipt.promptID);
+                            if (correction)
+                                correction.noWriteReceipt = { promptID: receipt.promptID, messageID: receipt.messageID };
+                        }
+                    });
+            }
             if (!missionReviewIndependent(mission, id) || !mission.attempts?.some(attempt => attempt.childSessionID === id))
                 return mission;
             const history = await reviewMessages(id);
@@ -610,6 +651,28 @@ export function createProfiledPlugin(profile, assetVersion) {
                 return direct && taskID && direct.unit.callID ? { root: direct.root, taskID, callID: direct.unit.callID,
                     startedAt: direct.unit.directExecution.startedAt } : undefined;
             },
+            missionDispatchOrigin: async (root, taskID, callID) => {
+                const state = await operators.read(root);
+                const unit = state?.units.find(item => item.callID === callID && /^task_id: (.+)$/mu.exec(item.task.prompt)?.[1] === taskID);
+                const segments = unit?.directHandoffs?.filter(item => !item.settledCallID || item.settledCallID === callID);
+                const first = segments?.[0];
+                return first ? { callID: first.callID, startedAt: first.startedAt,
+                    segments: segments.map(item => ({ sessionID: item.actor, startedAt: item.startedAt, endedAt: item.handedOffAt })) } : undefined;
+            },
+            missionHandoffChecks: async (root, taskID, callID) => {
+                const run = await operators.read(root);
+                const unit = run?.units.find(item => item.callID === callID && /^task_id: (.+)$/mu.exec(item.task.prompt)?.[1] === taskID);
+                const prior = unit?.directHandoffs?.filter(item => !item.settledCallID || item.settledCallID === callID).at(-1);
+                if (!unit || !prior)
+                    return [];
+                try {
+                    const history = await reviewMessages(prior.actor, prior.startedAt, true);
+                    return await directHandoffValidationChecks(unit.unit.validation, prior.actor, history, Date.parse(prior.startedAt), prior.checks, input.directory, prior.validationCwd ?? unit.unit.validation_cwd, prior.validationRegisteredAt);
+                }
+                catch {
+                    return [];
+                }
+            },
             reviewerCorrectionValidationMembers: async (child, command, directory) => {
                 const correction = await reviewerCorrection(child) ?? await directExecution(child);
                 if (!correction)
@@ -654,6 +717,9 @@ export function createProfiledPlugin(profile, assetVersion) {
                 const unit = run?.units.find(item => /^task_id: (.+)$/m.exec(item.task.prompt)?.[1] === taskID);
                 if (!run || !unit?.callID)
                     return undefined;
+                if (run.phase === "cancelled" && unit.directHandoffs?.length && !unit.childSessionID) {
+                    return { callID: unit.callID, cancelled: true };
+                }
                 // Direct work has no child Task terminal. Its explicit host-observed finish owns
                 // settlement; never mistake a prior parent response for this unit's completion.
                 if (unit.directExecution && run.phase !== "cancelled")
@@ -1150,7 +1216,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                             `and verifies old children before preparing a Worker. Otherwise obtain the user's scope decision.` };
             if (mission.coordinator === null && mission.runID === null && !mission.dispatchOpen && mission.phase === "open") {
                 return { ...packet, task: missions.task(mission),
-                    next_action: "Fast-lane: plan one useful Worker unit with the meaningful formal check known from user, project or task context and estimated scope, then dispatch its Task immediately. Investigation/edit/check/requested commit belong inside Worker before independent Review. Objective: target 2000 characters; original requests are supplied separately. Use Coordinator for an unknown check or real unit decomposition." };
+                    next_action: initialMissionAction(mission) };
             }
             if (mission.coordinator === null && mission.runID === run?.runID && !mission.dispatchOpen &&
                 run?.phase === "awaiting-acceptance" && mission.kind === "operation" && !missionExecutionComplete(mission)) {
@@ -2199,6 +2265,44 @@ export function createProfiledPlugin(profile, assetVersion) {
                 executor_session_id: actor, validation: direct.unit.unit.validation,
                 next_action: `Implement/correct and run the declared checks here, in this same session. Call ${finishDirectUnit} after the requested delivery boundary. No Worker or handoff read is needed. Retain the original requirements; independent Review and Operator acceptance still follow.` });
         }
+        async function handoffDirect(root, actor, callID, notes) {
+            const direct = await directExecution(actor);
+            if (direct) {
+                await control.assertDirectUnitQuiescent(actor);
+                const history = await reviewMessages(actor, direct.unit.directExecution.startedAt, true);
+                const calls = new Map();
+                for (const message of history)
+                    if (record(message.info) && message.info.sessionID === actor && Array.isArray(message.parts)) {
+                        for (const part of message.parts)
+                            if (record(part) && part.type === "tool" && typeof part.callID === "string" && part.callID !== callID)
+                                calls.set(part.callID, part);
+                    }
+                if ([...calls.values()].some(part => !record(part.state) || !["completed", "error"].includes(String(part.state.status)) ||
+                    record(part.state.metadata) && ["running", "pending", "unknown"].includes(String(part.state.metadata.status)))) {
+                    return JSON.stringify({ status: "direct-handoff-awaits-tools", next_action: "Finish the existing native command before handing off this unit; retain its result and continue here or delegate afterwards." });
+                }
+                await activateDirect(actor);
+                const mission = await missions.retainContext(root, actor, history, notes);
+                await operators.handoffDirect(root, actor, await missions.handoffContext(mission));
+            }
+            const run = await operators.required(root);
+            const unit = run.units.find(item => item.status !== "succeeded");
+            const last = unit?.directHandoffs?.at(-1);
+            if (actor !== (run.operatorSessionID ?? root) || !last || last.actor !== actor)
+                throw new Error("mission-direct-handoff-unavailable");
+            // Idempotently finish projection/release after a restart between the durable handoff and response.
+            await missions.update(root, mission => {
+                const previous = mission.attempts?.find(item => item.callID === last.callID);
+                if (previous?.status === "dispatched")
+                    previous.status = "handed-off";
+            });
+            await control.releaseDirectUnit(actor);
+            const next = await operators.next(root, actor);
+            return JSON.stringify({ ...next,
+                handoff: { from: actor, unit_id: unit.unit.id, retained_checks: last.checks.length },
+                next_action: unit.status === "pending" ? "Dispatch the returned Worker once to continue this same unit. Existing edits, context, checks and reservation are retained. The Worker owns remaining implementation and validation; handoff is not completion."
+                    : "The handed-off unit is already admitted. Continue its existing owner; do not dispatch another Worker." });
+        }
         tools[startDirectUnit] = { description: "Execute the next already-planned ordinary unit in this Coordinator/Operator session, including a correction planned with executor=self. Native edits and declared checks become formal evidence without a Worker, handoff read or approval. Never replace an active writer; completed correction history does not restrict this choice.",
             args: {}, execute: async (_args, context) => {
                 const { root } = await missionAuthority(context.sessionID);
@@ -2269,12 +2373,19 @@ export function createProfiledPlugin(profile, assetVersion) {
             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.`,
+        function initialMissionAction(mission) {
+            return mission.preferredExecutor === "coordinator"
+                ? "Dispatch this Coordinator Task now with the supplied recommendation/context. Coordinator owns substantial implementation and can use plan_units executor=self or delegate remaining work when useful. Start useful work, not a route-selection investigation."
+                : "Use the recommendation and already-known context: when a meaningful formal check and useful unit are already known, plan_units can dispatch its Worker directly. Otherwise dispatch this Coordinator Task now; it may implement here or delegate during actual work. Do not investigate merely to decide the route or discover a check for Operator planning.";
+        }
+        tools[startMission] = { description: `Operator: save current requirements and recommend preferred_executor from the original instruction and already-known context, without a routing investigation. The host retains the original request verbatim. Clear bounded work normally suits Worker; coupled design, ambiguous requirements or cross-system integration normally suit Coordinator direct execution. Follow explicit user choices. Coordinator may revise this advisory recommendation during useful work, not a mandatory reassessment. With known unit facts and meaningful formal checks, include unit now (and execution for an operation): worker/default can dispatch its Worker directly; coordinator retains these facts for its own execution choice. Unknown checks are resolved during actual work, not an Operator preflight. Investigation/edit/check/requested commit stay with the chosen author before applicable Review. ${MISSION_GIT_SCOPE} 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 },
                 work_quantities: { type: ["array", "object", "string", "number", "boolean", "null"], items: {}, additionalProperties: true, "x-sortie-optional": true,
                     minLength: 0, maxLength: 65535, minItems: 0, maxItems: 4096,
                     description: "Optional display-only workload array: stable id, kind, relative_weight, bindings.paths/commands, checkpoints. Reuse this ordinary plan; never add a planning/report turn for progress. Invalid shapes/estimates fall back without changing execution." },
-                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 },
+                preferred_executor: { type: "string", enum: ["coordinator", "worker"], "x-sortie-optional": true,
+                    description: "Initial recommendation from the instruction and already-known context. Coordinator may adapt through actual work without approval or a separate investigation. coordinator returns Coordinator even with supplied unit facts; worker uses the direct Worker route when those facts are ready. Not a model override or immutable requirement." },
+                unit: { ...missionUnitSchema, description: "Include already-known unit facts without investigating to fill them. worker/default returns its configured Worker directly; coordinator passes these facts to Coordinator without starting a Worker.", "x-sortie-optional": true },
                 execution: missionExecutionSchema,
                 handoff_context: handoffContextSchema,
                 confirmed_conditions: conditionsSchema,
@@ -2282,6 +2393,8 @@ export function createProfiledPlugin(profile, assetVersion) {
                 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 },
                 intent: { type: "string", enum: ["", "continue", "new", "replace"], "x-sortie-optional": true } }, execute: async (args, context) => {
                 await requireRoot(context.sessionID);
+                if (args.preferred_executor !== undefined && !["coordinator", "worker"].includes(args.preferred_executor))
+                    throw new Error("mission-preferred-executor-invalid");
                 if (args.intent !== undefined && !["", "continue", "new", "replace"].includes(args.intent))
                     throw new Error("mission-intent-invalid");
                 return serializeDispatchTransition(context.sessionID, async () => {
@@ -2329,6 +2442,14 @@ export function createProfiledPlugin(profile, assetVersion) {
                         ...(args.intent === "replace" && cancelled?.phase === "cancelled" ? { cancelledRunID: cancelled.runID } : {}),
                     });
                     mission = await missions.retainContext(context.sessionID, context.sessionID, history, args.handoff_context);
+                    if (args.preferred_executor !== undefined)
+                        mission = await missions.update(context.sessionID, state => {
+                            state.preferredExecutor = args.preferred_executor;
+                        });
+                    const suggestedUnit = args.unit;
+                    if (mission.preferredExecutor === "coordinator" && record(suggestedUnit) && mission.runID === null && !mission.dispatchOpen) {
+                        mission = await missions.update(context.sessionID, state => { state.suggestedUnit = structuredClone(suggestedUnit); });
+                    }
                     const prohibited = args.prohibited_write;
                     if (prohibited !== undefined) {
                         if (!Array.isArray(prohibited) || !prohibited.every(path => typeof path === "string"))
@@ -2367,7 +2488,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                         if (baseline)
                             mission = await missions.update(context.sessionID, state => { state.reviewBaseline = baseline; });
                     }
-                    if (args.unit !== undefined && mission.runID === null && !mission.dispatchOpen &&
+                    if (mission.preferredExecutor !== "coordinator" && args.unit !== undefined && mission.runID === null && !mission.dispatchOpen &&
                         (mission.kind !== "operation" || args.execution !== undefined || mission.execution)) {
                         const planned = JSON.parse(await declareMissionUnits(context.sessionID, context.sessionID, mission, [args.unit], undefined, args.execution, context.callID, args.handoff_context, args.work_quantities));
                         return JSON.stringify({ ...locationObservation(context.sessionID), mission_id: mission.id, requirements: mission.requirements, ...planned });
@@ -2380,7 +2501,8 @@ export function createProfiledPlugin(profile, assetVersion) {
                     return JSON.stringify({ ...locationObservation(context.sessionID), ...(mission.dispatchOpen
                             ? missionDispatchPacket(mission, await operators.read(context.sessionID))
                             : { mission_id: mission.id, requirements: mission.requirements, task: missions.task(mission),
-                                next_action: "Default to plan_units with a meaningful formal check known from user, project or task context and estimated read/write scope; dispatch its returned Worker now. Worker owns investigation/edit/check/requested commit before independent Review. Objective target 2000 characters; original request is separate and verbatim. Use Coordinator for an unknown check or real unit decomposition, not routine preparation." }) });
+                                ...(mission.preferredExecutor ? { preferred_executor: mission.preferredExecutor } : {}),
+                                next_action: initialMissionAction(mission) }) });
                 });
             } };
         tools[skipMissionConsultation] = { description: "Coordinator: durably record why a concrete optional Advisor/Scout consultation is unnecessary. This is observation only: it adds no approval, consultation requirement, or dispatch gate.",
@@ -2539,6 +2661,8 @@ export function createProfiledPlugin(profile, assetVersion) {
             const recoveryErrors = [];
             const addOwner = (actor, window) => owners.set(actor, [...(owners.get(actor) ?? []), window]);
             for (const unit of run.units) {
+                for (const prior of unit.directHandoffs ?? [])
+                    addOwner(prior.actor, { notBefore: prior.startedAt, notAfter: prior.handedOffAt });
                 if (unit.directExecution?.actor) {
                     addOwner(unit.directExecution.actor, { notBefore: unit.directExecution.startedAt,
                         ...(unit.directExecution.finishedAt ? { notAfter: unit.directExecution.finishedAt } : {}) });
@@ -2751,7 +2875,7 @@ export function createProfiledPlugin(profile, assetVersion) {
         }
         async function declareMissionUnits(root, actor, mission, raw, reason, execution, planningCallID, handoffNotes, workQuantities) {
             await control.currentBudget(root);
-            mission = await missions.required(root);
+            mission = actor === root ? await reconcileMissionDispatch(root) ?? await missions.required(root) : await missions.required(root);
             let previous = await operators.read(root);
             if (sourceReconciliationRequired(mission, previous))
                 return JSON.stringify({ ...missionDispatchPacket(mission, previous),
@@ -2766,8 +2890,34 @@ export function createProfiledPlugin(profile, assetVersion) {
                 Array.isArray(execution.commands) && execution.commands.length === 0);
             const plan = missionPlan(mission, raw, input.directory);
             assertMissionWritePaths(mission, plan.units.flatMap(unit => unit.write));
-            if (actor === root && (mission.coordinator !== null || plan.units.length !== 1))
-                throw new Error("mission-coordinator-required: dispatch the returned Coordinator task");
+            if (actor === root && (mission.coordinator !== null || plan.units.length !== 1)) {
+                // A submitted Coordinator still owns corrective planning. Return its actual
+                // continuation instead of referring to a Task that the rejection never supplied.
+                // This is routing advice only: no replacement plan, reservation or admission.
+                // Routing below alone chooses whether to offer a Task. A resumable parent
+                // packet can already contain one even while its Reviewer is still pending.
+                const { task: _dispatchTask, ...packet } = missionDispatchPacket(mission, previous);
+                const reviewPending = mission.runID === previous?.runID && mission.review?.verdict === "pending";
+                const active = mission.dispatchOpen || reviewPending || mission.runID === previous?.runID &&
+                    previous?.units.some(unit => unit.status === "running");
+                const continuation = !active ? missions.task(mission) : undefined;
+                // Existing Coordinator resumes accept a concrete prompt. Do not use the opaque
+                // initial reference here: claim() would expand it from unchanged Mission state
+                // and lose the unadmitted correction that prompted this continuation.
+                const task = continuation && mission.coordinator !== null ? { ...continuation,
+                    prompt: `Continue the same Mission ${mission.id} in this existing Coordinator session, in the user's language. ` +
+                        "Retain the saved original requests, requirements, candidate, checks and cumulative budget.\n" +
+                        "Proposed correction from Operator root (not admitted; preserve requirements, candidate and cumulative budget):\n" +
+                        JSON.stringify({ units: raw, reason, execution, handoff_context: handoffNotes, work_quantities: workQuantities }) } : continuation;
+                return JSON.stringify({ ...packet,
+                    status: active ? "mission-coordinator-active" : "mission-coordinator-required",
+                    ...(task ? { task } : {}),
+                    next_action: reviewPending
+                        ? "Dispatch the exact Reviewer Task from review_mission if not yet active; otherwise wait for that Reviewer. Do not start a Coordinator or another Worker while review is pending. The proposed plan has not been admitted."
+                        : active
+                            ? "Continue the active owning session or wait for its native completion; do not dispatch a duplicate Coordinator or Worker. The proposed plan has not been admitted."
+                            : "Dispatch this exact Task to continue the same Mission and Coordinator session with the concrete correction and retained checks. The proposed plan has not been admitted; keep requirements, candidate and cumulative budget unchanged." });
+            }
             const same = previous?.planHash === createHash("sha256").update(JSON.stringify(plan)).digest("hex");
             const replanning = previous && !["completed", "cancelled"].includes(previous.phase) && !same;
             const activeDirect = previous?.units.find(unit => unit.status === "running" && unit.directExecution?.actor === actor);
@@ -2936,19 +3086,25 @@ export function createProfiledPlugin(profile, assetVersion) {
                 : next);
         }
         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. Reuse useful author context by default; legitimate Worker/direct handoff remains available after terminal work, including correction. Retain findings, actual authorship and passed input-bound checks; do not rediscover or revalidate unchanged work merely for a new actor. ${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. Completion history is not a correction-owner lock or an acceptance prerequisite.`,
-            args: { units: { type: "array", minItems: 1, maxItems: 32, items: missionUnitSchema },
+            args: { units: { type: "array", minItems: 1, maxItems: 32, items: missionUnitSchema, "x-sortie-optional": true,
+                    description: "Useful work units. Omit only with executor=worker to hand off your currently running direct unit, retaining its contract and existing work." },
                 work_quantities: tools[startMission].args.work_quantities,
                 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) => {
+                executor: { type: "string", enum: ["worker", "self"], description: "Use self to implement/correct and formally validate here. Use worker without units to yield the current direct unit, carrying remaining action in handoff_context; the same unit, edits, checks and budget continue. With units, worker/default retains configured Worker routing.", "x-sortie-optional": true } }, execute: async (args, context) => {
                 const { root, mission } = await missionAuthority(context.sessionID);
                 if (args.executor !== undefined && !["self", "worker"].includes(args.executor))
                     throw new Error("mission-executor-invalid");
                 try {
                     return await serializeDispatchTransition(root, async () => {
+                        if (args.executor === "worker" && args.units === undefined)
+                            return handoffDirect(root, context.sessionID, context.callID, args.handoff_context);
                         const planned = await declareMissionUnits(root, context.sessionID, mission, args.units, args.reason, args.execution, context.callID, args.handoff_context, args.work_quantities);
-                        return args.executor === "self" && record(JSON.parse(planned).task) ? startDirect(root, context.sessionID) : planned;
+                        const task = JSON.parse(planned).task;
+                        // A Coordinator continuation is not a newly prepared direct unit.
+                        return args.executor === "self" && record(task) && task.subagent_type !== profileAgent(profile, "dog-operator")
+                            ? startDirect(root, context.sessionID) : planned;
                     });
                 }
                 catch (error) {
@@ -3092,7 +3248,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                             current.verdict = "findings";
                             current.result = findings;
                             // The independent investigation is recorded by this real tool call, not a fictitious terminal.
-                            current.initialPrompt = current.task.prompt;
+                            current.initialPrompt = initialMissionReviewPrompt(item, [current.task.prompt]);
                         });
                         review = mission.review;
                     }
@@ -3289,7 +3445,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                     // turn. Generate verification only when a completed initial review is recoverable;
                     // otherwise generate an admissible initial review instead of trapping the Coordinator.
                     const prior = mission.review?.task?.prompt;
-                    const completed = risk.length > 0 && prior && mission.review?.child && !mission.review.initialPrompt
+                    const completed = risk.length > 0 && prior && !initialMissionReviewPrompt(mission, [])
                         ? await completedMissionReviewPrompts(mission, profile, root, prior, {
                             get: async (id) => payload(await session("get", { path: { id }, query: { directory: input.directory } })),
                             messages: reviewMessages,

package/dist/plugin/runtime-bridge.d.ts

@@ -89,6 +89,17 @@ export interface RuntimeBridge {
         callID: string;
         startedAt: string;
     } | undefined>;
+    /** The same unit's original reservation and completed direct-author usage segments. */
+    missionDispatchOrigin?(rootSessionID: string, taskID: string, callID: string): Promise<{
+        callID: string;
+        startedAt: string;
+        segments: readonly {
+            sessionID: string;
+            startedAt: string;
+            endedAt: string;
+        }[];
+    } | undefined>;
+    missionHandoffChecks?(rootSessionID: string, taskID: string, callID: string): Promise<readonly ReviewerCorrectionCheck[]>;
     reviewerCorrectionValidationMembers?(childSessionID: string, command: string, directory?: string): Promise<string[] | undefined>;
     missionValidationDirectoryMatches?(rootSessionID: string, taskID: string, childSessionID: string, commands: readonly string[], directory: string): Promise<boolean>;
     recordReviewerCorrectionCheck?(rootSessionID: string, taskID: string, check: ReviewerCorrectionCheck): Promise<void>;
@@ -225,6 +236,7 @@ export interface RuntimeBridge {
         /** Settle an unfinished direct unit against its actual actor, never a fabricated child Task. */
         failDirectUnit(rootSessionID: string, actorSessionID: string): Promise<void>;
         releaseDirectUnit(actorSessionID: string): Promise<void>;
+        assertDirectUnitQuiescent(actorSessionID: string): Promise<void>;
         expandMissionWriteGate(childSessionID: string, paths: readonly string[]): Promise<void>;
         completeRoot(rootSessionID: string, acceptanceFingerprint: string): Promise<{
             status: "succeeded" | "awaiting-evidence";

package/dist/plugin/tool-schema.js

@@ -33,11 +33,13 @@ export function toolSchema(args) {
             const schema = plainSchema(value);
             if (optionalArgument(value)) {
                 schema.description = `${typeof schema.description === "string" ? `${schema.description} ` : ""}Pass an empty string to omit this argument.`;
-                // Object-typed optional arguments otherwise force a model to manufacture blank
-                // required provenance fields. Admit the same omission sentinel we already decode.
-                if (schema.type === "object")
+                // Structured optional arguments need the same omission sentinel we decode;
+                // otherwise V2 requires a fabricated object/array even when the tool says to omit it.
+                if (schema.type === "object" || schema.type === "array")
                     return [name, { anyOf: [schema, { type: "string", enum: [""], minLength: 0, maxLength: 0 }],
                             description: schema.description }];
+                if (schema.type === "string" && Array.isArray(schema.enum) && !schema.enum.includes(""))
+                    schema.enum = [...schema.enum, ""];
             }
             return [name, schema];
         })),

package/dist/plugin/unit-usage.d.ts

@@ -1,2 +1,2 @@
 /** Price complete native requests; absent/interrupted usage is unknown, never a fabricated zero. */
-export declare function settledUnitUsage(messages: readonly unknown[], startedAt?: string): number | null;
+export declare function settledUnitUsage(messages: readonly unknown[], startedAt?: string, endedAt?: string): number | null;

package/dist/plugin/unit-usage.js

@@ -1,7 +1,7 @@
 import { estimateModelUsageCost } from "./model-cost.js";
 const record = (value) => !!value && typeof value === "object" && !Array.isArray(value);
 /** Price complete native requests; absent/interrupted usage is unknown, never a fabricated zero. */
-export function settledUnitUsage(messages, startedAt) {
+export function settledUnitUsage(messages, startedAt, endedAt) {
     let cost = 0, requests = 0;
     const seen = new Set();
     for (const message of messages) {
@@ -12,10 +12,12 @@ export function settledUnitUsage(messages, startedAt) {
             continue;
         seen.add(info.id);
         const time = record(info.time) ? info.time : undefined;
-        if (startedAt) {
+        if (startedAt || endedAt) {
             if (typeof time?.created !== "number")
                 return null;
-            if (time.created < Date.parse(startedAt))
+            if (startedAt && time.created < Date.parse(startedAt))
+                continue;
+            if (endedAt && time.created >= Date.parse(endedAt))
                 continue;
         }
         if (typeof time?.completed !== "number")

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

@@ -18,6 +18,8 @@ export declare const MISSION_REFLECTION_WORKFLOW = "When bounded process reflect
 export declare function missionOperatorContent(profile: RuntimeProfile, version: string): string;
 /** Keep representation oracles consistent in direct execution, Worker and Review. */
 export declare const MISSION_REPRESENTATION_ORACLE = "Same-type representation, not name/visitor analogy; resolve conflicts.";
+/** Planning and Review use public type families instead of only issue-named examples. */
+export declare const MISSION_TYPE_FAMILY_ORACLE = "When changing a dispatch/exclusion set, derive the affected same-representation family from an existing\nschema/registry and its public callers, not just issue examples. Compare sibling entries under that\ncontract; reuse suitable parameterized checks. Do not widen unrelated families or require an exhaustive\nmatrix, another unit or review lane.";
 /** Coordinator preserves source-backed return semantics in direct work or a Worker's objective. */
 export declare const MISSION_RETURN_CONTRACT = "For a changed value-producing operation, derive its return contract from public callers and unchanged source/tests.\nPreserve established return type/container, metadata and label alignment unless the original request changes them;\nequal numeric values alone do not prove that contract. Trace which inputs determine result shape and labels,\nincluding non-primary parameters; a scalar primary input need not yield a scalar result. For a mask or conditional\nreplacement, preserve established broadcasting and missing-value propagation; an unknown condition is not proof\nthat replacement is intended. Carry the affected contract into direct work or the Worker's objective.\nReuse an adequate focused assertion; add only the smallest source-backed regression when needed, not an input matrix,\nanother unit, validation lane or review.";
 /** Coordinator preserves source-backed mutation semantics in direct work or a Worker's objective. */
@@ -25,7 +27,7 @@ export declare const MISSION_MUTATION_CONTRACT = "For a changed mutating operati
 /** Coordinator authors and plans regressions without adding another validation/review lane. */
 export declare const MISSION_REGRESSION_PLACEMENT = "Prefer an existing relevant test suite/subtest or fixture when it can express the regression assertion.\nIf a new test module is needed, prefer a distinctive behavior-specific name over automatically mirroring the implementation module.\nPreserve established assertions and project test discovery. This is placement guidance, not another test, unit or review requirement.";
 /** Shared by the installed Reviewer and its host-generated mission prompt. */
-export declare const MISSION_BEHAVIOR_REVIEW = "Establish the test oracle independently of the patch: tests added with the implementation are claims to\nreview, not established API behavior. For a changed failure path, compare a pre-existing analogous public\ntest and its shared assertion helper, including default expected outputs, with the new case. A new test\nthat asserts the implementation's current result can encode the defect rather than catch it. Preserve\nthe pre-change contract unless the request changes it; do not invent a universal failure-result convention.\nFor changed observable behavior, inspect affected public caller assertions/output snapshots found by search, not only implementation-local fixtures.\nReconcile expected outputs with the original requirements and reuse adequate checks; no extra review round.\nFor requested side-effect changes, check remaining controls with existing client-owned state, not only isolated defaults.\nJudge allowed effects from the original request; preserve authorized opt-in behavior.\nSame-type representation, not name/visitor analogy; resolve conflicts.\nTrace a concrete rejected input through the changed code back to the public caller, checking result,\nerror and observable state together, including earlier results that can survive failure. Missing assertions\nalone are not defects; a concrete contradiction with the established contract is a finding even if tests pass.\nDuring correction, reuse the established public test harness where applicable and exercise the smallest\nregression exposing the defect before the fix and passing afterward. Do not change expected values or\nhelper defaults merely to agree with the implementation; derive them from the original contract.\nPrefer existing suites/subtests for regressions. New test entry/helper names should be distinctive\nand compose with other same-package test files, not create generic package-level collisions.\n\nFor a requested per-call mode/option, trace where the setting is chosen and where changed code uses\nretained objects or closures. Distinguish the current caller's setting from a captured creation-time\nsetting; use the requested contract to decide which governs. If actual source crosses that boundary\nand existing tests do not cover it, exercise its smallest public case, including the disabled behavior.\nDo not invent a lifecycle matrix or infer that an opt-in feature is correct from only its enabled path.\n\nFor a changed failure handler, inspect the operation it calls and the public inputs reaching it,\nincluding failures not listed in the new handler. Use the supplied source/tests and established API behavior\nto identify a concrete input that could still violate the requested contract. A passing normal input does\nnot settle a different failure outcome of that same operation. A demonstrable material defect is FINDINGS; ask for\nan excerpt or result only when a specific material outcome cannot be settled. Do not invent new behavior,\nrequire an exhaustive exception inventory, or recommend catching every exception.\n\nReport FINDINGS only for concrete major or medium defects with a material impact on the original requirements,\npublic behavior, correctness or required validation. Name the consequence and smallest necessary fix.\nDo not turn minor style, wording, optional improvements or speculative edge cases into FINDINGS or EVIDENCE_GAPS.\nUse read/search to settle missing context in the current review. If a consequential uncertainty remains,\nrecord EVIDENCE_GAPS as an advisory limitation, not a demand for another evidence packet. Missing narration,\nrequirement mappings, hashes or clipped excerpts alone never justify a blocking finding.\n\nAssess behavioral requirements against actual source, tests and observed results. A required check known to\nhave failed or not run is a concrete finding; missing documentation of a check is not proof it did not run.\nFor incidental workflow constraints such as cache settings or command-path spelling, use existing host observations;\nabsence of a separate settings dump or historical log is not itself an evidence gap. Flag observed material\ncontradictions. The Operator owns final comparison with the original request. If a missing check genuinely\naffects correctness or a requested deliverable, name that consequence and the smallest useful next check.\nOn verification, compare the correction and its affected public outcomes with the original contract, not\nonly the wording of previous findings. Reuse unchanged evidence; do not expand into optional improvements\nor an exhaustive input matrix. PASS means no material finding, not exhaustive proof of every path.";
+export declare const MISSION_BEHAVIOR_REVIEW = "Establish the test oracle independently of the patch: tests added with the implementation are claims to\nreview, not established API behavior. For a changed failure path, compare a pre-existing analogous public\ntest and its shared assertion helper, including default expected outputs, with the new case. A new test\nthat asserts the implementation's current result can encode the defect rather than catch it. Preserve\nthe pre-change contract unless the request changes it; do not invent a universal failure-result convention.\nFor changed observable behavior, inspect affected public caller assertions/output snapshots found by search, not only implementation-local fixtures.\nReconcile expected outputs with the original requirements and reuse adequate checks; no extra review round.\nFor requested side-effect changes, check remaining controls with existing client-owned state, not only isolated defaults.\nJudge allowed effects from the original request; preserve authorized opt-in behavior.\nSame-type representation, not name/visitor analogy; resolve conflicts.\nWhen changing a dispatch/exclusion set, derive the affected same-representation family from an existing\nschema/registry and its public callers, not just issue examples. Compare sibling entries under that\ncontract; reuse suitable parameterized checks. Do not widen unrelated families or require an exhaustive\nmatrix, another unit or review lane.\nTrace a concrete rejected input through the changed code back to the public caller, checking result,\nerror and observable state together, including earlier results that can survive failure. Missing assertions\nalone are not defects; a concrete contradiction with the established contract is a finding even if tests pass.\nDuring correction, reuse the established public test harness where applicable and exercise the smallest\nregression exposing the defect before the fix and passing afterward. Do not change expected values or\nhelper defaults merely to agree with the implementation; derive them from the original contract.\nPrefer existing suites/subtests for regressions. New test entry/helper names should be distinctive\nand compose with other same-package test files, not create generic package-level collisions.\n\nFor a requested per-call mode/option, trace where the setting is chosen and where changed code uses\nretained objects or closures. Distinguish the current caller's setting from a captured creation-time\nsetting; use the requested contract to decide which governs. If actual source crosses that boundary\nand existing tests do not cover it, exercise its smallest public case, including the disabled behavior.\nDo not invent a lifecycle matrix or infer that an opt-in feature is correct from only its enabled path.\n\nFor a changed failure handler, inspect the operation it calls and the public inputs reaching it,\nincluding failures not listed in the new handler. Use the supplied source/tests and established API behavior\nto identify a concrete input that could still violate the requested contract. A passing normal input does\nnot settle a different failure outcome of that same operation. A demonstrable material defect is FINDINGS; ask for\nan excerpt or result only when a specific material outcome cannot be settled. Do not invent new behavior,\nrequire an exhaustive exception inventory, or recommend catching every exception.\n\nReport FINDINGS only for concrete major or medium defects with a material impact on the original requirements,\npublic behavior, correctness or required validation. Name the consequence and smallest necessary fix.\nDo not turn minor style, wording, optional improvements or speculative edge cases into FINDINGS or EVIDENCE_GAPS.\nUse read/search to settle missing context in the current review. If a consequential uncertainty remains,\nrecord EVIDENCE_GAPS as an advisory limitation, not a demand for another evidence packet. Missing narration,\nrequirement mappings, hashes or clipped excerpts alone never justify a blocking finding.\n\nAssess behavioral requirements against actual source, tests and observed results. A required check known to\nhave failed or not run is a concrete finding; missing documentation of a check is not proof it did not run.\nFor incidental workflow constraints such as cache settings or command-path spelling, use existing host observations;\nabsence of a separate settings dump or historical log is not itself an evidence gap. Flag observed material\ncontradictions. The Operator owns final comparison with the original request. If a missing check genuinely\naffects correctness or a requested deliverable, name that consequence and the smallest useful next check.\nOn verification, compare the correction and its affected public outcomes with the original contract, not\nonly the wording of previous findings. Reuse unchanged evidence; do not expand into optional improvements\nor an exhaustive input matrix. PASS means no material finding, not exhaustive proof of every path.";
 /** Mission Reviewer uses ordinary host read/search permissions, not a supplied-packet-only protocol. */
 export declare function missionReviewerContent(profile: RuntimeProfile): string;
 export declare function missionCoordinatorContent(profile: RuntimeProfile, version: string): string;

package/dist/runtime-mission-assets.js

@@ -161,20 +161,25 @@ ${MISSION_DEPENDENCY_WORKFLOW}
     ${profile.toolPrefix}cancel_operator with reason: "plain" to stop its owned children, then
     ${profile.toolPrefix}start_mission with intent: "replace" and the saved requirements. The cancelled
     Mission is archived; cumulative spend is retained. Dispatch only the returned Coordinator Task.
-  2. If a meaningful formal check is known from the user, project or task context and the work fits one unit,
-    include unit in start_mission to receive its Worker immediately in the same call. For a known operation,
-    include execution commands/directory alongside unit. If already started,
-    call plan_units and dispatch its Worker. Source investigation, shell/environment checks,
-    fix design and output inventory belong inside that Worker, not a routine Operator preflight.
+  2. Recommend preferred_executor in start_mission from the original instruction and already-known context.
+    Respect explicit user choices. Clear bounded implementation or known procedures normally suit worker;
+    coupled design, ambiguous requirements and cross-system integration normally suit coordinator.
+    Do not read/search/run diagnostics merely to classify difficulty or fill an Operator planning form.
+    A short reason in handoff_context is enough. This recommendation is advisory, not an immutable requirement.
+    Coordinator starts useful work immediately and may implement substantially itself or delegate remaining work
+    as execution makes that useful, without a separate reassessment or your approval.
+    If meaningful formal checks and unit facts are already known, include unit (and execution for a known operation).
+    worker/default receives its configured Worker directly; coordinator receives these facts without starting a Worker.
+    Unknown checks are discovered during useful author work, not a route-selection preflight.
+    Source investigation, shell/environment checks, fix design and output inventory belong with that author.
     Use estimated read/write paths; native scope reconciliation and expand_unit cover actual outputs.
     Write objective as the target or corrective delta: aim for 2000 characters.
     The Worker reads the full original request natively from its handoff once, including exact public reproduction
     inputs, paths and failures; do not copy that request into objective. Preserve it, not a summary.
-    Do not list speculative write paths or unrelated test suites as a precaution. Risk, file count,
-    duration and independent review alone do not require Coordinator. If the check is unknown, real unit
-    decomposition is needed, or a material user decision prevents work, use the returned
-     ${profileAgent(profile, "dog-operator")} Task for targeted discovery/coordination within the same budget.
-    Investigation, edits, formal checks and any requested commit stay in that Worker before independent Review;
+    Do not list speculative write paths or unrelated test suites as a precaution. File count, instruction length,
+    duration and availability of a check do not alone determine difficulty. Dispatch the returned
+    ${profileAgent(profile, "dog-operator")} Task when Coordinator is selected or unit facts are not yet known.
+    Investigation, edits, formal checks and any requested commit stay with the chosen author before independent Review;
     do not invent a review-before-commit gate or a commit-only handoff. Preserve explicit user ordering.
     ${MISSION_GIT_SCOPE}
 3. After a direct Worker succeeds, use its recorded result and inspect only missing source or evidence
@@ -279,6 +284,11 @@ existing user authorization and project gates; npm publication remains manual.
 }
 /** Keep representation oracles consistent in direct execution, Worker and Review. */
 export const MISSION_REPRESENTATION_ORACLE = `Same-type representation, not name/visitor analogy; resolve conflicts.`;
+/** Planning and Review use public type families instead of only issue-named examples. */
+export const MISSION_TYPE_FAMILY_ORACLE = `When changing a dispatch/exclusion set, derive the affected same-representation family from an existing
+schema/registry and its public callers, not just issue examples. Compare sibling entries under that
+contract; reuse suitable parameterized checks. Do not widen unrelated families or require an exhaustive
+matrix, another unit or review lane.`;
 /** Coordinator preserves source-backed return semantics in direct work or a Worker's objective. */
 export const MISSION_RETURN_CONTRACT = `For a changed value-producing operation, derive its return contract from public callers and unchanged source/tests.
 Preserve established return type/container, metadata and label alignment unless the original request changes them;
@@ -314,6 +324,7 @@ For changed observable behavior, inspect affected public caller assertions/outpu
 Reconcile expected outputs with the original requirements and reuse adequate checks; no extra review round.
 ${MISSION_CLIENT_STATE_CHECK}
 ${MISSION_REPRESENTATION_ORACLE}
+${MISSION_TYPE_FAMILY_ORACLE}
 Trace a concrete rejected input through the changed code back to the public caller, checking result,
 error and observable state together, including earlier results that can survive failure. Missing assertions
 alone are not defects; a concrete contradiction with the established contract is a finding even if tests pass.
@@ -470,11 +481,17 @@ ${controls(profile, ["plan_units", "start_direct_unit", "finish_direct_unit", "o
 You are Coordinator. Own most of the practical work and dispatch within the saved original request.
 You retain practical implementation authority: investigate, edit, correct, run formal checks and deliver
 in this SAME session when your existing context makes that efficient. You are not a dispatch-only role.
+Use the Operator's preferred_executor as a starting recommendation. Start useful work with available context;
+do not investigate merely to confirm the recommendation. Adapt through actual work, honoring explicit user choices.
 Use plan_units with executor: "self" for direct work, or start_direct_unit for an already prepared unit.
 The host binds your native check results to the candidate; finish_direct_unit closes that work without
 a Worker handoff. Independent Review and Operator final acceptance still follow. This is not limited to
 micro-edits. Delegate to the configured Worker when that reduces work/cost or provides useful separation.
 There is no proposal/approval/contract-repair round trip in this route.
+To hand unfinished direct work to a Worker, call plan_units with executor: "worker", omit units, and put
+the remaining action/useful observations in handoff_context. The host transfers this same unit after current
+native commands settle, retaining changes, checks and budget. Do not finish it as successful or replan just
+to change its author. Dispatch the returned Task once; Operator recommendation does not prevent this choice.
 Use project-relative paths for repository read/search/shell; the native working directory is project_root.
 Do not reconstruct or prepend the absolute workspace path. Preserve explicitly requested external paths.
 
@@ -495,9 +512,10 @@ For a named release in the one-attempt case-study fixture, pass its --release-re
 the v0127 matched profile intentionally pins 0.12.7, not the newest release. If these identities differ,
 select the matching runner/profile before starting rather than changing the pinned comparison or spending an arm.
 
-When delegating, start the first useful Worker without redundant source/shell preparation; let it
-investigate, check the environment and design the fix. When you already know the necessary implementation
-or correction, execute it directly instead of re-explaining it to another Worker. Call ${profile.toolPrefix}plan_units with concise units:
+Continue directly while your context makes that efficient. Delegate when the remaining work is clearer or
+separation reduces effort; no routing-only investigation or mandatory delegation checkpoint. The configured Worker
+can investigate, design, implement and check its assigned work; do not reduce its capability to mechanical edits.
+When delegating, start useful work without redundant source/shell preparation. Call ${profile.toolPrefix}plan_units with concise units:
 title, objective, read/write file or directory scopes, validation commands, and related requirement_ids
 when splitting multiple requirements across multiple units; a single unit inherits all requirements when
 requirement_ids is omitted. For operation missions, include execution with the actual
@@ -528,6 +546,7 @@ If peer source/tests expose a plausible related still-unhandled error, probe its
 before choosing the fix; reuse adequate checks. Include this in the current author's objective/check
 plan, not another unit or review round. Do not invent an exhaustive error matrix.
 ${MISSION_REPRESENTATION_ORACLE}
+${MISSION_TYPE_FAMILY_ORACLE}
 ${MISSION_RETURN_CONTRACT}
 ${MISSION_MUTATION_CONTRACT}
 ${MISSION_REGRESSION_PLACEMENT}
@@ -659,8 +678,7 @@ Use bounded documented setup in ${TOOL_ENVIRONMENT}/; reuse, never delete.
 User missing-only: installed/incompatible is not missing.
 Per-call modes: check retained creation/use for captured vs current settings.
 Tests: existing suites/subtests or distinctive regression entry names.
-${WORKER_VALIDATION_WORKFLOW}
-No fake success.
+${WORKER_VALIDATION_WORKFLOW}No fake success.
 Parent: independent Review after return, not before execution; no review-before-commit gate.
 Do not spawn nested subagents, amend, push/publish. Return changes, command/exit/elapsed,
 rerun reasons, unresolved/untested behavior; no proof doc.

package/package.json

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