sortie-dogs 0.13.3 → 0.13.4

package/README.md

@@ -35,6 +35,11 @@ implementation, validation, review, and model routing.
 Guides: [日本語](docs/guide-ja.md) · [简体中文](docs/guide-zh-CN.md) ·
 [Testing](docs/testing.md) · [CLI testing](docs/cli-testing.md)
 
+**Current release: [v0.13.4](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.13.4)**
+([release notes](docs/release-v0.13.4.md)). The default Mission runtime retains the `v010`
+profile, command and configuration names for compatibility; these names do not mean v0.10 is installed.
+The current asset marker is `0.13.4-reviewer-continuous-v1`.
+
 ## SWE-bench Lite: 170/300 (56.67%)
 
 The fixed **Sortie-dogs v0.12.24** harness resolved **170 of 300 SWE-bench Lite test issues** in one pass@1 campaign, with 9 empty patches and no official evaluation errors. Every instance has a frozen prediction and an inference-time trajectory. The task Workers ran `openai/gpt-6-luna-fast#max`; operator, coordinator and review roles ran `openai/gpt-6-sol#xhigh`. This is a system result, **not** a Luna-only model comparison or a Verified/full SWE-bench score.
@@ -43,22 +48,25 @@ The fixed **Sortie-dogs v0.12.24** harness resolved **170 of 300 SWE-bench Lite
 
 The single official 300-instance report and frozen predictions are hash-bound in the report. Confirmed inference expense was **$162.99**; a separate **$34.60** of usage has unknown pricing and is held against the campaign cap, **not** counted as known expense. Leaderboard registration and maintainer acceptance are separate from this official local evaluation.
 
-> **Beta:** v0.12.2 builds on the v0.10.23 execution engine. Runtime behavior,
+Historical scores below belong to their fixed candidates, not v0.13.4. SWE-bench is a separate,
+optional measurement rather than a mandatory release gate.
+
+> **Beta:** v0.13.x is still stabilizing. Runtime behavior,
 > configuration, and generated assets may still change before 1.0.
 
 ## Quick start
 
-Requirements: Node.js 22.6 or newer, npm, and OpenCode.
+Requirements: Node.js 22.6 or newer, npm, and OpenCode V2.
 
 Run these commands in the target project:
 
 ```sh
-npm install --save-dev sortie-dogs
+npm install --save-dev sortie-dogs@latest
 npx sortie-dogs init .
 ```
 
-The package retains the `v010` profile/namespace for compatibility. `init` adds the OpenCode V2 plugin and the required
-two-level subagent depth to `.opencode/opencode.json(c)`, preserving existing settings:
+`init` defaults to the `v010` Mission profile and registers the OpenCode V2 plugin in
+`.opencode/opencode.json(c)`, preserving unrelated settings. It sets subagent depth to at least two:
 
 ```json
 {
@@ -67,51 +75,72 @@ two-level subagent depth to `.opencode/opencode.json(c)`, preserving existing se
 }
 ```
 
-Restart OpenCode, then run:
+If an existing local bridge already imports `sortie-dogs/server`, `init` reuses it instead of adding
+a duplicate package entry. A larger existing subagent depth is retained.
+
+Completely restart OpenCode, then run:
 
 ```text
 /sortie-v010 <task>
 ```
 
 Selecting `dog-operator` directly starts the same workflow. `dog-operator` is the
-only user-facing v0.10 authority. `dogs-coordinator` and every `*-v010` role are
+user-facing entry point for the Mission profile. `dogs-coordinator` and every `*-v010` role are
 internal children and must not be selected as task entry points.
 
-`init` installs runtime assets and merges the required OpenCode settings; the `plugins` entry loads runtime enforcement and
-model routing. A new session alone does not reload an updated
-plugin process, so restart OpenCode after installation or upgrade.
+`init` installs runtime assets and merges the required OpenCode settings; the package entry or
+existing local bridge loads enforcement and model routing. OpenCode can reload watched configuration,
+but replacing an installed dependency may require a full restart. A new chat session alone does not
+prove the newly installed plugin is loaded.
+
+## v0.13.4 runtime updates
 
-## v0.13.3 runtime updates
+PR #152 restores same-session Coordinator/Operator implementation and formal validation through
+`plan_units(executor="self")`, `start_direct_unit` and `finish_direct_unit`. Known single-unit work can
+combine Mission start and planning; Luna Fast/max Worker routing remains the default. Full generated
+contracts remain visible when an explicit Read line range covers the file. Native background
+responsiveness remains: a launch acknowledgement or idle root is not Mission completion.
 
