pi-crew 0.11.21 → 0.11.22

package/src/runtime/compaction/important-line-classifier.ts

@@ -20,7 +20,55 @@
  *   "compacted ... chars, head+tail preserved") and `readIfSmall` (marker
  *   "truncated ... bytes, head+tail preserved") backward-compatible when no
  *   important lines are present.
+ *
+ * K6/K7 (DR-03 round-6):
+ * - `reserveChars` lets the caller (TruncationStage) subtract the composed
+ *   marker + separator + joined-important-line overhead from the head+tail
+ *   budget, so the FINAL composed result fits `maxChars` + small constant
+ *   instead of stacking unbudgeted overhead on top (~1.15×maxChars).
+ * - Head/tail/middle boundaries are surrogate-pair-safe: a code-unit index
+ *   that would split an astral pair (emoji, CJK extensions) is backed off
+ *   so every emitted part contains only whole code points.
+ */
+
+/** Default fraction of `maxChars` available for important-line content. */
+export const DEFAULT_SLACK_FACTOR = 0.15;
+/** Default cap on candidate lines before slack-budget selection. */
+export const DEFAULT_MAX_IMPORTANT_LINES = 30;
+
+function isHighSurrogateUnit(codeUnit: number): boolean {
+	return codeUnit >= 0xd800 && codeUnit <= 0xdbff;
+}
+
+function isLowSurrogateUnit(codeUnit: number): boolean {
+	return codeUnit >= 0xdc00 && codeUnit <= 0xdfff;
+}
+
+/**
+ * K7: back a head-end boundary off while it would split a surrogate pair.
+ * `value.slice(0, boundary)` must never end on a lone high surrogate — if the
+ * code unit at `boundary - 1` is a high surrogate, its low partner lives at
+ * `boundary` and slicing there would orphan both halves; the boundary walks
+ * back so the whole pair falls into the (dropped) middle instead.
  */
