pi-crew 0.11.24 → 0.11.26

package/src/runtime/broker/delegate/delegate-finalize.ts

@@ -0,0 +1,179 @@
+/**
+ * delegate-finalize.ts — broker-side SETTLE path for a delegate grandchild
+ * (ADR-5 §1/§5). Moved out of the `delegate.request` handler's fire-and-forget
+ * async IIFE (crew-broker.ts) by fix-wave 6 — behaviour change, not pure code
+ * motion: R43-N4 + R44-N4 are fixed here.
+ *
+ * R43-N4 (2026-10-19): the grandchild's fenced result used to be appended to
+ * the PARENT task's mailbox unconditionally. When the parent had already
+ * reached a terminal status (cancelled by a budget abort, failed, killed) that
+ * row was written into a mailbox nobody reads again — the result was silently
+ * dropped, permanently. {@link delegateResultTarget} now decides the
+ * destination from the parent record read INSIDE the run lock: a terminal (or
+ * missing) parent redirects the result to the RUN-level inbox (the
+ * orchestrator/leader channel) with `data.reroutedFrom` + a
+ * `delegate.rerouted` event, so a dead parent can no longer swallow an
+ * in-flight grandchild's output.
+ *
+ * R44-N4 (2026-10-19): usage roll-up is now BROKER-SIDE. Before this change
+ * the reservation written at admission was reconciled against the CHILD's own
+ * `message_end` self-report (`actual = clamp(selfReported, 0, reserved)`), so a
+ * child that under-reported refunded almost its whole reservation — the budget
+ * charge was self-attested (`probe-n4`: under-report refunded 49 999 of a
+ * 50 000 reserve). The charge is now the HOST-decided reservation, full stop:
+ * the admission reserve IS the spend, and nothing at settle time can reduce
+ * it. The child's number is still recorded on `delegate.rolled_up`
+ * (`selfReportedTokens`) for observability only — never as a charge.
+ * Consequence: the P2-8c "best-effort refund when finalize fails" path is gone
+ * with it (a failed finalize must NOT hand back budget the run may have
+ * consumed — the conservative direction).
+ */
+
+import { isTerminalTaskStatus } from "../../../state/contracts.ts";
+import { withRunLockSync } from "../../../state/coordination/locks.ts";
+import { appendMailboxMessageAsync } from "../../../state/coordination/mailbox.ts";
+import { loadRunManifestById, saveRunTasks } from "../../../state/stores/state-store.ts";
+import type { TeamTaskState } from "../../../state/types.ts";
+import { logInternalError } from "../../../utils/internal-error.ts";
+import { recordDelegateEvent } from "./delegate-event.ts";
+
+/** Destination of a settled grandchild's fenced result. */
+export type DelegateResultTarget = "parent" | "run-mailbox";
+
+export interface DelegateFinalizeInput {
+	/** Broker cwd (manifest lookup). */
+	brokerCwd: string;
+	runId: string;
+	parentTaskId: string;
+	/** Grandchild shadow-task id (`gc-*`) — also the mailbox `from` suffix. */
+	subId: string;
+	/** Already-fenced result body (caller neutralizes smuggled fence markers). */
+	fenced: string;
+	ok: boolean;
+	timedOut?: boolean;
+	/** Pessimistic reservation written at admission (0 = unmetered request).
+	 *  THIS is the broker-side charge — see the R44-N4 note above. */
+	reservedTokens: number;
+	/** Child-emitted usage, AUDIT ONLY (self-attested, never charged). */
+	selfReportedTokens?: number;
+}
+
+export interface DelegateFinalizeOutcome {
+	/** Where the result went, or "none" when the run record was gone. */
+	delivery: DelegateResultTarget | "none";
+	/** Broker-side charge applied to the parent allocation (unit: TOKENS). */
+	chargedTokens: number;
+}
+
+/**
+ * R43-N4: pick the result destination from the parent task RECORD.
+ *
+ * - parent still live (queued/running/waiting) → its own mailbox (unchanged);
+ * - parent gone or terminal (completed/failed/cancelled/skipped/…) → the run
+ *   mailbox, i.e. the leader channel. Terminal includes `completed`: a parent
+ *   that finished before its grandchild settled cannot consume the row either.
+ */
+export function delegateResultTarget(parentStatus: TeamTaskState["status"] | undefined): DelegateResultTarget {
+	if (parentStatus === undefined) return "run-mailbox";
+	return isTerminalTaskStatus(parentStatus) ? "run-mailbox" : "parent";
+}
+
+/** M3-5/R43-N3: the terminal event for a settled grandchild — owner-abort is
+ *  distinct from the grandchild's own deadline in the audit trail. */
+export function delegateTerminalEvent(outcome: {
+	ok: boolean;
+	timedOut?: boolean;
+	cancelled?: boolean;
+}): "delegate.completed" | "delegate.timed_out" | "delegate.cancelled" {
+	if (outcome.cancelled === true) return "delegate.cancelled";
+	return outcome.timedOut === true ? "delegate.timed_out" : "delegate.completed";
+}
+
+/**
+ * Settle a grandchild: deliver the fenced result, charge the budget, terminal-
+ * flip the shadow record. All writes happen INSIDE one run lock, computed off
+ * a fresh disk read (never a pre-spawn snapshot).
+ *
+ * Never throws: every failure is logged (the caller is a detached async task —
+ * a throw here would become an unhandled rejection).
+ */
+export function finalizeDelegateResult(input: DelegateFinalizeInput): DelegateFinalizeOutcome {
+	try {
+		const loaded = loadRunManifestById(input.brokerCwd, input.runId);
+		if (!loaded) return { delivery: "none", chargedTokens: 0 };
+		// Boxed state — read back AFTER the lock closure (a plain `let` would be
+		// narrowed to its initial literal by control-flow analysis).
+		const state: { delivery: DelegateResultTarget | "none" } = { delivery: "none" };
+		withRunLockSync(loaded.manifest, () => {
+			const latest = loadRunManifestById(input.brokerCwd, input.runId);
+			if (!latest) return;
+			const parent = latest.tasks.find((t) => t.id === input.parentTaskId);
+			const delivery = delegateResultTarget(parent?.status);
+			state.delivery = delivery;
+			// Durable delivery (ADR-5 §1): fenced result into the parent task's
+			// mailbox, or into the run inbox when the parent can no longer read
+			// it (R43-N4). `appendMailboxMessageAsync` is fire-and-forget here —
+			// the append itself takes the mailbox file lock, and blocking the run
+			// lock on it would serialize every settle behind disk I/O.
+			void appendMailboxMessageAsync(latest.manifest, {
+				direction: "inbox",
+				from: `delegate:${input.subId}`,
+				to: delivery === "parent" ? input.parentTaskId : "leader",
+				...(delivery === "parent" ? { taskId: input.parentTaskId } : {}),
+				body: input.fenced,
+				kind: "response",
+				data: {
+					subId: input.subId,
+					ok: input.ok,
+					timedOut: input.timedOut === true,
+					...(delivery === "parent" ? {} : { reroutedFrom: input.parentTaskId, reason: "parent-terminal" }),
+				},
+			}).catch((err) =>
+				logInternalError(
+					"crew-broker.delegate.mailbox",
+					err instanceof Error ? err : new Error(String(err)),
+					`runId=${input.runId} subId=${input.subId} delivery=${delivery}`,
+				),
+			);
+			if (delivery === "run-mailbox") {
+				recordDelegateEvent(latest.manifest, "delegate.rerouted", input.parentTaskId, {
+					subId: input.subId,
+					parentStatus: parent?.status ?? "missing",
+				});
+			}
+			// R44-N4: no refund, no reconciliation write — the admission reserve
+			// is the charge, so `allocation.tokensSpent` already holds it on disk.
+			// Only audit the (untrusted) child number.
+			if (input.reservedTokens > 0) {
+				recordDelegateEvent(latest.manifest, "delegate.rolled_up", input.parentTaskId, {
+					subId: input.subId,
+					chargedTokens: input.reservedTokens,
+					...(input.selfReportedTokens !== undefined ? { selfReportedTokens: input.selfReportedTokens } : {}),
+				});
+			}
+			// S1#1 (verifier N1): the terminal flip is UNCONDITIONAL — never
+			// depends on a reservation. RR-012 F16: onSpawn promoted the record to
+			// "running" during execution; this flip terminalizes every settle path.
+			saveRunTasks(
+				latest.manifest,
+				latest.tasks.map((t) =>
+					t.id === input.subId
+						? {
+								...t,
+								status: input.ok ? ("completed" as const) : ("failed" as const),
+								completedAt: new Date().toISOString(),
+							}
+						: t,
+				),
+			);
+		});
+		return { delivery: state.delivery, chargedTokens: input.reservedTokens };
+	} catch (err) {
+		logInternalError(
+			"crew-broker.delegate.finalize",
+			err instanceof Error ? err : new Error(String(err)),
+			`runId=${input.runId} subId=${input.subId}`,
+		);
+		return { delivery: "none", chargedTokens: 0 };
+	}
+}