-The current release integrates native background Mission execution, concise authoritative Worker
-handoffs, and same-context Reviewer corrections from PRs #148/#149 and their Ubuntu remediation.
-After finding defects, the original Reviewer can correct and explicitly self-recheck in the same
-native session, retaining formal checks, current-source evidence, Git delivery and cumulative budget.
-Author self-recheck is recorded as non-independent; a different Reviewer is conditional on a concrete
-reachable residual Major risk. Unresolved Major or Medium findings still block acceptance.
+The initial independent Reviewer can investigate, correct, formally validate, deliver and self-recheck
+continuously in its original native Task. Later Major/Medium findings accumulate in that same correction
+context. Author self-recheck remains `self-rechecked`, `independent=false`, never independent `PASS`.
+A different Reviewer is conditional on concrete residual Major risk; unresolved Major/Medium findings
+still block acceptance. Operator owns final comparison and receipt.
 
-The installed native correction fixture succeeded, but the original Anko measurements remain
-unaccepted, including the latest 25-minute run. This release does not claim general speedup,
-original-task completion or a new SWE-bench score. See the [release notes](docs/release-v0.13.3.md)
-and [retained implementation and measurement history](docs/anko-pr149-ubuntu-handoff.md).
+Inherited compiler scratch no longer falsely invalidates broad-scope formal proof. Host-observed Git
+delivery, caller-setting review and test-composition guidance reduce avoidable detours. Saved host
+completion cards remain in tool history/UI, while outgoing V2 model/compaction context omits only their
+presentation body, retaining receipt and evidence identities.
 
-## v0.12.0 workflow
+Two runs of the same fixed pre-release v8 package completed the original Anko task with official local
+score 1 (F2P 9/9, P2P 94/94) and selected public probes 9/9. Times were 26m49s and 25m55s, costs
+$1.47908048 and $1.54610816; each saved more than seven minutes versus the recorded v5 sample.
+These limited same-task observations do not establish general speedup or a new SWE-bench score.
+Release preflight, full tests, fixed-commit Windows CI and native Worker-start receipts are retained in
+`_testenv/releases/0.13.4/`; startup/model identity is not task completion. See the
+[release notes](docs/release-v0.13.4.md) and [quality-loop evidence](docs/nightly-quality-loop-20261002.md).
 
-v0.12.0 keeps Operator → Coordinator → Worker, with independent review:
+## Mission workflow
+
+Use Operator → Worker when one useful unit and its meaningful formal check are known;
+use Operator → Coordinator → Worker for actual discovery or decomposition:
 
 - `dog-operator` states a few requirements/negative constraints and owns user decisions and final acceptance.
   The host saves the original user message verbatim.
 - Hidden `dogs-coordinator` owns investigation, unit declarations, Worker/Scout/Advisor/Reviewer dispatch,
   in-request write-scope extensions, and corrections. It can read/search and run confirmation shell commands;
-  source editing tools belong to Worker.
+  it can implement and formally validate directly in its own session, or delegate a unit to Worker.
 - `dog-worker-v010` implements a host-generated unit within its file/directory write scopes.
   Investigation commands need no pre-registration; formal checks retain real host-recorded results.
-- High-risk changes require an independent Reviewer. Low-risk skips are explicit and recorded.
-- Simple low-risk single-unit work retains Operator → Worker Fast-lane dispatch.
+- High-risk changes require an initial independent Reviewer with read/search access. Low-risk skips
+  are explicit and recorded. Reviewer-owned corrections follow the self-recheck policy above.
+- Fast-lane can include high-risk single-unit work; it never implies a review skip.
+- Investigation, edits, formal checks and requested Git delivery stay in the same implementing child.
+  Explicit user ordering is retained; no routine plan-approval or commit-only handoff is needed.
 - Unit progress appears on the running Task without stopping Coordinator or prompting Operator.
 
-The v0.10 profile is serial by design. The stable profile's Luna fabric and
-parallel integration path are not exposed in this profile. More agents are not a
+The `v010` Mission profile is serial by design; background responsiveness does not add parallel writers.
+The stable profile's Luna fabric and parallel integration path are not exposed in this profile. More agents are not a
 goal; preserving quality while reducing unnecessary expensive work is.
 
 ### SWE-bench evaluation
@@ -186,32 +215,51 @@ astroid **3/5**, pyvista **0/1**, sqlfluff **1/5**.
 
 ## Mission tools
 
