sortie-dogs 0.13.21 → 0.14.0

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.0](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.14.0)**
+· [Release notes](docs/release-v0.14.0.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.0
 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.0
 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.
@@ -193,7 +195,7 @@ known expense. Official local evaluation and leaderboard acceptance are separate
 **8/23 (34.8%)**, versus v0.12.25's 7/23; all seven prior resolutions retained, no empty patches or
 official evaluation errors. [Fixed conditions, stopped-run accounting and costs](docs/benchmarks/swebench-lite-history.md#v0131-dev23-2026-09-30).
 
-All scores belong to their fixed candidates, **not v0.13.21**. SWE-bench remains an optional
+All scores belong to their fixed candidates, **not v0.14.0**. SWE-bench remains an optional
 measurement, not a release gate. Different budgets, models and conditions are not controlled comparisons.
 
 ## Configuration
@@ -216,7 +218,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.0-autonomous-routing-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 +234,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.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.21-operation-recovery-v1";
+export declare const V010_RUNTIME_ASSET_VERSION = "0.14.0-autonomous-routing-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.21-operation-recovery-v1";
+export const V010_RUNTIME_ASSET_VERSION = "0.14.0-autonomous-routing-v1";
 export const CODEX_SKILL_ASSET_VERSION = "0.13.11-codex-skill-v2";

package/dist/cli/codex-mission.js

@@ -47,7 +47,7 @@ export async function runCodexMissionCommand(argv) {
         const result = await adapter.run(prompt);
         process.stdout.write(`${JSON.stringify({ status: result.accepted ? "succeeded" : "incomplete", root_session_id: result.rootSessionID,
             thread_id: result.turn.threadID, turn_id: result.turn.turnID, native_status: result.turn.status,
-            response: result.turn.finalResponse, sessions: result.sessions, cost: null })}\n`);
+            response: result.turn.finalResponse, lifecycle: result.lifecycle, sessions: result.sessions, cost: null })}\n`);
         return signalExit ?? (result.accepted ? 0 : 1);
     }
     catch (error) {
@@ -66,6 +66,11 @@ export async function runCodexMissionCommand(argv) {
 }
 /** Bounded user-facing progress; do not dump control packets or hidden reasoning. */
 export function codexMissionProgress(event) {
+    if (event.method === "turn/completed")
+        return { thread_id: event.threadId, phase: "native-turn-terminal", turn_id: event.params.turn?.id,
+            native_status: event.params.turn?.status };
+    if (event.method === "sortie/continuation")
+        return { thread_id: event.threadId, turn_id: event.params.turnId, phase: event.params.phase, calls: event.params.calls };
     if (event.method === "sortie/modelRoute")
         return { thread_id: event.threadId, phase: "model-route", agent: event.params.agent, model: event.params.model,
             effort: event.params.effort, service_tier: event.params.serviceTier };

package/dist/codex/app-server.d.ts

@@ -46,6 +46,14 @@ export interface CodexTurnResult {
     readonly finalResponse?: string;
     readonly items: readonly JsonObject[];
     readonly usage?: JsonObject;
+    /** Host tools still running at native turn completion, drained without resending them. */
+    readonly deferredToolResults?: readonly CodexDeferredToolResult[];
+}
+export interface CodexDeferredToolResult {
+    readonly callID: string;
+    readonly tool: string;
+    readonly success: boolean;
+    readonly output: string;
 }
 export interface CodexAuthenticationState {
     readonly type: string | null;

package/dist/codex/app-server.js

@@ -188,7 +188,7 @@ export class CodexAppServerHost {
         if (!turnID)
             throw new CodexHostError("protocol-invalid-response", "turn/start returned no turn id.");
         return new Promise((resolve, reject) => {
-            this.active = { threadID, turnID, items: [], observer: Promise.resolve(), onEvent: options.onEvent, resolve, reject };
+            this.active = { threadID, turnID, items: [], observer: Promise.resolve(), tools: new Set(), onEvent: options.onEvent, resolve, reject };
             const backlog = this.notificationBacklog.splice(0);
             void backlog.reduce((prior, event) => prior.then(() => this.notification(event.method, event.params)), Promise.resolve())
                 .catch(error => { this.active?.reject(error); this.active = undefined; });
@@ -289,20 +289,34 @@ export class CodexAppServerHost {
         const params = object(message.params) ? message.params : {};
         if (method === "item/tool/call") {
             const active = this.active;
-            let result;
+            if (!active || active.completing || params.threadId !== active.threadID || params.turnId !== active.turnID ||
+                (params.namespace != null) || typeof params.callId !== "string" || typeof params.tool !== "string" || !this.options.dynamicTool) {
+                this.transport.send({ id: message.id, result: { contentItems: [{ type: "inputText",
+                                text: "Dynamic tool call does not belong to an active Sortie turn." }], success: false } });
+                return;
+            }
+            const call = { threadId: active.threadID, turnId: active.turnID, callId: params.callId, tool: params.tool, arguments: params.arguments };
+            const pending = Promise.resolve().then(async () => {
+                let output, success;
+                try {
+                    output = await this.options.dynamicTool(call);
+                    success = true;
+                }
+                catch (error) {
+                    output = error instanceof Error ? error.message : "Dynamic tool failed.";
+                    success = false;
+                }
+                if (!this.closed && !this.fault)
+                    this.transport.send({ id: message.id, result: { contentItems: [{ type: "inputText", text: output }], success } });
+                return { callID: call.callId, tool: call.tool, success, output };
+            });
+            active.tools.add(pending);
             try {
-                if (!active || active.completing || params.threadId !== active.threadID || params.turnId !== active.turnID ||
-                    (params.namespace != null) || typeof params.callId !== "string" || typeof params.tool !== "string" || !this.options.dynamicTool)
-                    throw new Error("Dynamic tool call does not belong to an active Sortie turn.");
-                const output = await this.options.dynamicTool({ threadId: active.threadID, turnId: active.turnID,
-                    callId: params.callId, tool: params.tool, arguments: params.arguments });
-                result = { contentItems: [{ type: "inputText", text: output }], success: true };
+                await pending;
             }
-            catch (error) {
-                result = { contentItems: [{ type: "inputText", text: error instanceof Error ? error.message : "Dynamic tool failed." }], success: false };
+            finally {
+                active.tools.delete(pending);
             }
-            if (!this.closed)
-                this.transport.send({ id: message.id, result });
             return;
         }
         if (method === "item/commandExecution/requestApproval" || method === "item/fileChange/requestApproval") {
@@ -374,14 +388,23 @@ export class CodexAppServerHost {
         // requests such as interrupt(), whose response must be read by this pump.
         // Keep the completing turn active until observers settle so close() can
         // reject it and a later turn cannot receive an interrupt meant for it.
-        void active.observer.then(() => {
+        const deferred = status === "completed" ? [...active.tools] : [];
+        // Native response completion is not host execution completion. Keep pumping
+        // command responses and child Tasks; explicit close/transport loss can still
+        // reject this turn. Failed/interrupted native turns never auto-continue.
+        void Promise.all([active.observer, Promise.all(deferred)]).then(([, tools]) => {
             if (this.active !== active)
                 return;
             this.active = undefined;
             if (active.observerError)
                 active.reject(new CodexHostError("request-failed", "Codex turn event observer failed.", active.observerError));
             else
-                active.resolve(result);
+                active.resolve({ ...result, ...(tools.length ? { deferredToolResults: tools } : {}) });
+        }).catch(error => {
+            if (this.active !== active)
+                return;
+            this.active = undefined;
+            active.reject(error);
         });
     }
 }

package/dist/codex/mission-session.d.ts

@@ -67,6 +67,12 @@ export declare class CodexMissionSession {
         rootSessionID: string;
         turn: CodexTurnResult;
         accepted: boolean;
+        lifecycle: {
+            root_turn_terminal: boolean;
+            owned_tasks_settled: boolean;
+            mission_phase: string | null;
+            mission_accepted: boolean;
+        };
         sessions: readonly JsonObject[];
     }>;
     private stopHosts;
@@ -85,6 +91,7 @@ export declare class CodexMissionSession {
     private restoreSession;
     private tools;
     private prompt;
+    private promptTurn;
     private execute;
 }
 export {};

package/dist/codex/mission-session.js

@@ -72,8 +72,11 @@ export class CodexMissionSession {
         const previous = await new OperatorMissionRuntime(this.directory, profile).read(session.id);
         const turn = await this.prompt(session, prompt);
         const mission = await new OperatorMissionRuntime(this.directory, profile).read(session.id);
-        return { rootSessionID: session.id, turn, accepted: turn.status === "completed" && mission?.phase === "completed" &&
-                (previous?.phase !== "completed" || previous.id !== mission.id), sessions: [...this.sessions.values()].map(item => ({ thread_id: item.id, agent: item.agent, model: item.model, usage: item.usage ?? null, usage_scope: "native-thread-cumulative", cost: null })) };
+        const ownedTasksSettled = [...this.sessions.values()].every(item => !["running", "unknown"].includes(item.outcome));
+        const accepted = turn.status === "completed" && ownedTasksSettled && mission?.phase === "completed" &&
+            (previous?.phase !== "completed" || previous.id !== mission.id);
+        return { rootSessionID: session.id, turn, accepted, lifecycle: { root_turn_terminal: ["completed", "failed", "interrupted", "cancelled"].includes(turn.status),
+                owned_tasks_settled: ownedTasksSettled, mission_phase: mission?.phase ?? null, mission_accepted: accepted }, sessions: [...this.sessions.values()].map(item => ({ thread_id: item.id, agent: item.agent, model: item.model, usage: item.usage ?? null, usage_scope: "native-thread-cumulative", cost: null })) };
     }
     async stopHosts() {
         this.closed = true;
@@ -459,11 +462,33 @@ export class CodexMissionSession {
         return tools;
     }
     async prompt(session, prompt, onDispatch) {
+        let result = await this.promptTurn(session, prompt, onDispatch);
+        while (result.status === "completed" && result.deferredToolResults?.length) {
+            if (this.closed)
+                throw new Error("Codex Mission adapter is closed.");
+            const mission = await new OperatorMissionRuntime(this.directory, profile).read(this.rootOf(session));
+            if (!mission || ["completed", "cancelled"].includes(mission.phase))
+                break;
+            await this.claimOwner(this.rootOf(session));
+            await this.options.onEvent?.({ method: "sortie/continuation", threadId: session.id,
+                params: { turnId: result.turnID, phase: "owned-tools-settled", calls: result.deferredToolResults.map(item => ({ callId: item.callID, tool: item.tool, success: item.success })) } });
+            result = await this.promptTurn(session, "The previous native response ended while existing host tools were still running. Those exact calls have now returned:\n" +
+                JSON.stringify(result.deferredToolResults) +
+                "\nContinue this same Mission from these results through the remaining validation, delivery, review and root acceptance. " +
+                "Do not resend the original request or redispatch the completed Tasks. Preserve failures, ownership and cumulative budget; use existing Mission status for the next action.", undefined, true);
+        }
+        return result;
+    }
+    async promptTurn(session, prompt, onDispatch, continuation = false) {
         const startedAt = Date.now();
         const messageID = randomUUID();
         const message = { id: messageID, agent: session.agent, model: { ...session.model } };
-        const parts = [{ type: "text", text: prompt }];
-        await this.hooks["chat.message"]?.({ sessionID: session.id, messageID, agent: session.agent }, { message, parts });
+        const parts = [{ type: "text", text: prompt, ...(continuation ? { synthetic: true } : {}) }];
+        // Only this host's drained results can continue an already-admitted execution.
+        // Reclaiming that Task with the result prompt rejects Workers' exact handoff;
+        // treating it as a real root request also grants spurious user-turn authority.
+        if (!continuation)
+            await this.hooks["chat.message"]?.({ sessionID: session.id, messageID, agent: session.agent }, { message, parts });
         // Shared Task routing may select a model; explicit adapter overrides still govern every native turn.
         if (message.model.providerID !== "openai")
             throw new Error("Codex Mission cannot use a non-OpenAI model route.");

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;

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 ?? [])}`,
@@ -932,6 +936,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

@@ -268,6 +268,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)

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";
@@ -610,6 +610,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 +676,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 +1175,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 +2224,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 +2332,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 +2352,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 +2401,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 +2447,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 +2460,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 +2620,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 } : {}) });
@@ -2936,17 +3019,20 @@ 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;
                     });

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.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
@@ -470,11 +475,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 +506,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
@@ -659,8 +671,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.21",
+  "version": "0.14.0",
   "description": "Bounded agent harness and validated orchestration loop plugin for OpenCode",
   "keywords": [
     "opencode",