package/src/runtime/broker/protocol/wait-resolve.ts

@@ -17,11 +17,76 @@
 import { withRunLockSync } from "../../../state/coordination/locks.ts";
 import { appendEventAsync } from "../../../state/event-log/event-log.ts";
 import { loadRunManifestById, saveRunManifest, saveRunTasks } from "../../../state/stores/state-store.ts";
+import type { TeamRunManifest, TeamTaskState } from "../../../state/types.ts";
 import { logInternalError } from "../../../utils/internal-error.ts";
 import type { ServerConnection } from "./connection-state.ts";
 import { parseWaitResolveParams } from "./request-parsers.ts";
 import { recordWaitPolicyRejection } from "./wait-auth.ts";
 
+/**
+ * M3-6 (R21-M1, fix-wave 6): resolve ONE park without un-shielding the others.
+ *
+ * `manifest.waitState` is a single run-level slot, but more than one task can
+ * be parked at the same time (concurrent `ask` calls / goal-loop + a worker).
+ * `isWaitAnswerPending(manifest)` reads ONLY this slot, and it is what keeps the
+ * stale-reconciler / crash-recovery from repairing (killing) a live worker that
+ * stopped heartbeating while parked. The pre-fix resolve cleared the slot
+ * whenever it pointed at the resolved park — so once the SECOND park resolved,
+ * the FIRST (still parked) task lost its shield entirely and could be
+ * stale-reaped while awaiting a human answer.
+ *
+ * Fix (single-slot contract preserved, no schema change): when the slot points at
+ * the park we just ended, RE-POINT it at the still-parked task whose shield must
+ * survive instead of blindly clearing it. The latest deadline wins so the run
+ * shield never expires while ANY park is still live (expiring early would
+ * re-open the same window; living slightly long only delays repair — the
+ * fail-safe direction the rest of this module already takes). A slot that
+ * belongs to a DIFFERENT (newer) park is left untouched, exactly as before.
+ *
+ * M4-R1(b) (fix-wave 6 residual, same class as M3-6): the identical
+ * clear-not-repoint bug lived in the SIBLING slot writers — respond.ts's
+ * requeue path (respond.ts:250-251) and dispatch-batch.ts's ask-timeout
+ * requeue (:198-199). Both scoped the CLEAR by taskId (WP-2 round-1 P3), but
+ * when the ended park owned the slot and a THIRD task was still parked they
+ * dropped the slot, re-opening the un-shielded window M3-6 had closed for
+ * wait.resolve. The helper is exported (predicate form, so the sibling writers
+ * can pass their requeued-id SET) and reused verbatim there.
+ */
+export function repointWaitState(
+	tasks: TeamTaskState[],
+	current: TeamRunManifest["waitState"],
+	isEnded: (taskId: string, questionId: string) => boolean,
+): TeamRunManifest["waitState"] {
+	if (current === undefined) return undefined;
+	if (!isEnded(current.taskId, current.questionId)) return current;
+	let next: TeamTaskState | undefined;
+	for (const task of tasks) {
+		if (task.status !== "waiting" || task.waiting === undefined) continue;
+		if (isEnded(task.id, task.waiting.questionId)) continue;
+		if (next === undefined || task.waiting.deadline > (next.waiting?.deadline ?? 0)) next = task;
+	}
+	if (next?.waiting === undefined) return undefined;
+	return {
+		taskId: next.id,
+		questionId: next.waiting.questionId,
+		askedAt: next.waiting.askedAt,
+		deadline: next.waiting.deadline,
+	};
+}
+
+/** wait.resolve's single-park view of {@link repointWaitState}. */
+function repointedWaitState(
+	tasks: TeamTaskState[],
+	current: TeamRunManifest["waitState"],
+	endedTaskId: string,
+	endedQuestionId: string,
+): TeamRunManifest["waitState"] {
+	return repointWaitState(tasks, current, (taskId, questionId) => taskId === endedTaskId && questionId === endedQuestionId);
+}
+
+/** @internal M3-6 test export — exercise the scoped-clear repoint directly. */
+export const __test__repointedWaitState = repointedWaitState;
+
 export interface WaitResolveHelpers {
 	sendError(conn: ServerConnection, id: string, code: string, message: string): void;
 	sendResult(conn: ServerConnection, id: string, result: unknown): void;
@@ -100,13 +165,14 @@ export async function handleWaitResolve(
 		// the flip, so respond_delivered records the same worker-pid evidence
 		// its respond_missed twin does root-side.
 		const workerPid = task.heartbeat?.pid ?? task.checkpoint?.childPid;
-		// waitState is a single run-level slot: clear it ONLY when it points
-		// at this exact question — never clobber another task's newer park.
-		const waitState = fresh.manifest.waitState;
-		const clearWaitState = waitState !== undefined && waitState.taskId === taskId && waitState.questionId === parsed.questionId;
+		// waitState is a single run-level slot: never clobber another task's newer
+		// park. M3-6 (R21-M1): and never un-shield a task that is STILL parked —
+		// when the slot pointed at the park we are ending, re-point it at the
+		// surviving park (repointedWaitState) instead of clearing it.
+		const waitState = repointedWaitState(fresh.tasks, fresh.manifest.waitState, taskId, parsed.questionId);
 		const updatedManifest = {
 			...fresh.manifest,
-			...(clearWaitState ? { waitState: undefined } : {}),
+			waitState,
 			updatedAt: new Date().toISOString(),
 		};
 		saveRunTasks(updatedManifest, updatedTasks);

package/src/runtime/budget-enforcement.ts

@@ -19,8 +19,9 @@ import { flushPendingAtomicWrites } from "../state/atomic-write.ts";
 import { appendEventAsync } from "../state/event-log/event-log.ts";
 import { loadRunManifestById, saveRunManifestAsync, saveRunTasksAsync, updateRunStatus } from "../state/stores/state-store.ts";
 import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
-import { aggregateUsage, formatTokens } from "../state/usage.ts";
+import { formatTokens, taskTokenTotal } from "../state/usage.ts";
 import { logInternalError } from "../utils/internal-error.ts";
+import { abortRunDelegates } from "./broker/delegate/delegate-abort.ts";
 import { MERGE_LOCK_BUSY_RETRY_DELAYS_MS, withRunLockBusyRetryAsync } from "./broker/protocol/lock-busy.ts";
 import { saveCrewAgents } from "./crew-agent-records.ts";
 import { cancelNonTerminalTasks, markBlocked } from "./dispatch-batch.ts";
@@ -47,6 +48,16 @@ export interface PerTaskBudgetCheckResult {
  * Check cumulative token usage against per-task budget thresholds.
  * Returns a structured result — callers decide how to act (warn vs abort).
  *
+ * M3-4 / R43-N2 (2026-10-19 fix-wave 6): `totalUsed` is now the FULL run cost
+ * — each task's own tokens PLUS the delegate spend booked on it
+ * (`taskTokenTotal`, i.e. `allocation.tokensSpent`). Pre-fix the check summed
+ * `task.usage` only, and grandchildren never write `task.usage` (they are
+ * broker-managed shadow records), so a nested delegate storm could burn an
+ * unbounded multiple of `budgetTotal` without ever tripping the abort
+ * (probe-verified round 43). The delegate amount is the BROKER-SIDE tally —
+ * the host-decided admission reservation — not the child's self-report
+ * (R44-N4), so an under-reporting child cannot hide its spend.
+ *
  * Exported for unit testing.
  */
 export function checkPerTaskBudget(
@@ -56,8 +67,8 @@ export function checkPerTaskBudget(
 	budgetAbort: number,
 	fairShareFraction = 0.5,
 ): PerTaskBudgetCheckResult {
-	const usage = aggregateUsage(tasks);
-	const totalUsed = (usage?.input ?? 0) + (usage?.output ?? 0) + (usage?.cacheWrite ?? 0);
+	let totalUsed = 0;
+	for (const task of tasks) totalUsed += taskTokenTotal(task);
 	const abort = totalUsed >= budgetAbort * budgetTotal;
 	const warning = !abort && totalUsed >= budgetWarning * budgetTotal;
 	// Fair share threshold based on TOTAL budget, not remaining budget.
@@ -66,8 +77,9 @@ export function checkPerTaskBudget(
 	const fairShareThreshold = budgetTotal * fairShareFraction;
 	const fairShareViolators: string[] = [];
 	for (const task of tasks) {
-		if (!task.usage) continue;
-		const taskTotal = (task.usage.input ?? 0) + (task.usage.output ?? 0) + (task.usage.cacheWrite ?? 0);
+		// M3-4: a delegate-heavy parent is charged for its grandchildren too.
+		const taskTotal = taskTokenTotal(task);
+		if (taskTotal === 0) continue;
 		// Only flag tasks that individually consumed a significant portion of the
 		// budget (>10% of total) AND exceeded the fair share threshold.
 		if (fairShareThreshold > 0 && taskTotal > fairShareThreshold && taskTotal > budgetTotal * 0.1) {
@@ -128,6 +140,12 @@ export async function terminaliseRunWithDrain(
 	// and be clobbered to "skipped" (observed CI flake: 02_b skipped on
 	// team-runner-budget-abort-inflight across v0.9.59 / cfd68d06 / 12386af2).
 	const inflightTaskIds = ctx.dispatchedTaskIds;
+	// M3-5/R43-N3: a run going terminal must also cancel its in-flight DELEGATE
+	// grandchildren. This drain only covers the run's own dispatch units; the
+	// grandchildren live in the broker's abort registry (fire-and-forget spawn
+	// before the fix, so they outlived every abort path by up to their own 24h
+	// deadline while still spending and holding nested slots).
+	abortRunDelegates(ctx.manifest.runId, opts.failedReason.slice(0, 120) || "run-terminal");
 	const outcomes = await drainPendingUnits(ctx.pendingUnits, ctx.runController);
 	const validResults: { manifest: TeamRunManifest; tasks: TeamTaskState[] }[] = [];
 	for (const outcome of outcomes) {
@@ -271,7 +289,9 @@ export async function enforceRunBudget(ctx: SchedulerContext): Promise<Scheduler
 		for (const violatorId of budgetCheck.fairShareViolators) {
 			const violator = tasks.find((t) => t.id === violatorId);
 			if (!violator) continue;
-			const taskTotal = (violator.usage?.input ?? 0) + (violator.usage?.output ?? 0) + (violator.usage?.cacheWrite ?? 0);
+			// M3-4/R43-N2: same full-cost rule as the threshold check (own usage
+			// + booked delegate spend) so the message matches the decision.
+			const taskTotal = taskTokenTotal(violator);
 			const message = `Task '${violatorId}' consumed ${formatTokens(taskTotal)} (${Math.round((taskTotal / input.budgetTotal) * 100)}% of total budget) — exceeds fair share`;
 			// ROUND 12: console → logInternalError, explicit "warn" severity.
 			logInternalError("team-runner.fair-share", new Error(message), `runId=${manifest.runId} taskId=${violatorId}`, "warn");

package/src/runtime/chain-parser.ts

@@ -125,10 +125,12 @@ function tokenize(input: string): Token[] {
 			continue;
 		}
 
-		// Name
-		if (/[a-zA-Z_]/.test(input[i]!)) {
+		// Name (a leading '@' is part of a @team reference — R14-C1: without this
+		// the tokenizer threw on '@', the whole DSL parse fell back to the simple
+		// splitter, and parallel(@a, @b) silently degraded into garbage steps.)
+		if (/[a-zA-Z_]/.test(input[i]!) || (input[i] === "@" && /[a-zA-Z_]/.test(input[i + 1] ?? ""))) {
 			let name = "";
-			while (i < input.length && /[a-zA-Z0-9_.-]/.test(input[i]!)) {
+			while (i < input.length && /[a-zA-Z0-9_.@-]/.test(input[i]!)) {
 				name += input[i];
 				i++;
 			}

package/src/runtime/chain-runner.ts

@@ -182,6 +182,9 @@ export class ChainRunner {
 		const startTime = Date.now();
 		let totalTokens = 0;
 		const allHandoffs: HandoffSummary[] = [];
+		// R14-C5: a break leaves later steps UNEXECUTED. Tracked explicitly so the
+		// success predicate cannot report a truncated chain as complete.
+		let brokeEarly = false;
 
 		for (let i = 0; i < spec.steps.length; i++) {
 			const step = spec.steps[i];
@@ -228,6 +231,7 @@ export class ChainRunner {
 				} else {
 					// Stop chain on step failure unless configured to continue
 					if (!spec.continueOnError && !step.continueOnError) {
+						brokeEarly = true;
 						break;
 					}
 				}
@@ -261,15 +265,25 @@ export class ChainRunner {
 
 				// Stop chain on failure unless configured to continue
 				if (!spec.continueOnError && !step.continueOnError) {
+					brokeEarly = true;
 					break;
 				}
 			}
 		}
 
+		// R14-C5 (false-green): the old predicate was `every(outcome !== "failure")`,
+		// so a `partial` step — which breaks the chain exactly like a failure — still
+		// produced success:true, and dispatch printed "Chain completed" + status ok
+		// for a chain whose remaining steps never ran. An empty spec was vacuously
+		// green for the same reason. Success now requires: at least one step, no
+		// early break, every planned step executed, and every outcome `success`.
+		const allStepsExecuted = stepResults.length === spec.steps.length;
+		const allOutcomesSuccessful = stepResults.every((s) => s.outcome === "success");
+
 		return {
 			steps: stepResults,
 			totalDuration: Date.now() - startTime,
-			success: stepResults.every((s) => s.outcome !== "failure"),
+			success: spec.steps.length > 0 && !brokeEarly && allStepsExecuted && allOutcomesSuccessful,
 			totalTokens: totalTokens > 0 ? totalTokens : undefined,
 			totalHandoffs: allHandoffs,
 		};
@@ -403,34 +417,39 @@ export class ChainRunner {
 
 	/**
 	 * Convert DSL AST steps (from chain-parser) to ChainSpec.
+	 *
+	 * R14-C1: `parallel(...)` groups are FLATTENED into ordered steps. They used to
+	 * be parked in `step.context.parallel`, which no consumer ever read — the whole
+	 * group collapsed into one step literally named "parallel" and never ran its
+	 * members. Chain execution is sequential by contract (see runChain), so the
+	 * members run in source order and each keeps its own step result, which means a
+	 * failing member stays visible instead of vanishing into a dropped group.
 	 */
 	private dslToChainSpec(dslSteps: DSLChainStep[], chainString: string): ChainSpec {
-		const steps: ChainStep[] = dslSteps.map((dslStep, index) => {
-			// For parallel groups, use a synthetic step name
+		const steps: ChainStep[] = [];
+
+		// Recursive so nested groups (parallel(a, parallel(b, c))) flatten too.
+		const pushStep = (dslStep: DSLChainStep): void => {
 			if (dslStep.parallel) {
-				return {
-					name: dslStep.name,
-					context: {
-						parallel: dslStep.parallel.map((p) => ({
-							name: p.name,
-							loopCount: p.loopCount,
-							withContext: p.withContext,
-							args: p.args,
-						})),
-					},
-					loopCount: dslStep.loopCount,
-				};
+				for (const member of dslStep.parallel) pushStep(member);
+				return;
 			}
+
 			const step: ChainStep = { name: dslStep.name };
-			if (dslStep.loopCount)
-				step.context = {
-					...step.context,
-					loopCount: dslStep.loopCount,
-				};
+
+			// '@team' reference — same resolution the simple parser applies to @refs.
+			if (dslStep.name.startsWith("@")) {
+				const team = this.sanitizeIdentifier(dslStep.name.slice(1));
+				if (team.length > 0) step.team = team;
+			}
+
+			if (dslStep.loopCount) step.context = { ...step.context, loopCount: dslStep.loopCount };
 			if (dslStep.withContext) step.context = { ...step.context, withContext: true };
 			if (dslStep.args && dslStep.args.length > 0) step.context = { ...step.context, args: dslStep.args };
-			return step;
-		});
+			steps.push(step);
+		};
+
+		for (const dslStep of dslSteps) pushStep(dslStep);
 
 		// Extract global overrides using existing logic
 		const globalModel = this.extractGlobalFlag(chainString, "global-model");

package/src/runtime/child-pi/mock-fixtures.ts

@@ -49,8 +49,15 @@ export async function runMockChildPi(
 	// SECURITY: Log mock mode activation prominently for audit trail
 	logInternalError("child-pi.mock", new Error(`Mock mode active: ${mock}`), "NOT running real agents");
 
+	// M3-2 (R47-3/V4): the verifier output contract requires a PASS:/FAIL:
+	// verdict line; happy-path mocks must emit contract-shaped output for
+	// verifier-role tasks or the (now real) verdict consumer marks the evidence
+	// unverified and the green contract blocks the run (fail-closed — correct
+	// for real verifiers, wrong for success mocks).
+	const verdictSuffix = input.role === "verifier" ? "\nPASS: mock verifier — mock success" : "";
+
 	if (mock === "success") {
-		const stdout = `[MOCK] Success for ${input.agent.name}\n`;
+		const stdout = `[MOCK] Success for ${input.agent.name}${verdictSuffix}\n`;
 		await observe(input, stdout);
 		return { exitCode: 0, stdout, stderr: "" };
 	}
@@ -62,7 +69,7 @@ export async function runMockChildPi(
 		// (default 1500ms, cap 5000ms) via PI_TEAMS_MOCK_STEER_WINDOW_MS.
 		const windowMs = Number(getCrewEnv("PI_TEAMS_MOCK_STEER_WINDOW_MS") ?? "1500");
 		await new Promise((resolve) => setTimeout(resolve, Math.min(windowMs, 5000)));
-		const text = `[MOCK] JSON success for ${input.agent.name}`;
+		const text = `[MOCK] JSON success for ${input.agent.name}${verdictSuffix}`;
 		const stdout = `${JSON.stringify({ type: "message", message: { role: "assistant", content: [{ type: "text", text }] } })}\n${JSON.stringify({ type: "message_end", usage: { input: 10, output: 5, cost: 0.001, turns: 1 } })}\n`;
 		await observe(input, stdout);
 		return { exitCode: 0, stdout, stderr: "" };
@@ -141,7 +148,7 @@ export async function runMockChildPi(
 							},
 						],
 					})}\nADAPTIVE_PLAN_JSON_END`
-				: `[MOCK] JSON success for ${input.agent.name}`;
+				: `[MOCK] JSON success for ${input.agent.name}${verdictSuffix}`;
 		const stdout = `${JSON.stringify({ type: "message", message: { role: "assistant", content: [{ type: "text", text }] } })}\n${JSON.stringify({ type: "message_end", usage: { input: 10, output: 5, cost: 0.001, turns: 1 } })}\n`;
 		await observe(input, stdout);
 		return { exitCode: 0, stdout, stderr: "" };
@@ -162,7 +169,7 @@ export async function runMockChildPi(
 	// parsers see exactly what a real child pi emits. Two events so the
 	// accumulation (sum) across messages is asserted, not a single snapshot.
 	if (mock === "json-usage-ledger") {
-		const text = `[MOCK] JSON usage ledger for ${input.agent.name}`;
+		const text = `[MOCK] JSON usage ledger for ${input.agent.name}${verdictSuffix}`;
 		const usageEvent = (tokens: { input: number; output: number; cacheRead: number; cacheWrite: number }, cost: number) =>
 			JSON.stringify({
 				type: "message_end",
@@ -282,7 +289,7 @@ export async function runMockChildPi(
 		}
 		// Subsequent invocations: delegate to json-success shape so the
 		// fallback chain's second attempt succeeds and the run completes.
-		const text = `[MOCK] JSON success for ${input.agent.name}`;
+		const text = `[MOCK] JSON success for ${input.agent.name}${verdictSuffix}`;
 		const stdout = `${JSON.stringify({ type: "message", message: { role: "assistant", content: [{ type: "text", text }] } })}\n${JSON.stringify({ type: "message_end", usage: { input: 10, output: 5, cost: 0.001, turns: 1 } })}\n`;
 		await observe(input, stdout);
 		return { exitCode: 0, stdout, stderr: "" };

package/src/runtime/compaction/tool-output-pruner.ts

@@ -95,13 +95,18 @@ export interface PruneResult {
 }
 
 // ---------------------------------------------------------------------------
-// Token estimation (rough char/4 heuristic, matching gajae-code)
+// Token estimation
 // ---------------------------------------------------------------------------
+// M3-10 / R34: the single char→token / text→token conversion lives in
+// src/utils/token-counter.ts. This site used to carry its own wrapper around
+// `countTokens`; it now uses the shared `estimateTokensForText` so pruner
+// budgets, handoff budgets (task-output-context.ts) and prompt-diet estimates
+// (prompt-builder.ts) all share one denominator and one unit (TOKENS).
 
-import { countTokens } from "../../utils/token-counter.ts";
+import { countTokens, estimateTokensForText } from "../../utils/token-counter.ts";
 
 function estimateTokens(text: string): number {
-	return countTokens(text);
+	return estimateTokensForText(text);
 }
 
 // ---------------------------------------------------------------------------