-1. `start_mission`: Operator supplies concise requirements; the host saves original messages and returns a Coordinator task.
-2. `plan_units`: Coordinator supplies title, objective, file/directory scopes and formal checks. The host generates
-   IDs, handoff, manifest, proof mapping and the ready Worker task. No proposal approval round trip.
-3. `operator_next`: advance serial units. `expand_unit` or a reasoned `plan_units` correction extends/replaces
-   settled execution within the original requirements and retained cumulative budget.
+1. `start_mission`: Operator supplies concise requirements; the host saves original messages. A known single unit
+   can include `unit` to combine start/planning and return its configured Worker task.
+2. `plan_units`: Operator or Coordinator supplies title, objective, file/directory scopes and formal checks. The host generates
+   IDs, handoff, manifest, proof mapping and the ready Worker task. `executor="self"` keeps execution in the
+   same controller session; `start_direct_unit` / `finish_direct_unit` retain observed formal-check freshness.
+3. `operator_next`: advance serial units. `expand_unit` reconciles required in-request outputs while
+   preserving the same Task. A reasoned `plan_units` correction or `retry_mission_unit` handles ordinary
+   unit recovery under the original requirements and cumulative budget.
 4. `review_mission`: generate the independent review packet from source, requirements and observed checks;
    dispatch its Reviewer task for high-risk changes or record a low-risk skip.
-5. `submit_mission`: Coordinator returns a completion candidate, user-only decision, or proven external/scope/budget blocker.
-6. `complete_mission`: Operator compares the original request, source and evidence, then explicitly accepts.
+5. `repair_review`: record findings and continue correction in the running original Reviewer Task, or resume
+   that same native session. Later findings accumulate; run inherited checks/requested Git delivery and
+   explicitly report `SELF_RECHECKED` in that same Task. Legacy
+   `CORRECTION_READY` alone requires a same-author read-only fallback through `review_mission`.
+6. `submit_mission`: Coordinator returns a completion candidate, user-only decision, or proven external/scope/budget blocker.
+7. `complete_mission`: Operator compares the original request, source and evidence, then explicitly accepts.
    Only a succeeded receipt authorizes DONE and the measured 🐾 return report.
 
 All tool names use the `sortie_v010_` prefix. Prior proposal/plan-repair tools remain in the compatibility
-implementation but are hidden from the normal v0.12 model tool list. An in-request path extension is a
-Coordinator decision; changing the original requirements or increasing budget returns to Operator/user.
+implementation but are hidden from the normal Mission tool list. Operator/Coordinator handle in-request
+path reconciliation without a new user approval. Changes beyond the original requirements or cumulative
+budget return to Operator/user. `EVIDENCE_GAPS` is an advisory limitation, not Review `PASS` or an
+automatic extra review; failed or missing required checks still prevent acceptance.
 
 Durable profile state and hash-bound task references support restart and
 compaction recovery without reconstructing criteria from summary prose. Stale,
-foreign-root, or changed references are rejected. An optional Git lifecycle can
-create one non-overwriting branch and one explicit-path commit; it never grants
-arbitrary Git, force push, release, or publication authority.
+foreign-root, or changed references are rejected. Requested `git add <paths>` and `git commit -m ...`
+use the actual source write scope, not a fabricated `.git/**` scope. An optional host-managed Git
+lifecycle also retains its branch, commit and post-commit boundaries. Neither mode grants arbitrary
+Git, force push, release or publication authority.
+
+### Progress and acceptance evidence
+
+`sortie_v010_operator_status` keeps original requests, formal command/exit/timing observations,
+review disposition and recorded delivery in a compact Mission view. `{ "view": "progress" }` exposes
+the current unit, completed/total units, host budget and next action; `{ "view": "full" }` or
+`details_ref` provides full snapshot diagnostics. Unknown clean state or a failed commit is not delivery
+success. Reading progress does not dispatch, retry or accept work; use native completion notifications
+instead of polling. Existing status reconciliation can recover a missed child terminal event.
 
 ## Configuration
 
 ### Profile files and precedence
 
-The default package entry is the v0.10 profile:
+The default package entry is the `v010` Mission profile:
 
 - Command: `/sortie-v010`
 - Primary agent: `dog-operator`
@@ -221,9 +269,11 @@ The default package entry is the v0.10 profile:
 - Runtime state: `.sortie-dogs-v010/`
 - Installed asset marker: `.opencode/sortie-dogs-v010.version`
 
+For a global install, the marker is `<OpenCode config root>/sortie-dogs-v010.version`.
+
 Precedence is built-in defaults, global file, project file, environment JSON,
 then plugin factory options. Unknown properties or invalid types are rejected.