+export function safeHeadBoundary(value: string, end: number): number {
+	let boundary = Math.max(0, Math.min(end, value.length));
+	while (boundary > 0 && isHighSurrogateUnit(value.charCodeAt(boundary - 1))) boundary -= 1;
+	return boundary;
+}
+
+/**
+ * K7: advance a tail-start boundary while it would split a surrogate pair.
+ * `value.slice(boundary)` must never start on a lone low surrogate — if the
+ * code unit at `boundary` is a low surrogate, its high partner lives at
+ * `boundary - 1` and slicing there would orphan both halves; the boundary
+ * walks forward so the whole pair stays in the (dropped) middle instead.
+ */
+export function safeTailBoundary(value: string, start: number): number {
+	let boundary = Math.max(0, Math.min(start, value.length));
+	while (boundary < value.length && isLowSurrogateUnit(value.charCodeAt(boundary))) boundary += 1;
+	return boundary;
+}
 
 /** Diagnostic patterns. Anchored where safe to avoid matching noise. */
 export const IMPORTANT_LINE_PATTERNS: readonly RegExp[] = [
@@ -75,7 +123,9 @@ export interface TruncationSplit {
 	 * fit the slack budget.
 	 */
 	importantLines: string[];
-	/** `value.length - maxChars` — chars dropped if no important lines preserved. */
+	/** `value.length - headTailBudget` — chars dropped if no important lines
+	 * preserved. `headTailBudget` is `maxChars - reserveChars`; with no
+	 * reserve (the default) this equals `value.length - maxChars`. */
 	baseDropped: number;
 }
 
@@ -84,8 +134,19 @@ export interface SplitOptions {
 	preserveImportant?: boolean;
 	/** Hard cap on candidate lines before slack-budget selection. Default 30. */
 	maxImportantLines?: number;
-	/** Fraction of `maxChars` available for important-line content. Default 0.15. */
+	/**
+	 * Fraction of `maxChars` available for important-line content. Default 0.15
+	 * ({@link DEFAULT_SLACK_FACTOR}).
+	 */
 	slackFactor?: number;
+	/**
+	 * K6: code units the CALLER will compose AROUND head+tail (marker text,
+	 * separators, joined important lines). The head+tail budget shrinks by
+	 * this reserve so the caller's final composed result fits `maxChars` +
+	 * small constant instead of stacking unbudgeted overhead on top. Default
+	 * 0 — legacy semantics where head+tail alone consume the full maxChars.
+	 */
+	reserveChars?: number;
 }
 
 /**
@@ -101,24 +162,37 @@ export function splitWithImportantLines(value: string, maxChars: number, opts: S
 	if (value.length <= maxChars) {
 		return { head: value, tail: "", importantLines: [], baseDropped: 0 };
 	}
-	const headLen = Math.floor(maxChars * 0.75);
-	const tailLen = maxChars - headLen;
-	const head = value.slice(0, headLen);
-	const tail = value.slice(value.length - tailLen);
+	// K6: reserve the caller's composed overhead (marker + separators +
+	// joined important lines) out of the head+tail budget. Clamped so at
+	// least one code unit of budget survives even when the reserve exceeds
+	// maxChars (pathologically small budgets — the marker alone dominates).
+	const reserve = Math.max(0, Math.min(Math.floor(opts.reserveChars ?? 0), maxChars - 1));
+	const headTailBudget = Math.max(1, maxChars - reserve);
+	const headLen = Math.floor(headTailBudget * 0.75);
+	const tailLen = headTailBudget - headLen;
+	// K7: surrogate-safe boundaries. Raw code-unit slices previously split
+	// astral pairs at the 75% head boundary and the tail start, emitting
+	// lone surrogates (mojibake) into the compacted output. Back off while
+	// the boundary would split a pair — the whole pair then falls into the
+	// middle (dropped) region instead of being broken across head/tail.
+	const headEnd = safeHeadBoundary(value, headLen);
+	const tailStart = safeTailBoundary(value, value.length - tailLen);
+	const head = value.slice(0, headEnd);
+	const tail = value.slice(tailStart);
 
 	if (opts.preserveImportant === false) {
 		return {
 			head,
 			tail,
 			importantLines: [],
-			baseDropped: value.length - maxChars,
+			baseDropped: value.length - headTailBudget,
 		};
 	}
 
-	const slackFactor = opts.slackFactor ?? 0.15;
+	const slackFactor = opts.slackFactor ?? DEFAULT_SLACK_FACTOR;
 	const slackChars = Math.max(0, Math.floor(maxChars * slackFactor));
-	const maxCandidates = opts.maxImportantLines ?? 30;
-	const middle = value.slice(headLen, value.length - tailLen);
+	const maxCandidates = opts.maxImportantLines ?? DEFAULT_MAX_IMPORTANT_LINES;
+	const middle = value.slice(headEnd, tailStart);
 	const candidates = extractImportantLines(middle, maxCandidates);
 
 	// Greedily pick whole lines that fit in the slack budget.
@@ -135,6 +209,6 @@ export function splitWithImportantLines(value: string, maxChars: number, opts: S
 		head,
 		tail,
 		importantLines: chosen,
-		baseDropped: value.length - maxChars,
+		baseDropped: value.length - headTailBudget,
 	};
 }

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

@@ -39,6 +39,14 @@ export interface ToolResultEntry {
 	content: string;
 	/** Whether the tool result represents an error. */
 	isError?: boolean;
+	/**
+	 * K8: the tool's REAL exit code when the original result carries one
+	 * (e.g. a bash exit status). Passed through to the digest verbatim
+	 * instead of the historical `isError ? 1 : 0` guess — exit 127 digests
+	 * as `exit=127`. Optional: callers whose source shape has no exit code
+	 * omit it and keep the legacy guess.
+	 */
+	exitCode?: number;
 }
 
 /** A file mutation event (edit/write) that can invalidate earlier reads. */
