pi-harness-runtime 1.1.451 → 1.1.453

package/AGENTS.md

@@ -46,8 +46,21 @@ A task with a cheap tier and an expensive tier MUST use the cheap tier while the
    {
      "metadata": {
        "validationPlan": {
-         "fast": { "command": "bun test tests/fast", "expectedDurationMs": 18000, "datasetSize": 100 },
-         "full": { "command": "bun test tests/full", "expectedDurationMs": 2400000, "datasetSize": 10000 },
+         "fast": {
+           "command": "bun test tests/fast",
+           "expectedDurationMs": 18000,
+           "datasetSize": 100,
+           "owner": "the agent that runs the validation",
+           "passCriteria": ["every record is written once", "the counts of source and target match"],
+           "failureAction": "stop the job and report the failure of the pilot"
+         },
+         "full": {
+           "command": "bun test tests/full",
+           "expectedDurationMs": 2400000,
+           "datasetSize": 10000,
+           "owner": "the agent that runs the validation",
+           "scaleUpFrom": "fast"
+         },
          "budgetMinutes": 90,
          "finalTierRequired": true
        }
@@ -57,6 +70,8 @@ A task with a cheap tier and an expensive tier MUST use the cheap tier while the
 
    The harness never guesses a tier from a command string. Without a declared plan the current behaviour is unchanged.
 
+   A tier that declares `scaleUpFrom: "fast"` is the scale-up of a large job: it only counts when the fast tier passed. The fast tier of such a plan is the representative pilot and declares `"representative": true`.
+
 2. **Iterate on the fast tier.** After every code edit, rerun the fast tier plus the focused unit/type checks the edit touches.
 
 3. **Run the full tier once.** Run the full tier as the final acceptance check, when the implementation and the fast tier are stable.
@@ -71,7 +86,9 @@ A task with a cheap tier and an expensive tier MUST use the cheap tier while the
 
 8. **The fast tier must be representative.** A small fixture keeps the shape of the data (optional fields, relations, uniqueness, boundary values, aggregates under test), not just the row count. Use deterministic data with cleanup so repeated runs do not accumulate rows.
 
-9. **Record every tier run in the ledger.** The harness never runs the tests, so the run is recorded by whoever knows the result:
+9. **A large job starts with a measured pilot.** The pilot is the fast tier: it runs over a representative subset (100 records when that is safe) and it is measured, not assumed. The scale-up only starts when the pilot passed, the pilot ran on the declared number of records, and the run stayed inside the budget. A pilot that fails stops the job: report the finding instead of scaling up. The batches of a scale-up are bounded and explicit (`packages/jev-judge/src/batch-plan.ts`), a failed batch is retried instead of restarting the job, and the concurrency limit is always a declared number.
+
+10. **Record every tier run in the ledger.** The harness never runs the tests, so the run is recorded by whoever knows the result:
 
    ```bash
    bun scripts/validation-run.ts --item 12 --tier fast --status passed --duration 18s --dataset 100
@@ -83,6 +100,8 @@ A task with a cheap tier and an expensive tier MUST use the cheap tier while the
 **What the harness does with the plan:**
 
 - The continuation message carries the plan, the recorded tier state and the remaining budget, so the agent never re-runs a tier that already passed.
+- A scale-up that ran before its pilot passed does not count: the final tier stays pending and the task stays open.
+- The status line names the phase, the progress, the validation state and the children that really ran.
 - When `budgetMinutes` is spent, the item pauses at a safe boundary: nothing is dispatched, the work stays open, and the reason is reported.
 - When a todo with `finalTierRequired` is marked complete while that tier is pending or failed, the completion report is suppressed and the item is named instead. A todo may not be reported as done on the strength of an unreported run.
 
@@ -273,6 +292,18 @@ ls packages/notification/dist/
 bun add -d typescript
 ```
 
+**The canonical build**: the compiled output that is committed comes from
+`bun scripts/build-packages.ts`, which uses the TypeScript of the root
+(`node_modules/.bin/tsc`). A package-level `bun run build` uses the
+TypeScript that the package itself installed, and the two write different
+source maps for the same source. A package-level build therefore leaves
+the tree with a `dist/` that the next canonical build changes again.
+
+```bash
+# The build whose output is committed
+bun scripts/build-packages.ts
+```
+
 ## Icon Usage
 
 **This is a Node.js CLI daemon — do NOT add React as a dependency for icons.**
@@ -341,6 +372,57 @@ todo create "Replace Film icon with themed icon"
 
 **IMPORTANT**: The `todo` tool and `bd` commands are DIFFERENT systems. Use `todo` for local task tracking.
 
+**Who owns the todo list.** The **agent** creates the todos, the harness
+only reads them. Two consequences:
+
+- The kind of a todo is read from `metadata.kind` first and from the title
+  prefix second. An explicit kind is more reliable than a prefix, and the
+  agent can always set it.
+- When the todo provider is not available, the harness says so: the status
+  line reads `[?] TODOS unavailable` and the agent is told that the phase
+  gate is not active. The harness never claims a gate it cannot enforce.
+
+---
+
+## Phase Model: Implementation, Review, Validation (CRITICAL)
+
+A task with several steps runs in three phases, and the harness enforces
+the order. The todo prefixes are the contract:
+
+| Prefix | Meaning |
+|--------|---------|
+| `[IMPLEMENT]` | implementation work of the current request |
+| `[REVIEW]` | the review of the task diff (one todo per chunk) |
+| `[REVIEW-FIX]` | a confirmed finding that has to be fixed |
+| `[TEST]` | the validation of the task (the tiers are declared in its metadata) |
+
+**Phase 1 - implementation.** Every open `[IMPLEMENT]` todo (and every
+unclassified todo) is implementation work. The phase ends when the list
+shows finished implementation work.
+
+**Phase 2 - review.** The review starts **on its own**: as soon as the
+implementation is done and the task changed a file, the harness derives the
+scope from the task diff, splits it into chunks and asks for one `[REVIEW]`
+todo per chunk. You never have to queue a review item to get one. A task
+that changed no file completes without a review - there is nothing to
+review.
+
+**Phase 3 - validation.** A `[TEST]` todo declares the validation plan of
+the task in `metadata.validationPlan` (see the section above) and the
+recorded runs in the validation ledger decide whether the task is done:
+
+- The task is **not** complete while the required final tier is pending.
+- The task is **not** complete when the final tier failed, timed out or
+  errored.
+- A plan that requires a final tier but declares none is an error to
+  report, not a plan to complete.
+- A validation state that cannot be read is never a validation that
+  passed.
+
+So the order of a real task is: implement, review the diff, fix the
+findings, run the tiers, record them, and only then report the task as
+done.
+
 ---
 
 ### Habit: Detect New Tasks from User Prompts (CRITICAL)

package/CHANGELOG.md

@@ -2,6 +2,58 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+### [1.1.453](https://github.com/ManotLuijiu/pi-harness-runtime/compare/v1.1.448...v1.1.453) (2026-10-27)
+
+
+### Features
+
+* **delegation:** a child is only a child when it really ran ([ac4e678](https://github.com/ManotLuijiu/pi-harness-runtime/commit/ac4e6782d7d4bc4941e458425c8a9f38a51fc9d4))
+* **delegation:** the scope of a request is measured before it is judged ([684b6a5](https://github.com/ManotLuijiu/pi-harness-runtime/commit/684b6a55184f63d3be24c48dcecfb0b13410dc15))
+* **jev:** the pending question carries the ask and the answer ([a792133](https://github.com/ManotLuijiu/pi-harness-runtime/commit/a792133e517fb8c12d3363e98942f3af30270f27))
+* **merge:** a manual run can leave the merge to the pull request event ([b3d1950](https://github.com/ManotLuijiu/pi-harness-runtime/commit/b3d1950b5941c78ccd56951acdafd1d4afbe1bff))
+* **phase:** the agent owns the todo list and the harness says so ([c489370](https://github.com/ManotLuijiu/pi-harness-runtime/commit/c489370bd7926aece8cb1a77aa20ca2d2672f1fb))
+* **review:** the review starts on its own when the implementation is done ([04f51f5](https://github.com/ManotLuijiu/pi-harness-runtime/commit/04f51f599cd3222b6c74dd8fadb1373bd72d9bd7))
+* **status:** the status line names the phase, the progress and the children ([0167bf3](https://github.com/ManotLuijiu/pi-harness-runtime/commit/0167bf396a0b987c1d44f3b869351976a951dd65))
+* **test:** the task waits for the final tier of the validation plan ([fa147db](https://github.com/ManotLuijiu/pi-harness-runtime/commit/fa147dbf7d50d56e6ea48c6d8fbb4fcb190caf8a))
+* **validation:** a large job starts with a measured pilot ([425964b](https://github.com/ManotLuijiu/pi-harness-runtime/commit/425964b04a3d4fa02adfabed47ff62c5ec2b9c28))
+
+
+### Bug Fixes
+
+* **hooks:** a tag is checked through the commit behind it ([c823e8e](https://github.com/ManotLuijiu/pi-harness-runtime/commit/c823e8e1f6973c62b5449a97c101759a4d5cbba5))
+* **jev:** the alternatives of a question are parsed without a quadratic pattern ([63016a3](https://github.com/ManotLuijiu/pi-harness-runtime/commit/63016a3f0488acb801990dd46770c00d382b5858))
+* **keys:** the key directory is audited as a tree ([081cc75](https://github.com/ManotLuijiu/pi-harness-runtime/commit/081cc75ac8ceff36b0d619c3f76371dc08459d3c))
+* **merge:** the boolean input is read as a boolean ([971b716](https://github.com/ManotLuijiu/pi-harness-runtime/commit/971b7169a43db382dbdeb6bb9bab02ab56e0351c))
+* **merge:** the manual job needs the right of the merge ([7ba685e](https://github.com/ManotLuijiu/pi-harness-runtime/commit/7ba685ec43d815f90aa35b742579e87e76c69209))
+* **merge:** the merge of the pull request is the GraphQL mutation ([972bab4](https://github.com/ManotLuijiu/pi-harness-runtime/commit/972bab4b0f7faf1b0047f3bb767ef6db3de4b2fa))
+* **merge:** the workflow merges the pull request the gates cleared ([d7639ec](https://github.com/ManotLuijiu/pi-harness-runtime/commit/d7639ec9b83723510acb4a5c4e23d5d6167c3af6))
+* **release:** a manual release keeps the version of its manifest ([122e661](https://github.com/ManotLuijiu/pi-harness-runtime/commit/122e661ea48cb8aff14c71dbd0221a4cf0ba4c8e))
+* **release:** the release scans the tree of the commit it publishes ([7d47a0b](https://github.com/ManotLuijiu/pi-harness-runtime/commit/7d47a0b5406480a1e1d3a52623a76aabd1e2d0ba))
+
+### [1.1.452](https://github.com/ManotLuijiu/pi-harness-runtime/compare/v1.1.448...v1.1.452) (2026-10-27)
+
+
+### Features
+
+* **delegation:** the scope of a request is measured before it is judged ([684b6a5](https://github.com/ManotLuijiu/pi-harness-runtime/commit/684b6a55184f63d3be24c48dcecfb0b13410dc15))
+* **jev:** the pending question carries the ask and the answer ([a792133](https://github.com/ManotLuijiu/pi-harness-runtime/commit/a792133e517fb8c12d3363e98942f3af30270f27))
+* **merge:** a manual run can leave the merge to the pull request event ([b3d1950](https://github.com/ManotLuijiu/pi-harness-runtime/commit/b3d1950b5941c78ccd56951acdafd1d4afbe1bff))
+* **review:** the review starts on its own when the implementation is done ([04f51f5](https://github.com/ManotLuijiu/pi-harness-runtime/commit/04f51f599cd3222b6c74dd8fadb1373bd72d9bd7))
+* **test:** the task waits for the final tier of the validation plan ([fa147db](https://github.com/ManotLuijiu/pi-harness-runtime/commit/fa147dbf7d50d56e6ea48c6d8fbb4fcb190caf8a))
+
+
+### Bug Fixes
+
+* **hooks:** a tag is checked through the commit behind it ([c823e8e](https://github.com/ManotLuijiu/pi-harness-runtime/commit/c823e8e1f6973c62b5449a97c101759a4d5cbba5))
+* **jev:** the alternatives of a question are parsed without a quadratic pattern ([63016a3](https://github.com/ManotLuijiu/pi-harness-runtime/commit/63016a3f0488acb801990dd46770c00d382b5858))
+* **keys:** the key directory is audited as a tree ([081cc75](https://github.com/ManotLuijiu/pi-harness-runtime/commit/081cc75ac8ceff36b0d619c3f76371dc08459d3c))
+* **merge:** the boolean input is read as a boolean ([971b716](https://github.com/ManotLuijiu/pi-harness-runtime/commit/971b7169a43db382dbdeb6bb9bab02ab56e0351c))
+* **merge:** the manual job needs the right of the merge ([7ba685e](https://github.com/ManotLuijiu/pi-harness-runtime/commit/7ba685ec43d815f90aa35b742579e87e76c69209))
+* **merge:** the merge of the pull request is the GraphQL mutation ([972bab4](https://github.com/ManotLuijiu/pi-harness-runtime/commit/972bab4b0f7faf1b0047f3bb767ef6db3de4b2fa))
+* **merge:** the workflow merges the pull request the gates cleared ([d7639ec](https://github.com/ManotLuijiu/pi-harness-runtime/commit/d7639ec9b83723510acb4a5c4e23d5d6167c3af6))
+* **release:** a manual release keeps the version of its manifest ([122e661](https://github.com/ManotLuijiu/pi-harness-runtime/commit/122e661ea48cb8aff14c71dbd0221a4cf0ba4c8e))
+* **release:** the release scans the tree of the commit it publishes ([7d47a0b](https://github.com/ManotLuijiu/pi-harness-runtime/commit/7d47a0b5406480a1e1d3a52623a76aabd1e2d0ba))
+
 ### [1.1.451](https://github.com/ManotLuijiu/pi-harness-runtime/compare/v1.1.448...v1.1.451) (2026-10-27)
 
 

package/index.ts

@@ -253,6 +253,9 @@ function keyFileFixesOrFallback(feature: string, labels: string[]): string[] {
 const sharedState = {
 	waitingForUserSince: null as Date | null,
 	todoContinuationController: null as unknown,
+	// The ledger of the validation runs. The two-phase workflow reads it to
+	// know whether the final tier of a test item passed.
+	validationLedger: null as unknown,
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	updateAutoContinueStatus: null as any,
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -439,6 +442,43 @@ async function loadTwoPhaseModule(): Promise<TwoPhaseModule | null> {
 	}
 }
 
+/**
+ * Measure the scope of a request in the workspace.
+ *
+ * The measurement is the only source of the numbers the delegation
+ * assessment uses: the request names the files, or the session changed
+ * them. When nothing can be measured the result is null, and the caller
+ * says that instead of inventing a scope.
+ */
+async function measureDelegationScope(
+	userMessage: string,
+): Promise<import("./packages/jev-judge/dist/delegation-harness.js").ScopeFacts | null> {
+	try {
+		const scope = await import("./packages/jev-judge/dist/delegation-scope.js");
+		const harness = await import("./packages/jev-judge/dist/delegation-harness.js");
+		const measurement = scope.measureScope({
+			workspacePath: _piSessionCwd || process.cwd(),
+			hints: scope.scopeHintsFromText(userMessage),
+		});
+		if (measurement.files.length === 0) return null;
+		return harness.scopeFactsFromMeasurement(measurement);
+	} catch (error) {
+		logToFile("[Delegation]", "Scope measurement failed:", oneLineError(error));
+		return null;
+	}
+}
+
+/**
+ * The decision of the delegation assessment, as the harness returns it.
+ */
+type DelegationDecisionLike = {
+	strategy: string;
+	reason: string;
+	workGroups?: { id: string; files: string[] }[];
+	dispatched?: boolean;
+	dispatchTool?: string;
+};
+
 /**
  * Register the two-phase workflow in the session.
  *
@@ -473,10 +513,79 @@ async function initTwoPhaseReview(pi: ExtensionAPI): Promise<void> {
 		}
 	};
 
+	/**
+	 * Read the validation state of the test items of the session.
+	 *
+	 * The ledger is the only mechanical source for "did the final tier
+	 * pass?". The workflow never runs a test itself, it only reads what the
+	 * ledger recorded.
+	 */
+	const readValidation = async (todos: TwoPhaseTodoLike[]) => {
+		const ledger = sharedState.validationLedger as
+			| import("./packages/jev-judge/dist/validation-ledger.js").ValidationLedger
+			| null
+			| undefined;
+		if (!ledger) {
+			return {
+				available: false,
+				pendingFinalTier: 0,
+				failedFinalTier: 0,
+				incompletePlan: 0,
+				reason: "the validation ledger is not initialized",
+			};
+		}
+		let pendingFinalTier = 0;
+		let failedFinalTier = 0;
+		let incompletePlan = 0;
+		for (const todo of todos) {
+			if (todo.id === undefined) continue;
+			if (mod.classifyTodo(todo) !== "test") continue;
+			const state = ledger.stateFor(todo as never);
+			if (state.planIncomplete) {
+				incompletePlan += 1;
+				continue;
+			}
+			if (!state.finalTierRequired) continue;
+			const status = state.full.status;
+			if (status === "passed") continue;
+			if (status === "failed" || status === "timeout" || status === "error") {
+				failedFinalTier += 1;
+			} else {
+				pendingFinalTier += 1;
+			}
+		}
+		return { available: true, pendingFinalTier, failedFinalTier, incompletePlan };
+	};
+
+	/**
+	 * The delegation state of the session.
+	 *
+	 * The numbers are the observed ones: the children that really ran and
+	 * the groups the harness measured. A plan that was never dispatched
+	 * shows zero dispatched children.
+	 */
+	const readDelegation = () => {
+		const harness = sharedState.delegationHarness as
+			| import("./packages/jev-judge/dist/delegation-harness.js").DelegationHarness
+			| null
+			| undefined;
+		if (!harness) return undefined;
+		try {
+			const receipt = harness.getReceipt();
+			const groups = receipt?.decision.workGroups?.length ?? 0;
+			const dispatched = harness.getChildren().length;
+			return { groups, dispatched };
+		} catch {
+			return undefined;
+		}
+	};
+
 	try {
 		await mod.initTwoPhaseReview({
 			pi,
 			readTodos,
+			readValidation,
+			readDelegation,
 			workspaceRoot: () => {
 				try {
 					return realpathSync(process.cwd());
@@ -748,6 +857,12 @@ async function initAutoContinue(pi: ExtensionAPI): Promise<void> {
 		});
 		logStartup("[pi-harness] Delegation harness initialized");
 
+		// The lifecycle of a continuation the harness started itself: the
+		// status stays "RUN" until the turn settles.
+		const { ContinuationGate } = await import(
+			"./packages/jev-judge/dist/continuation-status.js"
+		);
+
 		// The Jev key is missing: the fix commands must survive every later
 		// message with the same label - `HarnessStartupStatus.update` replaces
 		// a message by label, so a later "verifying API..." line would drop
@@ -774,6 +889,96 @@ async function initAutoContinue(pi: ExtensionAPI): Promise<void> {
 		let lastUserMessage: Date | null = null;
 		let autoContinueTimer: NodeJS.Timeout | null = null;
 		let _inferenceInProgress = false; // Track for overlap prevention
+		// A continuation was dispatched and its turn has not settled yet.
+		// The gate owns that state: the status stays "RUN" until the turn
+		// settles, and no timer may clear it in the meantime.
+		const _continuation = new ContinuationGate();
+		// The measured scope that was already handed to the agent. The
+		// plan is sent once per scope, not once per message.
+		let _lastDelegationPlanFingerprint: string | null = null;
+
+		/**
+		 * Hand the measured delegation plan to the agent.
+		 *
+		 * The harness measured the scope; the agent is the one that sends
+		 * the groups to the sub-agent tool. The message says so, and the
+		 * plan is not repeated for a scope the agent already knows.
+		 */
+		async function handDelegationPlanToAgent(
+			decision: DelegationDecisionLike | null,
+			fingerprint: string,
+		): Promise<void> {
+			if (!decision) return;
+			if (_lastDelegationPlanFingerprint === fingerprint) return;
+			let message: string | null = null;
+			try {
+				const harness = await import("./packages/jev-judge/dist/delegation-harness.js");
+				message = harness.buildDelegationSteer(decision);
+			} catch (error) {
+				logToFile("[Delegation]", "The delegation plan could not be built:", oneLineError(error));
+				return;
+			}
+			if (!message) return;
+			_lastDelegationPlanFingerprint = fingerprint;
+			try {
+				await pi.sendUserMessage(message, { deliverAs: "steer" });
+				logToFile("[Delegation]", "The measured delegation plan was handed to the agent");
+			} catch (error) {
+				logToFile("[Delegation]", "The delegation steer failed:", oneLineError(error));
+			}
+		}
+
+		// The children of a delegation are observed, not assumed. The
+		// harness does not dispatch anything: the agent sends the measured
+		// groups to the sub-agent tool, and the tool events are the proof
+		// that a child really ran.
+		pi.on("tool_execution_start", (event) => {
+			try {
+				const toolEvent = event as {
+					toolCallId?: string;
+					toolName?: string;
+					args?: unknown;
+				};
+				const child = sharedState.delegationHarness?.observeToolStart?.({
+					toolCallId: String(toolEvent.toolCallId ?? ""),
+					toolName: String(toolEvent.toolName ?? ""),
+					args: toolEvent.args,
+				});
+				if (child) {
+					logToFile(
+						"[Delegation]",
+						`A child was dispatched: ${child.toolName} (${child.groupId ?? "no group"})`,
+					);
+				}
+			} catch (error) {
+				logToFile("[Delegation]", "The child could not be recorded:", oneLineError(error));
+			}
+		});
+
+		pi.on("tool_execution_end", (event) => {
+			try {
+				const toolEvent = event as {
+					toolCallId?: string;
+					toolName?: string;
+					result?: unknown;
+					isError?: boolean;
+				};
+				const child = sharedState.delegationHarness?.observeToolEnd?.({
+					toolCallId: String(toolEvent.toolCallId ?? ""),
+					toolName: String(toolEvent.toolName ?? ""),
+					result: toolEvent.result,
+					isError: toolEvent.isError === true,
+				});
+				if (child) {
+					logToFile(
+						"[Delegation]",
+						`The child ended: ${child.toolName} (${child.status})${child.model ? `, model ${child.model}` : ""}`,
+					);
+				}
+			} catch (error) {
+				logToFile("[Delegation]", "The child could not be closed:", oneLineError(error));
+			}
+		});
 		let _sessionId = Date.now().toString(36); // Track session for cancellation
 		let _lastNotifiedQuestion = ""; // Track last question to prevent repeat notifications
 		let _completedNotifiedFor: string | null = null; // Track completion notification deduplication
@@ -1478,8 +1683,11 @@ async function initAutoContinue(pi: ExtensionAPI): Promise<void> {
 					sharedState.waitingForUserSince = null;
 					_lastNotifiedQuestion = "";
 
-					// Clear status after short delay
-					setTimeout(() => updateAutoContinueStatus("IDLE"), 2000);
+					// The status stays "RUN" until the turn that the steer
+					// started has settled. A timer would clear it while the
+					// agent is still working, and the status would claim
+					// that nothing runs any more.
+					_continuation.begin();
 				}
 				_inferenceInProgress = false;
 			} catch {
@@ -1523,6 +1731,9 @@ async function initAutoContinue(pi: ExtensionAPI): Promise<void> {
 						);
 					},
 				});
+				// The two-phase workflow reads the same ledger: the phase gate
+				// and the completion report must never disagree about a tier.
+				sharedState.validationLedger = validationLedger;
 				// SAFETY: ctx is ExtensionContext with sessionManager, isIdle, hasPendingMessages
 				// dispatch uses pi.sendUserMessage for actual message delivery
 				todoContinuationController = new TodoContinuationController(
@@ -1546,6 +1757,7 @@ async function initAutoContinue(pi: ExtensionAPI): Promise<void> {
 			// keep a timer alive nor block a later continuation.
 			todoContinuationController?.dispose?.();
 			todoContinuationController = null;
+			sharedState.validationLedger = null;
 		});
 
 		// --- task-intake: Automatic todo capture from user requests -----------
@@ -1637,25 +1849,33 @@ async function initAutoContinue(pi: ExtensionAPI): Promise<void> {
 					];
 					const isLargeRefactor = largeRefactorPatterns.some((p) => p.test(lowerMsg));
 					if (isLargeRefactor) {
-						logToFile("[Delegation]", "Large refactor request detected, triggering assessment");
-						// Trigger delegation assessment asynchronously
-						sharedState.delegationHarness.assess({
-							estimatedFiles: 10,
-							observedFiles: 10,
-							estimatedCallSites: 50,
-							observedCallSites: 50,
-							independentComponents: 2,
-							tightlyCoupled: false,
-							isMechanical: false,
-							isComplex: true,
-							fileTypes: {},
-							fingerprint: `user-msg-${Date.now()}`,
-						}, "user-request").then((decision: { strategy: string; reason: string } | null) => {
-						if (decision) {
-							logToFile("[Delegation]", `Assessment result: ${decision.strategy} - ${decision.reason}`);
-						}
-					}).catch((e: unknown) => logToFile("[Delegation]", "Assessment error:", String(e)));
-				}
+						// The scope is measured in the workspace: the request
+						// names the files, or the session changed them. A
+						// number that nobody counted is not a scope, so the
+						// assessment waits for the measurement.
+						logToFile("[Delegation]", "Large refactor request detected, measuring the scope");
+						measureDelegationScope(userMessage)
+							.then((facts) => {
+								if (!facts) {
+									logToFile("[Delegation]", "No measurable scope in the request - no delegation assessment");
+									return null;
+								}
+								return sharedState.delegationHarness
+									.assess(facts, `user-request-${facts.fingerprint}`)
+									.then(async (decision: DelegationDecisionLike | null) => {
+										if (decision) {
+											logToFile(
+												"[Delegation]",
+												`Assessment: ${decision.strategy} - ${decision.reason} (${decision.workGroups?.length ?? 0} measured group(s), dispatched=${decision.dispatched === true})`,
+											);
+										}
+										await handDelegationPlanToAgent(decision, facts.fingerprint);
+										return decision;
+									})
+									.catch((e: unknown) => logToFile("[Delegation]", "Assessment error:", String(e)));
+							})
+							.catch((e: unknown) => logToFile("[Delegation]", "Scope measurement failed:", String(e)));
+					}
 				}
 
 				// Temporary pause for user input processing (auto-clears on next decision)
@@ -1721,6 +1941,13 @@ async function initAutoContinue(pi: ExtensionAPI): Promise<void> {
 			// consuming the retry budget.
 			todoContinuationController?.releaseContinuationGuard?.("agent_settled");
 
+			// The turn that a continuation started has settled: the status
+			// returns to idle, unless the handler below dispatches the next
+			// continuation.
+			if (_continuation.settle()) {
+				updateAutoContinueStatus("IDLE");
+			}
+
 			// Don't continue if user is waiting for response
 			if (waitingForUserSince) {
 				todoContinuationController?.clearQueue();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-harness-runtime",
-  "version": "1.1.451",
+  "version": "1.1.453",
   "description": "[BETA] Codex-style /usage status + autonomous coding harness for pi. Not production ready — expect breaking changes.",
   "type": "module",
   "scripts": {

package/packages/agent-policy/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/agent-policy",
-  "version": "1.1.451",
+  "version": "1.1.453",
   "description": "Agent policy runtime for pi-harness - enforces mandatory rule delivery and mutation gating",
   "type": "module",
   "main": "./dist/index.js",

package/packages/auth/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/auth",
-  "version": "1.1.451",
+  "version": "1.1.453",
   "description": "pi-harness-runtime — auth",
   "type": "module",
   "main": "./dist/index.js",

package/packages/autonomous-runtime/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/autonomous-runtime",
-  "version": "1.1.451",
+  "version": "1.1.453",
   "description": "Autonomous Operations Runtime — task inbox, lease management, and worker lifecycle (RFC-0101)",
   "type": "module",
   "main": "./dist/index.js",

package/packages/checkpoint/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/checkpoint",
-  "version": "1.1.451",
+  "version": "1.1.453",
   "description": "Enhanced checkpoint system with incremental snapshots, diff-based storage, and recovery strategies",
   "type": "module",
   "main": "./dist/index.js",

package/packages/clipboard/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/clipboard",
-  "version": "1.1.451",
+  "version": "1.1.453",
   "type": "module",
   "main": "src/index.ts",
   "exports": {

package/packages/codex-watcher/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/codex-watcher",
-  "version": "1.1.451",
+  "version": "1.1.453",
   "description": "Watches Codex CLI sessions and emits visible messages for PING-PONG monitoring",
   "type": "module",
   "main": "./dist/src/index.js",

package/packages/config-capture/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moocoding/config-capture",
-  "version": "1.1.451",
+  "version": "1.1.453",
   "description": "Auto-capture API-fetched configuration values to AGENTS.md",
   "type": "module",
   "main": "src/index.ts",

package/packages/contracts/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/contracts",
-  "version": "1.1.451",
+  "version": "1.1.453",
   "type": "module",
   "description": "RPC schema definitions for pi-harness runtime",
   "main": "./dist/index.js",

package/packages/cookie-sanitizer/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/cookie-sanitizer",
-  "version": "1.1.451",
+  "version": "1.1.453",
   "description": "pi-harness-runtime — cookie sanitizer (provider-quota cookie file normaliser)",
   "type": "module",
   "main": "./dist/index.js",

package/packages/evaluation-engine/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/evaluation-engine",
-  "version": "1.1.451",
+  "version": "1.1.453",
   "description": "Evaluation engine for pi-harness runtime (RFC-0057)",
   "type": "module",
   "main": "./dist/index.js",

package/packages/event-bus/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/event-bus",
-  "version": "1.1.451",
+  "version": "1.1.453",
   "type": "module",
   "main": "src/index.ts",
   "exports": {

package/packages/event-store/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/event-store",
-  "version": "1.1.451",
+  "version": "1.1.453",
   "type": "module",
   "main": "src/index.ts",
   "exports": {

package/packages/experience-replay/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/experience-replay",
-  "version": "1.1.451",
+  "version": "1.1.453",
   "description": "Experience replay for debugging and reproducibility (RFC-0059)",
   "type": "module",
   "main": "./dist/index.js",