-Use external v0.10 role names such as `dog-operator`, `dogs-coordinator`, and
+Use external `v010` role names such as `dog-operator`, `dogs-coordinator`, and
 `dog-reviewer-v010` in `modelRouting`; do not also declare their stable aliases.
 
 Example `.opencode/sortie-dogs-v010.json`:
@@ -266,8 +316,8 @@ not invent, probe, or translate variant names.
 - `freeTierFallbackModels`: ordered global last-resort model IDs. Default:
   `opencode/deepseek-v4-flash-free`; `[]` disables this fallback.
 - `dedicatedWorkerModel`: canonical stable serial target, default
-  `openai/gpt-6.1-sol` / `medium`. The v0.10 profile also supplies its explicit
-  role routes below; do not infer the v0.10 worker route from this stable setting.
+  `openai/gpt-6.1-sol` / `medium`. The Mission profile supplies its explicit
+  role routes below; do not infer its Worker route from this stable setting.
 - `consultation.strategy`: fixed advisor identity, optional `required`, and
   positive `maxCallsPerCandidate`; default one call and not required.
 - `consultation.sourceReview`: risk-based review with `maxCallsPerCandidate`
@@ -281,27 +331,35 @@ not invent, probe, or translate variant names.
 - `continuation.summarizeModel`: optional explicit compaction model; omission
   reuses the latest observed root model.
 - `validationProfile`: `fast`, `balanced`, or `assurance`; default `balanced`.
-- `reflection`: accepted by the shared schema, but reflection writes are not
-  exposed by the serial v0.10 profile. Stable reflection remains opt-in and off by
-  default.
+- `reflection`: enabled by default for `run`, `project` and `global` layers, with at most three
+  entries / 500 estimated tokens injected. Root Operator can use `sortie_v010_reflection` to retain
+  verified process causes/preventions for later turns and sessions; this is not model training.
+  Storage and managed blocks are separate from stable. Set `reflection.enabled` to `false` to disable.
 
-The v0.10 host owns handoff and manifest controls under
+The Mission host owns handoff and manifest controls under
 `.sortie-dogs-v010/contracts/`. Do not create a legacy root
 `operation-manifest.json` for this profile and do not edit generated controls.
 Delete `.sortie-dogs-v010/` only when no Sortie run is active.
 
 ### Validation policy
 
-`validationProfile` chooses non-canonical depth:
+`validationProfile` chooses supplementary non-canonical depth:
 
 - `fast`: static checks
 - `balanced`: targeted checks
 - `assurance`: related checks
 
-Canonical proof remains canonical. Full-suite execution requires release context
-or explicit risk. Workers own static, targeted, and related checks; the root owns
-canonical and full-suite checks. An unchanged candidate, command, and environment
-reuse the same evidence instead of spending the validation budget again.
+It does not replace meaningful declared formal checks or user/project-required broad validation.
+Batch related edits, run focused checks, then execute every declared formal check in order on the
+stable candidate. The implementing Worker or admitted correcting Reviewer runs those commands;
+canonical/full-suite `owner=coordinator` is evidence accounting, not a requirement for root execution.
+
+Keep required broad checks for the final integrated candidate. Reuse valid unchanged evidence only
+when the contract permits; identity includes candidate, command, environment, scope and owner.
+Required repeated occurrences retain their own execution identities and cannot be skipped as duplicates.
+Native commands, actual working directory, exit, duration and saved source bindings establish freshness.
+Diagnostics do not substitute for formal proof. Repeat checks when changes, failures or freshness require
+it, rather than solely because a Worker changed or documentation was edited.
 
 ### Default routes
 
@@ -332,25 +390,40 @@ export { SortieDogsPlugin } from "sortie-dogs/plugin/stable";
 
 The stable profile uses `/sortie`, `dog-coordinator`,
 `.opencode/sortie-dogs.json`, `SORTIE_DOGS_CONFIG`, and `.sortie-dogs/`. Do not
-register stable and v0.10 from the same package installation path in one host.
+register stable and `v010` from the same package installation path in one host.
 
 ## Global availability
 
-Project-local installation is recommended. To expose v0.10 assets globally:
+Project-local installation is recommended. To expose the current Mission assets globally:
+
+```sh
+npm install --global sortie-dogs@0.13.4
+sortie-dogs init --global --profile v010
+```
+
+Global initialization registers the package or reuses an existing local V2 bridge, and sets subagent
+depth to at least two, preserving unrelated settings and the default agent.
+
+An existing `<OpenCode config root>/plugins/sortie-dogs/index.js` bridge importing `sortie-dogs/server`
+can resolve a **separate dependency** under that config root. Updating npm-global alone does not update
+it. For that layout, also install the same release at the actual config root, then rerun global init:
 
 ```sh
-npm install --global sortie-dogs
+npm install --prefix "$HOME/.config/opencode" sortie-dogs@0.13.4
 sortie-dogs init --global --profile v010
 ```
 