@@ -102,11 +110,23 @@ function estimateTokens(text: string): number {
 
 const DIGEST_NOTICE_TOKEN_CAP_MULTIPLIER = 1.25;
 
-function firstErrorLine(text: string): string | undefined {
-	return text
-		.split(/\r?\n/)
-		.find((line) => /error|failed|exception|panic/i.test(line))
-		?.trim();
+function firstErrorLine(text: string, isError = false): string | undefined {
+	const lines = text.split(/\r?\n/);
+	const matched = lines.find((line) => /error|failed|exception|panic/i.test(line))?.trim();
+	if (matched !== undefined) return matched;
+	// K8: multi-line stderr/stack whose HEAD carries the diagnostic but no
+	// line matches the keyword patterns (localized messages, shell errors,
+	// stack frames without a keyword). Fall back to the first 3 non-empty
+	// lines of the content head — the head names the failing frame; the old
+	// digest kept only the TAIL line, which for a stack trace is the least
+	// informative frame. Gated on isError so success output never grows a
+	// bogus error= part.
+	if (!isError) return undefined;
+	const head = lines
+		.map((line) => line.trim())
+		.filter((line) => line.length > 0)
+		.slice(0, 3);
+	return head.length > 0 ? head.join(" | ") : undefined;
 }
 
 function truncateField(value: string, maxLength: number): string {
@@ -119,22 +139,26 @@ function truncateField(value: string, maxLength: number): string {
  * Generate a compact digest of a tool result for the digest notice.
  * Supports bash (exit code + tail line), grep/search (match/file counts),
  * and falls back to undefined for tools without a known digest format.
+ *
+ * K8: `exitCode` passes the REAL exit status through when the original
+ * result carries one (exit 127 → `exit=127`, not the hardcoded `exit=1`);
+ * when absent the legacy `isError ? 1 : 0` guess is kept.
  */
-export function resultDigest(toolName: string, content: string, isError?: boolean): string | undefined {
+export function resultDigest(toolName: string, content: string, isError?: boolean, exitCode?: number): string | undefined {
 	const name = toolName.toLowerCase();
 	const text = content ?? "";
 	if (name === "bash") {
-		const exitCode = isError ? 1 : 0;
+		const exitCodeValue = typeof exitCode === "number" && Number.isFinite(exitCode) ? Math.trunc(exitCode) : isError ? 1 : 0;
 		const tail = text.trim().split(/\r?\n/).filter(Boolean).at(-1) ?? "";
-		const error = firstErrorLine(text);
-		return [`exit=${exitCode}`, tail ? `tail=${tail}` : undefined, error ? `error=${error}` : undefined]
+		const error = firstErrorLine(text, isError);
+		return [`exit=${exitCodeValue}`, tail ? `tail=${tail}` : undefined, error ? `error=${error}` : undefined]
 			.filter((part): part is string => part !== undefined)
 			.join("; ");
 	}
 	if (name === "search" || name === "grep") {
 		const match = text.match(/(\d+)\s+matches?/i) ?? text.match(/totalMatches["']?:\s*(\d+)/i);
 		const files = text.match(/(\d+)\s+files?/i) ?? text.match(/filesWithMatches["']?:\s*(\d+)/i);
-		const error = firstErrorLine(text);
+		const error = firstErrorLine(text, isError);
 		return (
 			[match ? `matches=${match[1]}` : undefined, files ? `files=${files[1]}` : undefined, error ? `error=${error}` : undefined]
 				.filter((part): part is string => part !== undefined)
@@ -146,7 +170,7 @@ export function resultDigest(toolName: string, content: string, isError?: boolea
 
 function createPrunedNotice(tokens: number, entry: ToolResultEntry): string {
 	const generic = `[Output pruned — ${tokens} tokens]`;
-	const digest = resultDigest(entry.toolName, entry.content, entry.isError);
+	const digest = resultDigest(entry.toolName, entry.content, entry.isError, entry.exitCode);
 	if (!digest) return generic;
 	const genericTokens = countTokens(generic);
 	const maxTokens = Math.max(genericTokens, Math.floor(genericTokens * DIGEST_NOTICE_TOKEN_CAP_MULTIPLIER));

package/src/runtime/crew-agent-records.ts

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import {
+	atomicWriteFile,
 	atomicWriteJson,
 	atomicWriteJsonCoalesced,
 	cancelPendingCoalescedWriteForPath,
@@ -686,7 +687,12 @@ function readSeqFromSidecar(filePath: string): number | undefined {
 
 function writeSeqToSidecar(filePath: string, seq: number): void {
 	try {
-		fs.writeFileSync(`${filePath}.${AGENT_EVENT_SEQ_SIDECAR}`, String(seq));
+		// D6 (DR-02): tmp+rename so a concurrent reader (nextAgentEventSeq on
+		// another thread/process) never observes a torn or empty .seq.
+		// best-effort durability per F4: the sidecar is only an O(1) lookup
+		// optimization — losing it on a crash costs the O(n) scan fallback,
+		// never correctness. Path and content format unchanged (String(seq)).
+		atomicWriteFile(`${filePath}.${AGENT_EVENT_SEQ_SIDECAR}`, String(seq), { durability: "best-effort" });
 	} catch (error) {
 		logInternalError("crew-agent-records.seq-sidecar", error, `filePath=${filePath}`);
 	}

package/src/runtime/delivery-coordinator.ts

@@ -26,6 +26,12 @@ export interface DeliveryCoordinatorDeps {
 const PENDING_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
 
 export class DeliveryCoordinator {
+	// DR-02 C3: the queue was TTL-bounded ONLY (24h) — an extension that stays
+	// sessionless while runs keep completing could grow `pending` unboundedly.
+	// Hard count cap with drop-oldest (oldest delivery is the least likely to
+	// still matter); the TTL eviction below stays unchanged. Static (not
+	// module-const) so tests can read/patch it like Semaphore.MAX_QUEUE.
+	static readonly MAX_PENDING = 1_000;
 	private active = false;
 	private generation = 0;
 	private pending: PendingDelivery[] = [];
@@ -36,6 +42,9 @@ export class DeliveryCoordinator {
 	/** The session id passed to the most recent activate(); used by flushQueuedResults
 	 * to park deliveries owned by a different session (vector #12). */
 	private activeSessionId?: string;
+	/** DR-02 C3: set after the first warn of an overflow episode; cleared once
+	 * the queue is back at/below the cap so the NEXT episode warns again. */
+	private pendingOverflowWarned = false;
 
 	constructor(deps: DeliveryCoordinatorDeps) {
 		this.deps = deps;
@@ -215,6 +224,27 @@ export class DeliveryCoordinator {
 			this.ttlTimer.unref();
 		}
 		this.pending.push({ ...delivery, generation: this.generation });
+		// DR-02 C3: count cap — drop-oldest while over cap, warn ONCE per
+		// overflow episode (flag resets once the queue is back under cap, so a
+		// later separate overflow is visible again).
+		if (this.pending.length <= DeliveryCoordinator.MAX_PENDING) {
+			this.pendingOverflowWarned = false;
+			return;
+		}
+		let dropped = 0;
+		while (this.pending.length > DeliveryCoordinator.MAX_PENDING) {
+			if (this.pending.shift() === undefined) break;
+			dropped++;
+		}
+		if (dropped > 0 && !this.pendingOverflowWarned) {
+			this.pendingOverflowWarned = true;
+			logInternalError(
+				"delivery-coordinator.pending-overflow",
+				undefined,
+				`dropped=${dropped} max=${DeliveryCoordinator.MAX_PENDING} remaining=${this.pending.length} runId=${delivery.runId}`,
+				"warn",
+			);
+		}
 	}
 
 	private evictExpired(): void {

package/src/runtime/dwf-state-store.ts

@@ -19,8 +19,21 @@ import { existsSync, mkdirSync, readFileSync, unlinkSync } from "node:fs";
 import { dirname } from "node:path";
 import { atomicWriteJson } from "../state/atomic-write.ts";
 import { logInternalError } from "../utils/internal-error.ts";
+import type { AgentResult } from "./goal-workflow/dynamic-workflow-context.ts";
+
+/** R6-12 (DR-03 round-6, 2026-10-16): current DWF checkpoint format version.
+ *  Bumped whenever the persisted shape changes incompatibly — the loader
+ *  rejects unknown FUTURE versions (see DwfStore.load) so a newer checkpoint
+ *  is never silently mis-hydrated by an older binary. */
+export const DWF_CHECKPOINT_VERSION = 1;
 
 export interface DwfCheckpointState {
+	/** R6-12: format version. Always DWF_CHECKPOINT_VERSION on write (save()
+	 *  stamps it like updatedAt); load() tolerates a missing version (legacy
+	 * pre-R6-12 checkpoints written by the version-less code — otherwise an
+	 * in-flight run would lose its resume state across an upgrade) but rejects
+	 * any other value. */
+	version: typeof DWF_CHECKPOINT_VERSION;
 	runId: string;
 	vars: Record<string, unknown>;
 	phases: string[];
@@ -28,11 +41,14 @@ export interface DwfCheckpointState {
 	logs: string[]; // capped copy (≤1000); the events log (dwf.log) is the durable source of truth
 	spent: number; // budget accumulator (round-14 P1-2)
 	agentCount: number;
-	/** PERS-1: per-agent-call idempotency cache. Maps a deterministic call ID to the
-	 *  cached result so a DWF resume skips already-completed agent calls (avoids
-	 *  duplicating artifacts/mailbox/tokens). Uses Record (not Map) for JSON
-	 *  serialization safety. */
-	completedAgentCalls?: Record<string, { text: string; usage?: { input: number; output: number } }>;
+	/** PERS-1: per-agent-call idempotency cache. Maps a deterministic call ID to
+	 *  the cached FULL AgentResult (R6-3: text + usage + structured + artifactPath
+	 *  + actual durationMs — previously only {text,usage}, so replayed steps lost
+	 *  structured output and artifact linkage) so a DWF resume skips
+	 *  already-completed agent calls (avoids duplicating artifacts/mailbox/tokens).
+	 *  Uses Record (not Map) for JSON serialization safety. Optional: legacy
+	 *  checkpoints (and fresh states) omit it. */
+	completedAgentCalls?: Record<string, AgentResult>;
 	updatedAt: string;
 }
 
@@ -70,16 +86,34 @@ export class DwfStore {
 			// Corrupt-guard: a valid checkpoint must be an object with a string runId
 			// (mirrors GoalStore.load's typeof parsed.goalId !== "string" check).
 			if (!parsed || typeof parsed !== "object" || typeof parsed.runId !== "string") return undefined;
+			// R6-12: version guard, mirroring the recovery/checkpoint.ts runId-guard
+			// style (typed mismatch → treat as not-loadable). A checkpoint from an
+			// unknown FUTURE version is REJECTED (→ undefined → fresh run) rather than
+			// mis-hydrated — a newer format's fields mean nothing to this binary.
+			// A MISSING version is accepted as legacy (written by the pre-R6-12 code,
+			// shape-identical otherwise) so an in-flight run survives an upgrade.
+			// Logged (not silent) so the quarantine is observable in diagnostics.
+			if (parsed.version !== undefined && parsed.version !== DWF_CHECKPOINT_VERSION) {
+				logInternalError(
+					"dwf-state-store.load",
+					new Error(
+						`unknown dwf-checkpoint version ${String(parsed.version)} (expected ${DWF_CHECKPOINT_VERSION}) — rejecting checkpoint, run restarts fresh`,
+					),
+					`runId=${parsed.runId}`,
+				);
+				return undefined;
+			}
 			return parsed as DwfCheckpointState;
 		} catch {
 			return undefined;
 		}
 	}
 
-	/** Atomically persist a checkpoint state. Stamps `updatedAt` (callers need not set it). */
+	/** Atomically persist a checkpoint state. Stamps `version` (R6-12) and
+	 *  `updatedAt` (callers need not set either). */
 	save(state: DwfCheckpointState): void {
 		const path = this.path;
-		const next = { ...state, updatedAt: new Date().toISOString() };
+		const next = { ...state, version: DWF_CHECKPOINT_VERSION, updatedAt: new Date().toISOString() };
 		try {
 			mkdirSync(dirname(path), { recursive: true });
 			atomicWriteJson(path, next);

package/src/runtime/finalize-run.ts

@@ -439,9 +439,20 @@ export async function finalizeRun(ctx: SchedulerContext): Promise<{ manifest: Te
 		// (No updateRunStatus call: from===to is a no-op, but the intent here is
 		// explicitly "leave the earlier decision intact".)
 	} else {
+		// R4-4 (DR-02 wave 2): needs_attention is terminal-without-result and the
+		// scheduler counts it as done, so the run still COMPLETES — but the green
+		// "Team workflow completed." summary must not hide that a task's result
+		// was never submitted. Detection-first surfacing only: status stays
+		// "completed" (no flip, no block); the policy engine emits a matching
+		// non-blocking notify decision listing the task ids.
+		const needsAttentionCount = tasks.filter((task) => task.status === "needs_attention").length;
 		manifest = applyStatusInMemory(
 			"completed",
-			input.executeWorkers ? "Team workflow completed." : "Team workflow scaffold completed without launching child workers.",
+			needsAttentionCount > 0
+				? `Team workflow completed with ${needsAttentionCount} task(s) needing attention (no result submitted).`
+				: input.executeWorkers
+					? "Team workflow completed."
+					: "Team workflow scaffold completed without launching child workers.",
 		);
 	}
 	manifest = writeProgress(manifest, tasks, "team-runner", input.executeWorkers, input.runtimeConfig);
@@ -553,7 +564,7 @@ export async function finalizeRun(ctx: SchedulerContext): Promise<{ manifest: Te
 	const healthStore = new HealthStore(crewRoot);
 	healthStore.saveSnapshot({
 		runId: finalManifest.manifest.runId,
-		tasks: finalTasks.map((t) => ({ id: t.id, status: t.status })),
+		tasks: finalTasks.map((t) => ({ id: t.id, status: t.status, heartbeat: t.heartbeat })),
 		createdAt: finalManifest.manifest.createdAt,
 	});
 	ctx.manifest = manifest;