sortie-dogs 0.13.17 → 0.13.19

package/README.md

@@ -19,8 +19,8 @@ evidence-backed result, not more agents for their own sake.
 [![Node.js](https://img.shields.io/node/v/sortie-dogs)](https://www.npmjs.com/package/sortie-dogs)
 [![MIT License](https://img.shields.io/npm/l/sortie-dogs)](LICENSE)
 
-**Current release: [v0.13.17](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.13.17)**
-· [Release notes](docs/release-v0.13.17.md)
+**Current release: [v0.13.19](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.13.19)**
+· [Release notes](docs/release-v0.13.19.md)
 
 [Quick start](#quick-start) · [Workflow](#mission-workflow) · [Models](#default-models) ·
 [Measured results](#measured-results) · [Configuration](#configuration) · [Documentation](#documentation)
@@ -57,7 +57,7 @@ Use an existing Codex CLI signed in with **ChatGPT**. On Windows, PowerShell **7
 available; POSIX uses bash. Sortie does not install Codex, start login or use a metered API fallback.
 
 ```sh
-npm install --save-dev sortie-dogs@0.13.17
+npm install --save-dev sortie-dogs@0.13.19
 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.17
+npm install --save-dev sortie-dogs@0.13.19
 npx --no-install sortie-dogs init .
 ```
 
@@ -125,6 +125,11 @@ Discovery:  User → Operator → Coordinator → Worker → Validation → Revi
 The default Mission profile is serial. Background responsiveness and status observations do not
 add parallel writers, replay unknown commands or imply completion. More agents are not the goal.
 
+Whole-request workload appears as `全体作業量 n/100（概算）`, using ordinary plans and native
+work observations, not budget consumption or fixed stage shares. Calculation adds no model
+request or verification; formal acceptance still owns `100/100`.
+[Workload estimates, optional weights and runtime cost](docs/work-quantity-progress.md).
+
 For **run-once / result-collection** requests, a terminal failure can be the requested result:
 validate and report it without an unauthorized repair/rerun loop. Acceptance preserves the real
 operation exit and `execution-failed` outcome; it never turns a failed benchmark into a successful
@@ -188,7 +193,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.17**. SWE-bench remains an optional
+All scores belong to their fixed candidates, **not v0.13.19**. SWE-bench remains an optional
 measurement, not a release gate. Different budgets, models and conditions are not controlled comparisons.
 
 ## Configuration
@@ -211,7 +216,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.17-handoff-continuity-v1`; the unchanged Codex skill marker is
+The current Mission asset marker is `0.13.19-workload-progress-v1`; the unchanged Codex skill marker is
 `0.13.11-codex-skill-v2`. Installed markers alone do not prove a running host reloaded the new version.
 
 There is no supported uninstall command. Remove the dependency and only known Sortie-owned paths;
@@ -227,7 +232,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.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.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.17-handoff-continuity-v1";
+export declare const V010_RUNTIME_ASSET_VERSION = "0.13.19-workload-progress-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.17-handoff-continuity-v1";
+export const V010_RUNTIME_ASSET_VERSION = "0.13.19-workload-progress-v1";
 export const CODEX_SKILL_ASSET_VERSION = "0.13.11-codex-skill-v2";

package/dist/cli/codex-mission.js

@@ -118,6 +118,8 @@ export function codexMissionProgress(event) {
         command: bounded(args.command), workdir: bounded(args.workdir), cwd: bounded(metadata.cwd), reason: bounded(args.reason),
         agent: bounded(args.subagent_type), description: bounded(args.description), child_session_id: bounded(metadata.sessionId),
         outcome: bounded(receipt.status), exit: metadata.exit, executor: metadata.executor,
+        ...(record(receipt.work_quantity ?? metadata.work_quantity) ? { work_quantity: receipt.work_quantity ?? metadata.work_quantity,
+            work_quantity_display: bounded(receipt.work_quantity_display ?? metadata.work_quantity_display) } : {}),
         next_action: bounded(receipt.next_action),
         summary: bounded(args.summary ?? receipt.summary),
         detail: bounded(receipt.reason ?? receipt.error ?? (item.success === false ? text : undefined)) };

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

@@ -111,6 +111,15 @@ export interface GoalTerminalReceipt {
 interface GoalEventBase {
     readonly at: string;
 }
+/** Host verification of an existing direct finish receipt, not a new execution. */
+export interface GoalDirectFinishRecovery {
+    readonly call_id: string;
+    readonly actor_session_id: string;
+    readonly finish_call_id: string;
+    readonly started_at: string;
+    readonly finished_at: string;
+    readonly validation_call_ids: readonly string[];
+}
 export interface GoalValidationRetryAuthorization {
     readonly authority: "operator-repair-validation-retry";
     readonly operator_run_id: string;
@@ -218,6 +227,7 @@ export type GoalFlightEvent = (GoalEventBase & {
     readonly unit_id: string;
     readonly previous_receipt_id: string;
     readonly evidence: readonly GoalEvidence[];
+    readonly direct_finish?: GoalDirectFinishRecovery;
 }) | (GoalEventBase & {
     readonly kind: "validation.admission";
     readonly goal_id: string;

package/dist/core/goal-bound.js

@@ -133,7 +133,7 @@ export function reduceGoalFlight(records) {
     let replanRevision = null;
     let legacyResetRevision = false;
     let previous = null;
-    const processDefects = new Map();
+    const recoverableSettlements = new Map();
     const unitCosts = new Map();
     const validationAdmissions = new Map();
     const validationSettlements = new Map();
@@ -160,7 +160,7 @@ export function reduceGoalFlight(records) {
                 session_ids: [event.origin_session_id] };
             replanRevision = null;
             legacyResetRevision = false;
-            processDefects.clear();
+            recoverableSettlements.clear();
             validationAdmissions.clear();
             validationSettlements.clear();
             reopenedValidationEvidence.clear();
@@ -255,8 +255,8 @@ export function reduceGoalFlight(records) {
                 unit_ids: addUnique(state.unit_ids, event.unit_id),
                 evidence_refs: event.evidence.reduce((refs, evidence) => addUnique(refs, evidence.evidence_id), state.evidence_refs),
                 satisfied_criteria: event.evidence.reduce((ids, evidence) => evidence.measurement.criterion_ids.reduce(addUnique, ids), state.satisfied_criteria) };
-            if (event.result_class === "process-defect" && event.evidence.length === 0 && event.disposition !== "cancelled") {
-                processDefects.set(event.receipt_id, { unitID: event.unit_id, revision: state.revision, epoch: state.scope_epoch });
+            if (event.evidence.length === 0 && event.disposition !== "succeeded") {
+                recoverableSettlements.set(event.receipt_id, { unitID: event.unit_id, revision: state.revision, epoch: state.scope_epoch, settlement: event });
             }
         }
         else if (event.kind === "unit.usage-reconciled") {
@@ -271,11 +271,24 @@ export function reduceGoalFlight(records) {
                     : costs.reduce((sum, item) => sum + item.cost, 0) };
         }
         else if (event.kind === "unit.evidence-reconciled") {
-            const old = processDefects.get(event.previous_receipt_id);
+            const old = recoverableSettlements.get(event.previous_receipt_id);
+            const direct = event.direct_finish, settled = old?.settlement;
+            const directFinish = direct !== undefined && text(direct.call_id) && direct.call_id.startsWith("direct-") &&
+                text(direct.actor_session_id) && text(direct.finish_call_id) && instant(direct.started_at) && instant(direct.finished_at) &&
+                Date.parse(direct.finished_at) >= Date.parse(direct.started_at) && Array.isArray(direct.validation_call_ids) && direct.validation_call_ids.length > 0 &&
+                direct.validation_call_ids.every(text) && settled?.native_session_id === direct.actor_session_id &&
+                settled.native_started_at !== undefined && Math.abs(Date.parse(settled.native_started_at) - Date.parse(direct.started_at)) <= 1000 &&
+                Math.abs(Date.parse(settled.at) - Date.parse(direct.finished_at)) <= 1000 &&
+                settled.reservation_id === goalFingerprint({ goal_id: event.goal_id, unit_id: event.unit_id, call_id: direct.call_id }) &&
+                settled.receipt_id === goalFingerprint({ call_id: direct.call_id,
+                    output: "Host-observed direct unit finished; controller session remains active." }) &&
+                (settled.disposition === "cancelled" && settled.result_class === "interrupted" ||
+                    settled.disposition === "failed" && ["process-defect", "acceptance"].includes(settled.result_class ?? ""));
+            const processDefect = direct === undefined && settled?.disposition !== "cancelled" && settled?.result_class === "process-defect";
             requireState(state.phase === "active" && state.receipt === null && old?.unitID === event.unit_id &&
-                old.revision === state.revision && old.epoch === state.scope_epoch && state.outstanding_reservations.length === 0, "transition", "Evidence reconciliation requires a current settled process defect.");
+                old.revision === state.revision && old.epoch === state.scope_epoch && state.outstanding_reservations.length === 0 && (processDefect || directFinish), "transition", "Evidence reconciliation requires a current settled process defect or verified direct finish defect.");
             requireState(event.evidence.length > 0 && event.evidence.every(entry => validGoalEvidence(entry, state) && entry.execution.units.includes(event.unit_id)), "evidence", "Reconciled evidence must retain the current goal and unit identity.");
-            processDefects.delete(event.previous_receipt_id);
+            recoverableSettlements.delete(event.previous_receipt_id);
             state = { ...state, evidence_refs: event.evidence.reduce((refs, evidence) => addUnique(refs, evidence.evidence_id), state.evidence_refs),
                 satisfied_criteria: event.evidence.reduce((ids, evidence) => evidence.measurement.criterion_ids.reduce(addUnique, ids), state.satisfied_criteria) };
         }

package/dist/core/initialize.js

@@ -391,7 +391,10 @@ async function v010Config(root, global) {
     const update = (path, value) => { content = applyEdits(content, modify(content, path, value, options)); };
     const wrapper = `${prefix}plugins/sortie-dogs/index.js`;
     const wrapperSource = await readFile(resolve(root, wrapper), "utf8").catch(() => "");
-    const localV2Wrapper = /^\s*export\s*\{\s*default\s*\}\s*from\s*["']sortie-dogs\/server["'];?\s*$/u.test(wrapperSource);
+    // Both the package re-export and the release fixture's factory wrapper are
+    // automatically discovered by V2. Adding the package would load the same ID twice.
+    const localV2Wrapper = /^\s*export\s*\{\s*default\s*\}\s*from\s*["']sortie-dogs\/server["'];?\s*$/u.test(wrapperSource) ||
+        /^\s*import\s*\{\s*createSortieDogsV2Plugin\s*\}\s*from\s*["']sortie-dogs\/server["'];?\s*import\s*\{\s*SortieDogsPlugin\s*\}\s*from\s*["']sortie-dogs\/plugin["'];?\s*export\s+default\s+createSortieDogsV2Plugin\s*\(\s*SortieDogsPlugin\s*\);?\s*$/u.test(wrapperSource);
     const registered = plugins?.some(item => {
         const name = typeof item === "string" ? item : item !== null && typeof item === "object" ? item.package : undefined;
         return typeof name === "string" && /^sortie-dogs(?:@[^/]+)?$/u.test(name);

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

@@ -1,6 +1,7 @@
 import { type OperatorPlan, type OperatorState, type OperatorTask, type OperatorRuntime } from "./operator-runtime.js";
 import { type RuntimeProfile } from "./runtime-profile.js";
 import { type MissionContinuity } from "./mission-context.js";
+import { type WorkQuantityState } from "./work-quantity.js";
 export { missionValidationCommand } from "./mission-validation-command.js";
 export declare const MISSION_REFERENCE = "SORTIE_MISSION_REF ";
 export declare const MISSION_REVIEW_REFERENCE = "SORTIE_MISSION_REVIEW_REF ";
@@ -76,6 +77,13 @@ export interface MissionAttempt {
         code: string;
     };
     resultClass?: string;
+    /** Retained erroneous finish projection; the original goal receipt remains append-only. */
+    registrationRecovery?: {
+        at: string;
+        previousStatus: MissionAttempt["status"];
+        previousResultClass?: string;
+        previousFailure?: MissionAttempt["failure"];
+    };
     selectedModel?: string;
 }
 export interface MissionTerminalRescue {
@@ -249,6 +257,8 @@ export interface OperatorMission {
         status: string;
         at: string;
     }[];
+    /** Display-only request workload; excluded from controls, prompts and acceptance. */
+    workQuantity?: WorkQuantityState;
     submission: {
         status: "ready" | "needs-decision" | "blocked";
         summary: string;
@@ -380,7 +390,7 @@ export declare function missionPlan(mission: OperatorMission, raw: unknown, proj
 /** Compact provenance, not a new acceptance verdict or a substitute for original-request comparison. */
 export declare function missionAcceptanceSummary(mission: OperatorMission, run: OperatorState | undefined, operators: OperatorRuntime, observe?: (validation: readonly string[], child: string | null, notBefore?: number) => Promise<unknown>): Promise<Record<string, unknown>>;
 export declare function missionReviewIndependent(mission: OperatorMission, child: string | undefined): boolean;
-export declare function missionPacket(mission: OperatorMission, run?: OperatorState): Record<string, unknown>;
+export declare function missionPacket(mission: OperatorMission, run?: OperatorState, includeWorkQuantity?: boolean): Record<string, unknown>;
 /** Models forward a short capability, never recopy the host's evidence hashes and source packet. */
 export declare function missionReviewTask(mission: OperatorMission): OperatorTask;
 /** Optional implementation notes supplement host-observed source/checks; prose is not a coverage gate. */

package/dist/core/operator-mission.js

@@ -7,6 +7,8 @@ import { profileAgent } from "./runtime-profile.js";
 import { normalizeCommand } from "../plugin/gate.js";
 import { missionValidationCommand } from "./mission-validation-command.js";
 import { retainMissionContext, missionContextView } from "./mission-context.js";
+import { planWorkQuantity, projectWorkQuantity, syncWorkQuantity } from "./work-quantity.js";
+import { applyPendingWork, rememberWorkMission, rememberedWorkRun } from "./work-quantity-observations.js";
 export { missionValidationCommand } from "./mission-validation-command.js";
 const digest = (value) => createHash("sha256").update(value).digest("hex");
 const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
@@ -299,11 +301,22 @@ export class OperatorMissionRuntime {
         return matches.length === 1 ? matches[0] : undefined;
     }
     async save(file, value) {
+        if (record(value) && value.version === "0.12" && typeof value.root === "string") {
+            const mission = value;
+            const run = rememberedWorkRun(this.projectRoot, mission.root);
+            const current = run?.runID === mission.runID ? run : undefined;
+            if (!mission.workQuantity || current && mission.workQuantity.planRunID !== current.runID) {
+                mission.workQuantity = planWorkQuantity(mission, current?.units.map(unit => unit.unit), current, mission.workQuantity, undefined, this.projectRoot);
+            }
+            mission.workQuantity = syncWorkQuantity(applyPendingWork(this.projectRoot, mission.root, mission.workQuantity), mission, current);
+        }
         const temporary = `${file}.${randomUUID()}.tmp`;
         await mkdir(join(this.projectRoot, this.profile.stateDirectory, "missions"), { recursive: true });
         try {
             await writeFile(temporary, JSON.stringify(value), { flag: "wx", mode: 0o600 });
             await rename(temporary, file);
+            if (record(value) && value.version === "0.12" && file === this.file(String(value.root)))
+                rememberWorkMission(this.projectRoot, value);
         }
         finally {
             await rm(temporary, { force: true });
@@ -326,6 +339,8 @@ export class OperatorMissionRuntime {
         const state = await this.loadMission(root);
         if (state && (state.version !== "0.12" || state.root !== root))
             throw new Error("mission-state-invalid");
+        if (state)
+            rememberWorkMission(this.projectRoot, state);
         return state;
     }
     /** Serialize host recovery claims across processes; a stale lock never authorizes takeover. */
@@ -441,6 +456,7 @@ export class OperatorMissionRuntime {
                     throw new Error("mission-requirements-preserved: keep the existing ordered requirements and append user additions");
                 }
                 previous.requirements = requirements.map((text, index) => ({ id: `R${index + 1}`, text }));
+                previous.workQuantity = planWorkQuantity(previous, [], undefined, previous.workQuantity);
                 // Only an explicit Mission action adopts the latest real turn; chat capture alone never does.
                 if (!previous.requests.some(item => item.id === request.id))
                     previous.requests.push(request);
@@ -468,6 +484,10 @@ export class OperatorMissionRuntime {
                 ...((previous === undefined || previous.phase === "cancelled") &&
                     (replaceRequirements || previous?.runID === null || previous === undefined || request.id !== previous.requests[0]?.id) && predecessor
                     ? { supersededRunID: predecessor } : {}) };
+            if (previous?.phase === "cancelled" && !replaceRequirements &&
+                previous.requirements.every((requirement, index) => state.requirements[index]?.text === requirement.text)) {
+                state.workQuantity = planWorkQuantity(state, [], undefined, previous.workQuantity);
+            }
             await this.save(this.file(root), state);
             return state;
         });
@@ -762,7 +782,7 @@ export function missionReviewIndependent(mission, child) {
     return child !== undefined && !mission.sourceAuthors?.includes(child) &&
         !(mission.corrections ?? []).some(correction => correction.author === child);
 }
-export function missionPacket(mission, run) {
+export function missionPacket(mission, run, includeWorkQuantity = true) {
     const predecessor = run && mission.runID !== run.runID && (mission.supersededRunID === run.runID || run.phase === "cancelled") ? run : undefined;
     if (predecessor)
         run = undefined;
@@ -770,7 +790,9 @@ export function missionPacket(mission, run) {
     const reviewAccepted = currentReview && missionReviewAccepted(mission.review);
     const operationStatus = missionExecutionStatus(mission);
     const operationComplete = missionExecutionComplete(mission);
+    const workload = syncWorkQuantity(structuredClone(mission.workQuantity ?? planWorkQuantity(mission, run?.runID === mission.runID ? run.units.map(unit => unit.unit) : [], run)), mission, run);
     return { mission_id: mission.id, phase: mission.phase, coordinator_session_id: mission.coordinator,
+        ...(includeWorkQuantity ? { work_quantity: projectWorkQuantity(workload, mission.phase === "completed", mission.phase === "cancelled") } : {}),
         ...(predecessor ? { predecessor: { run_id: predecessor.runID, status: predecessor.phase,
                 completed_units: predecessor.units.filter(unit => unit.status === "succeeded").length,
                 note: "Historical results and spend are retained; they do not complete the current requirements." } } : {}),

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

@@ -2,6 +2,7 @@ import { type RuntimeProfile } from "./runtime-profile.js";
 import type { GoalEvidence, GoalTerminalReceipt } from "./goal-bound.js";
 import type { SerialDispatchSettlement } from "../plugin/runtime-bridge.js";
 import { type OperatorContractRepairFileIdentity } from "./operator-contract-repair.js";
+import { type WorkQuantityState, type WorkQuantityProgress } from "./work-quantity.js";
 export declare const OPERATOR_LIMITS: Readonly<{
     units: 32;
     planBytes: number;
@@ -131,6 +132,11 @@ interface UnitState {
         actor: string;
         startedAt: string;
         finishedAt?: string;
+        registrationRecovery?: {
+            at: string;
+            previousStatus: "failed" | "cancelled";
+            previousResultClass: string | null;
+        };
         checks: import("../plugin/runtime-bridge.js").ReviewerCorrectionCheck[];
         validationCwd?: Readonly<Record<string, string>>;
         validationRegisteredAt?: Readonly<Record<string, string>>;
@@ -200,6 +206,8 @@ export interface OperatorAcceptanceAnchor {
     readonly handoffHash: string;
 }
 export interface OperatorState {
+    /** Display metadata only, never part of the immutable execution plan. */
+    workQuantity?: WorkQuantityState;
     readonly schema_version: "0.1";
     readonly profile: string;
     readonly rootSessionID: string;
@@ -249,6 +257,7 @@ export interface OperatorState {
     receipt: GoalTerminalReceipt | null;
 }
 export interface OperatorProgress {
+    readonly work_quantity?: WorkQuantityProgress;
     readonly profile: string;
     readonly view: "progress";
     readonly run_id: string;
@@ -430,7 +439,7 @@ export declare class OperatorRuntime {
     private repairValidationRetryBinding;
     canRetryRepairValidation(state: OperatorState): boolean;
     resumeRepairValidation(root: string, runID: string, authorize: (source: OperatorRepairValidationRetrySource) => Promise<void>): Promise<OperatorState>;
-    resume(root: string, runID: string, recovered: ReadonlyMap<string, readonly GoalEvidence[]>, unstarted?: ReadonlySet<string>): Promise<OperatorState>;
+    resume(root: string, runID: string, recovered: ReadonlyMap<string, readonly GoalEvidence[]>, unstarted?: ReadonlySet<string>, recoveredDirect?: ReadonlySet<string>): Promise<OperatorState>;
     requireAcceptanceRemediation(root: string, runID: string): Promise<OperatorState>;
     draftStatus(root: string): Promise<unknown | undefined>;
     completionGoalFingerprint(state: OperatorState): Promise<string>;

package/dist/core/operator-runtime.js

@@ -15,6 +15,8 @@ import { ensureGitManagedStateExcluded } from "./git-managed-state.js";
 import { operatorContractRepairFingerprint } from "./operator-contract-repair.js";
 import { classifyUnitResult } from "./unit-result-classification.js";
 import { SOURCE_REVIEW_PHASES, SOURCE_REVIEW_RISK_TAGS } from "./consultation.js";
+import { planWorkQuantity, projectWorkQuantity, syncWorkQuantity } from "./work-quantity.js";
+import { applyPendingWork, rememberWorkRun } from "./work-quantity-observations.js";
 export const OPERATOR_LIMITS = Object.freeze({ units: 32, planBytes: 256 * 1024, packetBytes: 24 * 1024,
     remediationReserve: 32 });
 export class OperatorContractError extends Error {
@@ -319,8 +321,10 @@ export class OperatorRuntime {
     async read(root) {
         await this.writes.get(root);
         const cached = this.states.get(root);
-        if (cached)
+        if (cached) {
+            rememberWorkRun(this.projectRoot, cached);
             return structuredClone(cached);
+        }
         let source;
         try {
             source = await readFile(this.file(root), "utf8");
@@ -330,9 +334,13 @@ export class OperatorRuntime {
                 return undefined;
             throw error;
         }
-        if (Buffer.byteLength(source) > OPERATOR_LIMITS.planBytes * 4)
-            throw new Error("operator-state-too-large");
         const parsed = JSON.parse(source);
+        // Display metadata must not turn an otherwise valid execution state into a refusal.
+        if (Buffer.byteLength(source) > OPERATOR_LIMITS.planBytes * 4) {
+            const { workQuantity: _display, ...execution } = parsed;
+            if (Buffer.byteLength(JSON.stringify(execution)) > OPERATOR_LIMITS.planBytes * 4)
+                throw new Error("operator-state-too-large");
+        }
         const repairGeneration = parsed.repairGeneration === undefined ? 0 : parsed.repairGeneration;
         const state = { ...parsed,
             repairResidualPaths: parsed.repairResidualPaths === undefined ? [] : parsed.repairResidualPaths,
@@ -382,9 +390,15 @@ export class OperatorRuntime {
             throw new Error("operator-state-invalid");
         }
         this.states.set(root, state);
+        rememberWorkRun(this.projectRoot, state);
         return structuredClone(state);
     }
     async save(state) {
+        if (!state.workQuantity || state.workQuantity.planRunID !== state.runID)
+            state.workQuantity = planWorkQuantity({
+                id: state.workQuantity?.scopeID ?? `operator:${state.runID}`, requirements: state.acceptance.map((text, index) => ({ id: `R${index + 1}`, text })), phase: "running", submission: null
+            }, state.units.map(unit => unit.unit), state, state.workQuantity, undefined, this.projectRoot);
+        syncWorkQuantity(applyPendingWork(this.projectRoot, state.rootSessionID, state.workQuantity), {}, state);
         state.sequence++;
         const serialized = JSON.stringify(state);
         const previous = this.writes.get(state.rootSessionID) ?? Promise.resolve();
@@ -405,6 +419,7 @@ export class OperatorRuntime {
         try {
             await next;
             this.states.set(state.rootSessionID, structuredClone(state));
+            rememberWorkRun(this.projectRoot, state);
         }
         catch (error) {
             state.sequence--;
@@ -1139,6 +1154,7 @@ export class OperatorRuntime {
             ? { ...structuredClone(previous.gitLifecycle), committedHead: null, commitProvenance: null }
             : await this.createGitLifecycle(plan, remediationHead);
         const state = { schema_version: "0.1", profile: this.profile.id, rootSessionID: root, runID, planHash: validatedPlanHash,
+            ...(parent?.workQuantity ? { workQuantity: structuredClone(parent.workQuantity) } : {}),
             acceptance: plan.acceptance, acceptanceProof: plan.acceptance_proof, acceptanceFingerprint, sourceRefs: plan.source_refs, createdAt: new Date().toISOString(),
             parentRunID: parent?.runID ?? null, ...(superseding ? { supersededRunID: previous.runID } : {}), priorAcceptedUnits,
             remediationParent: remediationTaskID && remediationHead && parent?.gitLifecycle ? {
@@ -2091,16 +2107,17 @@ export class OperatorRuntime {
             return state;
         });
     }
-    resume(root, runID, recovered, unstarted = new Set()) {
+    resume(root, runID, recovered, unstarted = new Set(), recoveredDirect = new Set()) {
         return this.serial(root, async () => {
             const state = await this.required(root);
             if (state.contractRepair !== null)
                 throw new Error("operator-resume-contract-repair-required");
-            if (state.runID !== runID || state.phase !== "awaiting-decision" || state.units.some(unit => unit.status === "running" || unit.status === "cancelled")) {
+            if (state.runID !== runID || state.phase !== "awaiting-decision" || state.units.some(unit => unit.status === "running" ||
+                unit.status === "cancelled" && !recoveredDirect.has(unit.unit.id))) {
                 throw new Error("operator-resume-not-ready");
             }
             for (const unit of state.units) {
-                if (unit.status !== "failed")
+                if (unit.status !== "failed" && unit.status !== "cancelled")
                     continue;
                 if (unstarted.has(unit.unit.id)) {
                     if (unit.resultClass !== "process-defect" || unit.childSessionID !== null || state.decision !== "dispatch-admission-rejected")
@@ -2111,10 +2128,18 @@ export class OperatorRuntime {
                     continue;
                 }
                 const evidence = recovered.get(unit.unit.id);
+                const direct = recoveredDirect.has(unit.unit.id) && unit.directExecution?.actor === unit.childSessionID &&
+                    !!unit.directExecution.finishedAt && !!unit.callID && !!evidence?.length;
+                await this.verifyControls(unit);
                 const ids = new Set(evidence?.flatMap(item => item.measurement.criterion_ids) ?? []);
-                if (unit.resultClass !== "process-defect" || !evidence?.length || !unit.unit.acceptance_indices.every(index => state.acceptanceProof[index].some(id => ids.has(id)))) {
+                if (unit.resultClass !== "process-defect" && !direct || !evidence?.length || !unit.unit.acceptance_indices.every(index => state.acceptanceProof[index].some(id => ids.has(id)))) {
                     throw new Error("operator-resume-proof-incomplete");
                 }
+                if (unit.status === "cancelled" && !direct)
+                    throw new Error("operator-resume-proof-incomplete");
+                if (direct)
+                    unit.directExecution.registrationRecovery = { at: new Date().toISOString(),
+                        previousStatus: unit.status, previousResultClass: unit.resultClass };
                 unit.status = "succeeded";
                 unit.resultClass = "acceptance";
                 unit.evidence = evidence;
@@ -2210,6 +2235,7 @@ export class OperatorRuntime {
         const authoritativeAction = nextAction !== undefined ? nextAction
             : this.continuationNextAction(state);
         return { profile: state.profile, view: "progress", run_id: state.runID, stage: state.phase, decision: state.decision,
+            ...(state.workQuantity ? { work_quantity: projectWorkQuantity(state.workQuantity, state.phase === "completed", state.phase === "cancelled") } : {}),
             current_unit: current === undefined ? null : { id: current.unit.id, title: current.unit.title, status: current.status },
             completed_units: state.units.filter(unit => unit.status === "succeeded").length, total_units: state.units.length,
             budget_remaining_units: budgetRemainingUnits, next_action: typeof authoritativeAction === "string" ? authoritativeAction : null };
@@ -2233,6 +2259,7 @@ export class OperatorRuntime {
             : `call ${this.profile.toolPrefix}cancel_operator, then call ${this.profile.toolPrefix}prepare_operator with an approved replacement plan for the same goal and exact acceptance; start from git_lifecycle.committed_head, keep writes within git_lifecycle.approved_write_union, retain consumed budget, and do not call resume_operator or edit the committed candidate${carriedAction}`;
         const awaitingAcceptanceNextAction = `assess the independent-review requirement and obtain review when required, copying review_dispatch_contract.required_prompt_lines into the reviewer Task prompt with real values; if review PASSes (or policy records an allowed skip), call ${this.profile.toolPrefix}complete_operator with this run_id and acceptance_fingerprint; if review has blocking findings wholly inside the existing exact acceptance, the union of git_lifecycle.approved_write_union and git_lifecycle.remediation_reserve, and remaining cumulative budget, do not complete or ask for user approval: call ${this.profile.toolPrefix}cancel_operator with reason review-blocking, then call ${this.profile.toolPrefix}prepare_operator for one same-goal replacement from git_lifecycle.committed_head targeting only those findings; copy this packet's acceptance array verbatim into the replacement plan without paraphrase, deletion, addition, or reordering, preserve accepted-criteria lineage, and run final canonical validation/review; if the replacement is refused for write scope, report replacement_constraints.blocked_write_paths to the user as the exact paths needing approval and stop, then after the user approves resend the same replacement with git_lifecycle.remediation_scope_expansion set to exactly those paths; if acceptance or budget must increase, stop for the user decision`;
         const packet = { profile: state.profile, run_id: state.runID, root_session_id: state.rootSessionID, generation: state.generation,
+            ...(state.workQuantity ? { work_quantity: projectWorkQuantity(state.workQuantity, state.phase === "completed", state.phase === "cancelled") } : {}),
             sequence: state.sequence, status: state.phase, repair_generation: state.repairGeneration,
             acceptance: state.acceptance, acceptance_fingerprint: state.acceptanceFingerprint,
             next_task_ref: current?.status === "pending" ? (state.units.length > 1

package/dist/core/run-flight-ledger.js

@@ -925,6 +925,14 @@ export class RunFlightLedger {
                 stored.reservation_id === event.reservation_id && stored.native_session_id === event.native_session_id &&
                 stored.cost_usd === event.cost_usd))
                 return reduceGoalFlight(records);
+            if (event.kind === "unit.evidence-reconciled" && event.direct_finish !== undefined) {
+                const existing = records.find(record => record.event.kind === "unit.evidence-reconciled" &&
+                    record.event.previous_receipt_id === event.previous_receipt_id)?.event;
+                if (existing?.kind === "unit.evidence-reconciled" && existing.goal_id === event.goal_id && existing.unit_id === event.unit_id &&
+                    goalFingerprint(existing.evidence) === goalFingerprint(event.evidence) &&
+                    goalFingerprint(existing.direct_finish) === goalFingerprint(event.direct_finish))
+                    return reduceGoalFlight(records);
+            }
             if (event.kind === "goal.accepted") {
                 const prior = records.find(({ event: stored }) => stored.kind === "goal.accepted" &&
                     stored.origin_user_message_id === event.origin_user_message_id);

package/dist/core/validation-budget.js

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import { CONTRACT_TEXT_LIMITS } from "./contract-limits.js";
 export const VALIDATION_PROFILES = ["fast", "balanced", "assurance"];
 /** A real failed process can be rerun after setup repair without changing source or command identity. */
 export function retryableValidationFailure(outcome, exitCode) {
@@ -38,6 +39,7 @@ export function validationEvidenceState(events) {
     return { reusable: [...reusable], blocked: [...blocked] };
 }
 const id = (value) => typeof value === "string" && value.length > 0 && value.length <= 4096;
+const commandText = (value) => typeof value === "string" && value.length > 0 && value.length <= CONTRACT_TEXT_LIMITS.command;
 const scopes = new Set(["static", "targeted", "related", "canonical", "full-suite", "full"]);
 const normalizedScope = (scope) => scope === "full" ? "canonical" : scope;
 export function validationOwner(scope) {
@@ -94,7 +96,7 @@ export function decideValidationBudget(request, state) {
     const environment = value.environment;
     const marginal = value.marginal_value;
     const valid = id(value.run_id) && id(value.operation_id) && id(value.source_snapshot) && id(value.candidate) &&
-        value.command.length > 0 && value.command.every(id) && scopes.has(value.scope) &&
+        value.command.length > 0 && value.command.every(commandText) && scopes.has(value.scope) &&
         environment !== null && typeof environment === "object" && id(environment.platform) && id(environment.arch) &&
         id(environment.runtime) && (environment.toolchain === undefined || id(environment.toolchain)) &&
         (value.owner === "worker" || value.owner === "coordinator") &&

package/dist/core/work-quantity-observations.d.ts

@@ -0,0 +1,13 @@
+/** Bounded display observations from already delivered native events. No I/O or authority. */
+import type { OperatorMission } from "./operator-mission.js";
+import type { OperatorState } from "./operator-runtime.js";
+import { type WorkQuantityEvent, type WorkQuantityState, type WorkQuantityProgress } from "./work-quantity.js";
+export declare function rememberWorkMission(directory: string, mission: OperatorMission): void;
+export declare function rememberWorkRun(directory: string, run: OperatorState): void;
+export declare function rememberedWorkRun(directory: string, root: string): OperatorState | undefined;
+export declare function workRootForActor(directory: string, actor: string): string | undefined;
+/** Every event is folded at most once per saved projection; repeated edits are not completed work. */
+export declare function observeActorWork(directory: string, actor: string, event: WorkQuantityEvent): string | undefined;
+export declare function applyPendingWork(directory: string, root: string, state: WorkQuantityState): WorkQuantityState;
+export declare function missionWorkState(directory: string, mission: OperatorMission, run?: OperatorState): WorkQuantityState;
+export declare function cachedWorkProgress(directory: string, actor: string): WorkQuantityProgress | undefined;

package/dist/core/work-quantity-observations.js

@@ -0,0 +1,91 @@
+import { observeWorkQuantity, planWorkQuantity, projectWorkQuantity, syncWorkQuantity } from "./work-quantity.js";
+const views = new Map();
+const owners = new Map();
+const identity = (directory, root) => `${directory.replaceAll("\\", "/").replace(/\/$/u, "")}\0${root}`;
+function view(directory, root) {
+    const id = identity(directory, root);
+    let value = views.get(id);
+    if (!value) {
+        value = { sequence: 0, events: new Map() };
+        views.set(id, value);
+    }
+    owners.set(id, root);
+    return value;
+}
+export function rememberWorkMission(directory, mission) {
+    const value = view(directory, mission.root);
+    if (value.mission?.id !== mission.id && value.mission?.workQuantity?.scopeID !== mission.workQuantity?.scopeID)
+        value.events.clear();
+    value.mission = mission;
+    value.sequence = Math.max(value.sequence, mission.workQuantity?.observationSequence ?? 0);
+    delete value.progress;
+    if (mission.coordinator)
+        owners.set(identity(directory, mission.coordinator), mission.root);
+    if (mission.review?.child)
+        owners.set(identity(directory, mission.review.child), mission.root);
+    for (const attempt of mission.attempts ?? [])
+        if (attempt.childSessionID)
+            owners.set(identity(directory, attempt.childSessionID), mission.root);
+}
+export function rememberWorkRun(directory, run) {
+    const value = view(directory, run.rootSessionID);
+    value.run = run;
+    value.sequence = Math.max(value.sequence, run.workQuantity?.observationSequence ?? 0);
+    delete value.progress;
+    if (run.operatorSessionID)
+        owners.set(identity(directory, run.operatorSessionID), run.rootSessionID);
+    for (const unit of run.units)
+        if (unit.childSessionID)
+            owners.set(identity(directory, unit.childSessionID), run.rootSessionID);
+}
+export function rememberedWorkRun(directory, root) {
+    return views.get(identity(directory, root))?.run;
+}
+export function workRootForActor(directory, actor) { return owners.get(identity(directory, actor)); }
+/** Every event is folded at most once per saved projection; repeated edits are not completed work. */
+export function observeActorWork(directory, actor, event) {
+    const root = owners.get(identity(directory, actor));
+    if (!root)
+        return undefined;
+    const value = view(directory, root);
+    if (value.mission && ["completed", "cancelled"].includes(value.mission.phase) || !value.mission &&
+        value.run && ["completed", "cancelled"].includes(value.run.phase))
+        return undefined;
+    const run = value.run;
+    const unit = run?.units.find(unit => unit.status === "running" && unit.childSessionID === actor);
+    const observed = { ...event, ...(unit ? { unit: `${run.runID}/${unit.unit.id}` } : {}) };
+    const id = JSON.stringify([event.kind, event.paths, event.command, event.commands, event.checkpoints, observed.unit]);
+    value.events.delete(id);
+    value.events.set(id, { sequence: ++value.sequence, event: observed });
+    delete value.progress;
+    if (value.events.size > 512)
+        value.events.delete(value.events.keys().next().value);
+    return root;
+}
+export function applyPendingWork(directory, root, state) {
+    const value = views.get(identity(directory, root));
+    if (!value)
+        return state;
+    for (const entry of value.events.values())
+        if (entry.sequence > (state.observationSequence ?? 0))
+            observeWorkQuantity(state, entry.event);
+    state.observationSequence = value.sequence;
+    return state;
+}
+export function missionWorkState(directory, mission, run) {
+    const state = mission.workQuantity ?? planWorkQuantity(mission, run?.runID === mission.runID ? run.units.map(unit => unit.unit) : [], run, undefined, undefined, directory);
+    return syncWorkQuantity(applyPendingWork(directory, mission.root, structuredClone(state)), mission, run);
+}
+export function cachedWorkProgress(directory, actor) {
+    const root = owners.get(identity(directory, actor));
+    const value = root && views.get(identity(directory, root));
+    if (!value)
+        return undefined;
+    if (value.progress)
+        return value.progress;
+    if (value.mission)
+        return value.progress = projectWorkQuantity(missionWorkState(directory, value.mission, value.run), value.mission.phase === "completed", value.mission.phase === "cancelled");
+    if (value.run?.workQuantity)
+        return value.progress = projectWorkQuantity(syncWorkQuantity(applyPendingWork(directory, root, structuredClone(value.run.workQuantity)), {}, value.run), value.run.phase === "completed", value.run.phase === "cancelled");
+    return undefined;
+}