sortie-dogs 0.13.18 → 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.18](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.13.18)**
-· [Release notes](docs/release-v0.13.18.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.18
+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.18
+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.18**. 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.18-direct-settlement-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.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.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.18-direct-settlement-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.18-direct-settlement-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/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 ";
@@ -256,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;
@@ -387,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;
@@ -205,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;
@@ -254,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;

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 ? {
@@ -2219,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 };
@@ -2242,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/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;
+}

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

@@ -0,0 +1,94 @@
+/** Display-only request workload. No filesystem, hashing, model, process or network access. */
+import type { OperatorMission } from "./operator-mission.js";
+import type { OperatorState } from "./operator-runtime.js";
+export type WorkKind = "requirement" | "implementation" | "artifact" | "validation" | "operation" | "review" | "delivery" | "acceptance" | "user-acceptance";
+export interface WorkObservation {
+    read?: boolean;
+    changed?: boolean;
+    started?: boolean;
+    passed?: boolean;
+    failed?: boolean;
+    reported?: boolean;
+    settled?: string;
+    invalidated?: boolean;
+    callID?: string;
+    changedTargets?: string[];
+}
+export interface WorkQuantityItem {
+    id: string;
+    label: string;
+    kind: WorkKind;
+    requirementIDs: string[];
+    weight: number;
+    basis: "declared" | "derived" | "fallback";
+    parentID?: string;
+    paths: string[];
+    commands: string[];
+    units: string[];
+    observation: WorkObservation;
+    fraction: number;
+    removed?: boolean;
+    children?: string[];
+    targetEstimate?: number;
+    aliases?: string[];
+    commandPattern?: "pr" | "push" | "publish" | "deploy" | "install";
+}
+export interface WorkQuantityState {
+    version: 1;
+    scopeID: string;
+    revision: number;
+    revisionReason?: string;
+    items: WorkQuantityItem[];
+    estimatedTotal: number;
+    estimatedDone: number;
+    basis: "declared" | "derived" | "fallback" | "mixed";
+    pendingCount: number;
+    remainingKinds: WorkKind[];
+    lastReview?: string;
+    observationSequence?: number;
+    planRunID?: string;
+}
+export interface WorkQuantityProgress {
+    n: number;
+    denominator: 100;
+    scope_id: string;
+    scope: "whole-request";
+    estimated: true;
+    basis: WorkQuantityState["basis"];
+    estimated_done: number;
+    estimated_total: number;
+    estimate_revision: number;
+    revision_reason?: string;
+    completed: boolean;
+    cancelled: boolean;
+    remaining_kinds: WorkKind[];
+}
+export interface WorkQuantityEvent {
+    kind: "read" | "change" | "command-start" | "command-end" | "checkpoint" | "user-acceptance";
+    paths?: readonly string[];
+    command?: string;
+    commands?: readonly string[];
+    unit?: string;
+    callID?: string;
+    exit?: number | null;
+    successful?: boolean;
+    checkpoints?: readonly string[];
+}
+type WorkUnit = {
+    id?: string;
+    title?: string;
+    objective?: string;
+    read?: readonly string[];
+    write?: readonly string[];
+    validation?: readonly string[];
+    requirement_ids?: readonly string[];
+    acceptance_indices?: readonly number[];
+};
+/** Concrete work before scheduling/coalescence; broad scopes remain unexpanded estimates. */
+export declare function planWorkQuantity(mission: Pick<OperatorMission, "id" | "requirements" | "kind" | "execution" | "review" | "submission" | "phase">, rawUnits?: readonly WorkUnit[], run?: OperatorState, previous?: WorkQuantityState, declared?: unknown, directory?: string): WorkQuantityState;
+export declare function observeWorkQuantity(state: WorkQuantityState, event: WorkQuantityEvent): WorkQuantityState;
+/** Existing recorded outcomes only. No freshness checks, history reads, Git inspection or acceptance actions. */
+export declare function syncWorkQuantity(state: WorkQuantityState, mission: Partial<OperatorMission>, run?: OperatorState): WorkQuantityState;
+export declare function projectWorkQuantity(state: WorkQuantityState, completed?: boolean, cancelled?: boolean): WorkQuantityProgress;
+export declare function formatWorkQuantity(progress: WorkQuantityProgress): string;
+export {};