-Global initialization also merges `sortie-dogs` and `experimental.subagent_depth: 2` into the
-global OpenCode config, preserving unrelated settings and the default agent.
+The command shows the default config root; use your actual root if overridden. For a configured npm
+package entry, OpenCode V2 also provides `opencode plugin list` / `opencode plugin update`; exact
+version pins require an explicit version change. Completely restart OpenCode after updating, then
+check the installed package, asset marker and loaded plugin version.
 
 ## Updates and removal
 
-After replacing the dependency, rerun initialization and restart OpenCode:
+For project-local updates, replace the dependency, rerun initialization and completely restart OpenCode:
 
 ```sh
+npm install --save-dev sortie-dogs@latest
 npx sortie-dogs init .
 ```
 
@@ -358,6 +431,10 @@ npx sortie-dogs init .
 version, preserves user configuration, and stops safely on unknown ownership or
 conflicting files.
 
+Align any exact version pin or separate bridge dependency with the intended release too. An installed
+marker of `0.13.4-reviewer-continuous-v1` identifies the assets; it does not prove an already-running
+OpenCode process has reloaded the plugin.
+
 There is no supported uninstall command. Remove the npm dependency separately,
 then follow the [safe manual removal guide](docs/uninstall.md). Delete only known
 Sortie-owned paths; never remove the whole `.opencode` directory or use broad

package/dist/asset-version.d.ts

@@ -3,5 +3,5 @@
  * installed project marker without importing every asset body.
  */
 export declare const RUNTIME_ASSET_VERSION = "0.3.89-completion-proof-v1";
-export declare const V010_RUNTIME_ASSET_VERSION = "0.13.3-reviewer-context-v1";
+export declare const V010_RUNTIME_ASSET_VERSION = "0.13.4-reviewer-continuous-v1";
 export type RuntimeAssetVersion = typeof RUNTIME_ASSET_VERSION | typeof V010_RUNTIME_ASSET_VERSION;

package/dist/asset-version.js

@@ -3,4 +3,4 @@
  * installed project marker without importing every asset body.
  */
 export const RUNTIME_ASSET_VERSION = "0.3.89-completion-proof-v1";
-export const V010_RUNTIME_ASSET_VERSION = "0.13.3-reviewer-context-v1";
+export const V010_RUNTIME_ASSET_VERSION = "0.13.4-reviewer-continuous-v1";

package/dist/core/contract-limits.d.ts

@@ -6,7 +6,8 @@ export declare const CONTRACT_TEXT_LIMITS: Readonly<{
     command: 8192;
     path: 512;
 }>;
-/** New Mission task generation only; persisted/legacy contracts retain their original bounds. */
+/** New Mission task generation only; persisted/legacy contracts retain their original bounds.
+ * Only target is authoring guidance. maximum is internal headroom, never a new target. */
 export declare const MISSION_OBJECTIVE_LIMITS: Readonly<{
     target: 2000;
     maximum: 3000;

package/dist/core/contract-limits.js

@@ -1,4 +1,5 @@
 /** Common text bounds shared by handoff, manifest and goal evidence validation. */
 export const CONTRACT_TEXT_LIMITS = Object.freeze({ title: 160, objective: 32768, statement: 1000, command: 8192, path: 512 });
-/** New Mission task generation only; persisted/legacy contracts retain their original bounds. */
+/** New Mission task generation only; persisted/legacy contracts retain their original bounds.
+ * Only target is authoring guidance. maximum is internal headroom, never a new target. */
 export const MISSION_OBJECTIVE_LIMITS = Object.freeze({ target: 2000, maximum: 3000 });

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

@@ -44,7 +44,7 @@ export interface MissionAttempt {
     predecessorAttemptID?: string | null;
     /** Fingerprint of the settled scoped candidate against which a later Rescue is proposed. */
     candidateID?: string;
-    kind: "implementation" | "normal_remediation" | "astra_rescue" | "reviewer_correction";
+    kind: "implementation" | "normal_remediation" | "astra_rescue" | "reviewer_correction" | "direct_execution";
     status: "pending" | "dispatched" | "succeeded" | "failed" | "cancelled" | "unconfirmed";
     callID?: string;
     childSessionID?: string;
@@ -151,6 +151,15 @@ export interface OperatorMission {
     runID: string | null;
     /** Git HEAD before this mission's first implementation unit, retained across replans and commits. */
     reviewBaseline?: string;
+    /** A dated host Git observation, never an inference from a Worker report or lifecycle plan. */
+    deliveryObservation?: {
+        run_id: string;
+        observed_at: string;
+        head: string | null;
+        branch: string | null;
+        clean: boolean;
+        source: string;
+    };
     /** Cumulative declared review inputs/outputs, including units that failed after writing source. */
     reviewScope?: MissionReviewScope;
     /** Optional Advisor/Scout decisions and native consultation outcomes; never an admission gate. */
@@ -203,6 +212,13 @@ export interface OperatorMission {
         findings: string;
         initialPrompt: string;
         baseline?: string;
+        /** Actual still-running initial Review; direct correction is not another child terminal. */
+        inlineReview?: {
+            callID: string;
+            promptID: string;
+            admittedAt: number;
+            reviewIdentity: string;
+        };
         status: "prepared" | "running" | "ready" | "failed" | "cancelled";
         selfRecheck?: MissionSelfRecheck;
     }[];

package/dist/core/operator-mission.js

@@ -413,8 +413,8 @@ export class OperatorMissionRuntime {
     }
     brief(state) {
         return [`mission_id: ${state.id}`, `project_root: ${this.projectRoot}`, "Use the user's language below for all replies and Task titles.",
-            "Own investigation, unit declarations, Worker/Scout/Advisor/independent Reviewer dispatch, scope extensions and corrections.",
-            "Start the first useful Worker promptly. No proposal/approval phase. Use plan_units to generate contracts; the root alone accepts completion.",
+            "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.",
             "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 ?? [])}`,
@@ -508,7 +508,9 @@ export async function missionAcceptanceSummary(mission, run, operators, observe)
             return [];
         return (unit.evidence ?? []).map(proof => ({ run_id: state.runID, unit_id: unit.unit.id,
             task_id: unit.task.prompt.match(/^task_id: (.+)$/mu)?.[1] ?? null,
-            worker_session_id: unit.childSessionID, state_archive_path: path, handoff_path: unit.handoffPath,
+            worker_session_id: unit.directExecution ? null : unit.childSessionID,
+            ...(unit.directExecution ? { execution_mode: "direct", executor_session_id: unit.directExecution.actor } : {}),
+            state_archive_path: path, handoff_path: unit.handoffPath,
             ...(anchor ? { accepted_anchor: anchor } : {}), evidence_id: proof.evidence_id,
             command: proof.execution.command, exit: proof.execution.exit_code, outcome: proof.execution.outcome,
             started_at: proof.execution.started_at, ended_at: proof.execution.ended_at,
@@ -534,7 +536,8 @@ export async function missionAcceptanceSummary(mission, run, operators, observe)
         try {
             if (!observe || !unit.childSessionID)
                 throw new Error("native-worker-history-unavailable");
-            return { ...provenance, status: "available", observations: await observe(unit.unit.validation, unit.childSessionID, unit.reviewerCorrection ? Date.parse(unit.reviewerCorrection.admittedAt ?? item.state.createdAt) : undefined) };
+            return { ...provenance, status: "available", observations: await observe(unit.unit.validation, unit.childSessionID, unit.directExecution ? Date.parse(unit.directExecution.startedAt) :
+                    unit.reviewerCorrection ? Date.parse(unit.reviewerCorrection.admittedAt ?? item.state.createdAt) : undefined) };
         }
         catch (error) {
             return { ...provenance, status: "unavailable", reason: error instanceof Error ? error.message : String(error) };
@@ -554,8 +557,9 @@ export async function missionAcceptanceSummary(mission, run, operators, observe)
             verdict: mission.review.verdict, result: mission.review.result ?? null, self_recheck: mission.review.selfRecheck ?? null,
             freshness: "not established by run ID; existing source comparison remains required" } : null,
         delivery: { submission: mission.submission, git_lifecycle: current?.gitLifecycle ?? null,
+            observation: mission.deliveryObservation && mission.deliveryObservation.run_id === current?.runID ? mission.deliveryObservation : null,
             observation_source: "persisted operator Git lifecycle and formal validation records; no new Git inspection",
-            clean: "not independently observed by this projection" },
+            clean: mission.deliveryObservation && mission.deliveryObservation.run_id === current?.runID ? mission.deliveryObservation.clean : "not independently observed by this projection" },
         interpretation: "Compare original requests with the submitted candidate and actual evidence. Historical PASS is not current PASS. Inspect concrete gaps, not routine archive searches or full source rereads. Existing completion and Review guards still apply." };
 }
 export function missionReviewIndependent(mission, child) {
@@ -575,7 +579,8 @@ export function missionPacket(mission, run) {
                 note: "Historical results and spend are retained; they do not complete the current requirements." } } : {}),
         requirements: mission.requirements, original_request_refs: mission.requests.map(item => `user:${item.id}`),
         launch_conditions: mission.launchConditions ?? [], prohibited_write: mission.prohibitedWrite ?? [],
-        accounting_scope: "Implementation units (Worker or scoped Reviewer correction) are not benchmark attempts. Host budget uses the existing Worker-unit ledger; orchestration, read-only Review and external campaign costs are excluded. Launch caps are fixed conditions, not a known campaign remainder.",
+        accounting_scope: "Implementation units (Worker, direct controller execution or scoped Reviewer correction) are not benchmark attempts. Host budget uses the existing unit ledger; orchestration, read-only Review and external campaign costs are excluded. Launch caps are fixed conditions, not a known campaign remainder.",
+        delivery_observation: mission.deliveryObservation?.run_id === (run?.runID ?? mission.runID) ? mission.deliveryObservation : null,
         submission: mission.submission, progress: mission.progress, consultations: mission.consultations ?? [],
         attempts: mission.attempts ?? [], corrections: (mission.corrections ?? []).map(({ findings: _findings, initialPrompt: _prompt, ...item }) => item), ...(mission.rescue ? { rescue: mission.rescue } : {}),
         operation: { kind: mission.kind ?? "implementation", status: missionExecutionStatus(mission),

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

@@ -123,6 +123,13 @@ interface UnitState {
         checks?: import("../plugin/runtime-bridge.js").ReviewerCorrectionCheck[];
     };
     evidence: readonly GoalEvidence[];
+    /** Implementation in the existing controller session, without a native child Task. */
+    directExecution?: {
+        actor: string;
+        startedAt: string;
+        finishedAt?: string;
+        checks: import("../plugin/runtime-bridge.js").ReviewerCorrectionCheck[];
+    };
     resultClass: string | null;
     failure?: SerialDispatchSettlement["failure"];
     normalRemediationUsed?: boolean;
@@ -345,6 +352,9 @@ export declare class OperatorRuntime {
     next(root: string, actor: string): Promise<unknown>;
     private nextOnce;
     admitWorker(root: string, actor: string, callID: string, args: unknown): Promise<OperatorTask>;
+    admitDirect(root: string, actor: string, callID: string): 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;
     rejectedAdmission(root: string, callID: string, reason?: string): Promise<void>;
     rejectDispatch(root: string, callID: string, decision?: string): Promise<void>;

package/dist/core/operator-runtime.js

@@ -741,10 +741,11 @@ export class OperatorRuntime {
         return this.serial(root, async () => {
             const state = await this.required(root);
             const unit = state.units.find(item => /^task_id: (.+)$/mu.exec(item.task.prompt)?.[1] === taskID);
-            if (!unit?.reviewerCorrection || unit.callID !== check.dispatchCallID || unit.childSessionID !== check.childSessionID ||
-                unit.reviewerCorrection.author !== check.childSessionID)
+            const execution = unit?.reviewerCorrection ?? unit?.directExecution;
+            if (!unit || !execution || unit.callID !== check.dispatchCallID || unit.childSessionID !== check.childSessionID ||
+                (unit.reviewerCorrection?.author ?? unit.directExecution?.actor) !== check.childSessionID)
                 throw new Error("mission-review-correction-check-owner-mismatch");
-            const checks = unit.reviewerCorrection.checks ??= [];
+            const checks = execution.checks ??= [];
             if (checks.some(item => item.callID === check.callID))
                 return;
             checks.push(structuredClone(check));
@@ -838,7 +839,7 @@ export class OperatorRuntime {
             throw new Error("mission-superseded-run-mismatch");
         const terminalChildren = mission?.terminalChildren ?? [];
         const retainAcceptance = previous !== undefined && cancelledMissionRetainsAcceptance(previous);
-        const predecessorChildren = previous?.units.flatMap(unit => unit.childSessionID !== null
+        const predecessorChildren = previous?.units.flatMap(unit => !unit.directExecution && unit.childSessionID !== null
             ? [unit.childSessionID] : []) ?? [];
         if (superseding && previous && (!replacingFailedAcceptance && !["explicit-cancellation", "agent-changed"].includes(previous.decision ?? "") || previous.gitLifecycle !== null ||
             previous.repairResidualPaths.length > 0 || previous.contractRepair !== null ||
@@ -866,7 +867,7 @@ export class OperatorRuntime {
         const parent = replanning ? { ...previous, phase: "cancelled", decision: "mission-replan" }
             : (!superseding || (retainAcceptance && !mission?.replaceRequirements)) && previous?.phase === "cancelled" ? previous : undefined;
         if (parent && ["explicit-cancellation", "agent-changed"].includes(parent.decision ?? "")) {
-            const cancelled = parent.units.flatMap(unit => (parent.decision === "agent-changed" || unit.status === "cancelled") && unit.childSessionID !== null
+            const cancelled = parent.units.flatMap(unit => !unit.directExecution && (parent.decision === "agent-changed" || unit.status === "cancelled") && unit.childSessionID !== null
                 ? [unit.childSessionID] : []);
             if (cancelled.length > 0 && (new Set(terminalChildren).size !== terminalChildren.length ||
                 cancelled.some(id => !terminalChildren.includes(id)))) {
@@ -1337,6 +1338,48 @@ export class OperatorRuntime {
     admitWorker(root, actor, callID, args) {
         return this.serial(root, () => this.admitWorkerOnce(root, actor, callID, args));
     }
+    admitDirect(root, actor, callID) {
+        return this.serial(root, async () => {
+            const state = await this.required(root);
+            if (actor !== (state.operatorSessionID ?? root) || !["prepared", "running"].includes(state.phase)) {
+                throw new Error("operator-direct-owner-mismatch");
+            }
+            const unit = state.units.find(item => item.status !== "succeeded");
+            if (!unit || unit.status !== "pending" || unit.reviewerCorrection || unit.repairValidation || unit.terminalRescue) {
+                throw new Error("operator-direct-unit-unavailable");
+            }
+            await this.verifyControls(unit);
+            unit.directExecution = { actor, startedAt: new Date().toISOString(), checks: [] };
+            unit.childSessionID = actor;
+            unit.callID = callID;
+            unit.status = "running";
+            state.phase = "running";
+            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 () => {
+            const state = await this.required(root);
+            const unit = state.units.find(item => item.status !== "succeeded");
+            if (state.phase !== "prepared" || !unit || unit.status !== "pending" ||
+                unit.reviewerCorrection?.author !== author || !promptID || unit.repairValidation || unit.terminalRescue) {
+                throw new Error("mission-review-direct-unit-unavailable");
+            }
+            await this.verifyControls(unit);
+            const startedAt = new Date().toISOString();
+            unit.directExecution = { actor: author, startedAt, checks: [] };
+            unit.reviewerCorrection.admittedAt = startedAt;
+            unit.reviewerCorrection.promptID = promptID;
+            unit.childSessionID = author;
+            unit.callID = callID;
+            unit.status = "running";
+            state.phase = "running";
+            await this.save(state);
+            return state;
+        });
+    }
     async admitWorkerOnce(root, actor, callID, args) {
         const state = await this.required(root);
         if (actor !== state.operatorSessionID && !(actor === root && state.units.length === 1 && state.operatorSessionID === null))
@@ -1709,6 +1752,8 @@ export class OperatorRuntime {
         else
             delete unit.failure;
         unit.status = result.disposition;
+        if (unit.directExecution)
+            unit.directExecution.finishedAt = new Date().toISOString();
         if (unit.terminalRescue) {
             unit.terminalRescue.status = "settled";
             unit.terminalRescue.disposition = result.disposition;
@@ -1873,10 +1918,14 @@ export class OperatorRuntime {
         else if (state.decision !== ACCEPTANCE_REMEDIATION_DECISION)
             state.decision = reason;
         for (const unit of state.units)
-            if (unit.status === "running")
+            if (unit.status === "running") {
                 unit.status = "cancelled";
+                if (unit.directExecution)
+                    unit.directExecution.finishedAt = new Date().toISOString();
+            }
         await this.save(state);
-        return [state.operatorSessionID, ...state.units.map(unit => unit.childSessionID)].filter((id) => id !== null);
+        return [state.operatorSessionID, ...state.units.filter(unit => !unit.directExecution).map(unit => unit.childSessionID)]
+            .filter((id) => id !== null && id !== root);
     }
     terminal(root, receipt) {
         return this.serial(root, () => this.terminalOnce(root, receipt));

package/dist/plugin/gate.d.ts

@@ -36,6 +36,8 @@ interface Extraction {
     gitCommit?: boolean;
     gitCommitAdds?: string[][];
     gitMutation?: boolean;
+    /** Ambiguity in the Git mutation itself, not another native shell segment. */
+    gitAmbiguous?: boolean;
     remoteMutation?: boolean;
     issue?: CommandIssue;
 }