zob-harness 0.3.0 → 0.4.0

package/.pi/extensions/zob-harness/src/domains/autonomy/interactive-autonomy.ts

@@ -249,10 +249,10 @@ function patternMatchesAny(text: string, patterns: string[]): boolean {
   });
 }
 
-const SECRET_ACCESS_VERB_PATTERN = /\b(read|cat|open|inspect|print|show|copy|extract|use|lire|ouvrir|affiche|imprime|copie|extrais|utilise)\b/i;
-const SECRET_ACCESS_CONTEXT_PATTERN = /\b(secret|token|api[_ -]?key|private\s+key|ssh\s+key|credential|identifiant)\b.{0,80}\b(read|show|print|copy|use|lire|affiche|copie|utilise)\b/i;
-const NEGATIVE_SAFETY_DIRECTIVE_PATTERN = /\b(do not|don't|dont|never|must not|mustn't|avoid|forbidden|denylist|deny list|blocked|without|no\s+secrets?|ne\s+pas|ne\s+jamais|n'ouvre\s+pas|ne\s+lis\s+pas|interdit|sans)\b/i;
-const CONTRAST_OR_EXCEPTION_PATTERN = /\b(but|however|except|unless|sauf|mais|pourtant)\b/i;
+const SECRET_ACCESS_VERB_PATTERN = /\b(read|cat|open|inspect|print|show|copy|extract|use)\b/i;
+const SECRET_ACCESS_CONTEXT_PATTERN = /\b(secret|token|api[_ -]?key|private\s+key|ssh\s+key|credential|identifier)\b.{0,80}\b(read|show|print|copy|use)\b/i;
+const NEGATIVE_SAFETY_DIRECTIVE_PATTERN = /\b(do not|don't|dont|never|must not|mustn't|avoid|forbidden|denylist|deny list|blocked|without|no\s+secrets?)\b/i;
+const CONTRAST_OR_EXCEPTION_PATTERN = /\b(but|however|except|unless)\b/i;
 
 function isNegativeSecretSafetyLine(line: string, policy: InteractiveAutonomyPolicy): boolean {
   const trimmed = line.trim();
@@ -278,8 +278,8 @@ function secretAccessRequested(text: string, policy: InteractiveAutonomyPolicy):
 }
 
 function productionApplyRequested(text: string): boolean {
-  return /\b(deploy|release|ship|apply|write|push|publish|déploie|deploie|publie|livre|applique)\b.{0,80}\b(prod|production|live)\b/i.test(text)
-    || /\b(prod|production|live)\b.{0,80}\b(deploy|release|ship|apply|write|push|publish|déploie|deploie|publie|livre|applique)\b/i.test(text);
+  return /\b(deploy|release|ship|apply|write|push|publish)\b.{0,80}\b(prod|production|live)\b/i.test(text)
+    || /\b(prod|production|live)\b.{0,80}\b(deploy|release|ship|apply|write|push|publish)\b/i.test(text);
 }
 
 function extractTargetPaths(text: string): string[] {
@@ -360,14 +360,14 @@ export function scoreMissionReadiness(text: string, options: { mode: Interactive
   const clarificationCodes: string[] = [];
   const safetyGateCodes = ["no_secrets", "no_destructive_commands", "no_production_apply", "no_global_production_claim", "validation_required"];
 
-  const hasActionVerb = /\b(implement|impl[eé]mente|build|cr[eé]e|create|add|ajoute|fix|corrige|modify|modifie|change|update|mets?|refactor|refactorise|wire|branche|brancher|validate|test|smoke|audit|review|documente|write|edit|fais|make)\b/i.test(raw);
-  const hasAcceptanceLanguage = /\b(acceptance|criteria|crit[eè]res?|must|must not|doit|ne doit pas|validation|validate|test|smoke|preuve|evidence|oracle|done when|definition of done)\b/i.test(raw);
-  const hasTestabilityLanguage = /\b(test|tests|smoke|npm run|check|typecheck|validation|validate|oracle|proof|preuve|assert|v[eé]rifie|verify)\b/i.test(raw);
-  const asksClarificationOnly = /\b(explain|explique|pourquoi|question|aide|help|status|statut|montre|show)\b/i.test(raw) && !hasActionVerb;
+  const hasActionVerb = /\b(implement|build|create|add|fix|modify|change|update|refactor|wire|validate|test|smoke|audit|review|document|write|edit|make)\b/i.test(raw);
+  const hasAcceptanceLanguage = /\b(acceptance|criteria|must|must not|validation|validate|test|smoke|proof|evidence|oracle|done when|definition of done)\b/i.test(raw);
+  const hasTestabilityLanguage = /\b(test|tests|smoke|npm run|check|typecheck|validation|validate|oracle|proof|assert|verify)\b/i.test(raw);
+  const asksClarificationOnly = /\b(explain|why|question|help|status|show)\b/i.test(raw) && !hasActionVerb;
   const destructiveRequested = policy.safety.blockDestructiveCommands && patternMatchesAny(raw, policy.safety.destructivePatterns);
   const secretRequested = policy.safety.blockSecretAccess && secretAccessRequested(raw, policy);
   const productionRequested = policy.safety.blockProductionApply && productionApplyRequested(raw);
-  const globalClaimRequested = /\b(100%|global|production[- ]?wide|full production|prod)\b.{0,80}\b(claim|declare|prouve|prove|certifie|certify|ready|autonomous|autonomie)\b/i.test(raw);
+  const globalClaimRequested = /\b(100%|global|production[- ]?wide|full production|prod)\b.{0,80}\b(claim|declare|prove|certify|ready|autonomous|autonomy)\b/i.test(raw);
 
   if (!raw) blockerCodes.push("user_input_missing");
   if (destructiveRequested) blockerCodes.push("destructive_action_requested");
@@ -376,9 +376,9 @@ export function scoreMissionReadiness(text: string, options: { mode: Interactive
   if (globalClaimRequested) clarificationCodes.push("global_production_claim_requires_fresh_oracle_proof");
 
   const clarity = raw.length >= 80 && hasActionVerb ? 0.9 : raw.length >= 35 && hasActionVerb ? 0.72 : hasActionVerb ? 0.55 : asksClarificationOnly ? 0.35 : raw.length > 0 ? 0.25 : 0;
-  const acceptanceCriteria = hasAcceptanceLanguage ? 0.8 : /\b(done|fini|termin[eé]|livrable|deliverable)\b/i.test(raw) ? 0.5 : 0.15;
-  const targetPaths = targetPathRefs.length > 0 ? 0.85 : /\b(repo|project|harness|pi|extension|codebase|projet)\b/i.test(raw) ? 0.45 : 0.15;
-  const testability = hasTestabilityLanguage ? 0.85 : /\b(works|fonctionne|ready|ok)\b/i.test(raw) ? 0.35 : 0.15;
+  const acceptanceCriteria = hasAcceptanceLanguage ? 0.8 : /\b(done|complete|finished|deliverable)\b/i.test(raw) ? 0.5 : 0.15;
+  const targetPaths = targetPathRefs.length > 0 ? 0.85 : /\b(repo|project|harness|pi|extension|codebase)\b/i.test(raw) ? 0.45 : 0.15;
+  const testability = hasTestabilityLanguage ? 0.85 : /\b(works|ready|ok)\b/i.test(raw) ? 0.35 : 0.15;
   const risk: MissionRiskLevel = blockerCodes.length > 0 || productionRequested ? "high" : /\b(network|browser|cloud|api|deploy|publish|commit|database|db|payment|auth)\b/i.test(normalized) ? "medium" : "low";
   const safety = risk === "high" ? 0 : risk === "medium" ? 0.55 : 1;
   const signals: MissionReadinessSignals = {

package/.pi/extensions/zob-harness/src/domains/coms/coms-v2/registry.ts

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 
@@ -10,6 +10,8 @@ import { readZobComsV2Policy, zobComsRegistryEnabled } from "./policy.js";
 import type { ZobLivePeerCard, ZobLivePeerStatus, ZobLiveRegistrySnapshot } from "./types.js";
 
 const FORBIDDEN_PERSISTED_KEYS = new Set(["body", "task", "prompt", "output", "content", "message", "rationale", "text", "diff", "patch"]);
+const DEFAULT_OFFLINE_PEER_RETENTION_MS = 24 * 60 * 60 * 1000;
+const MIN_OFFLINE_PEER_RETENTION_MS = 5 * 60 * 1000;
 
 function registryRoot(): { path: string; kind: "user_runtime" | "env_override" } {
   const override = process.env.ZOB_COMS_REGISTRY_ROOT;
@@ -54,6 +56,19 @@ function readPeerCardsFromAgentsDir(dir: string, nowMs: number, teamName?: strin
     .map((peer) => ({ ...peer, status: derivePeerStatus(peer, nowMs) }));
 }
 
+function boundedOfflinePeerRetentionMs(value: number | undefined): number {
+  const env = Number.parseInt(process.env.ZOB_COMS_OFFLINE_PEER_RETENTION_MS ?? "", 10);
+  const raw = typeof value === "number" && Number.isFinite(value) ? value : Number.isFinite(env) ? env : DEFAULT_OFFLINE_PEER_RETENTION_MS;
+  return Math.max(MIN_OFFLINE_PEER_RETENTION_MS, Math.floor(raw));
+}
+
+function offlinePeerExpired(peer: ZobLivePeerCard, nowMs: number, retentionMs: number): boolean {
+  if (derivePeerStatus(peer, nowMs) !== "offline") return false;
+  const heartbeatMs = Date.parse(peer.heartbeatAt);
+  if (!Number.isFinite(heartbeatMs)) return true;
+  return nowMs - heartbeatMs >= Math.max(peer.offlineAfterMs, retentionMs);
+}
+
 function allProjectAgentsDirs(): string[] {
   const root = registryRoot();
   const projectsDir = join(root.path, "projects");
@@ -94,6 +109,34 @@ function derivePeerStatus(peer: ZobLivePeerCard, nowMs: number): ZobLivePeerStat
   return "online";
 }
 
+export function pruneExpiredZobLivePeers(repoRoot: string, input: { teamName?: string; nowMs?: number; retentionMs?: number } = {}): { schema: "zob.live-registry-prune.v1"; pruned: number; retained: number; retentionMs: number; bodyStored: false } {
+  const { dir } = projectAgentsDir(repoRoot);
+  const nowMs = input.nowMs ?? Date.now();
+  const retentionMs = boundedOfflinePeerRetentionMs(input.retentionMs);
+  let pruned = 0;
+  let retained = 0;
+  if (!existsSync(dir)) return { schema: "zob.live-registry-prune.v1", pruned, retained, retentionMs, bodyStored: false };
+  for (const entry of readdirSync(dir).filter((name) => name.endsWith(".json"))) {
+    const filePath = join(dir, entry);
+    try {
+      const peer = parsePeerCard(JSON.parse(readFileSync(filePath, "utf8")) as unknown);
+      if (!peer || (input.teamName && peer.team !== input.teamName)) {
+        retained += 1;
+        continue;
+      }
+      if (offlinePeerExpired(peer, nowMs, retentionMs)) {
+        unlinkSync(filePath);
+        pruned += 1;
+      } else {
+        retained += 1;
+      }
+    } catch {
+      retained += 1;
+    }
+  }
+  return { schema: "zob.live-registry-prune.v1", pruned, retained, retentionMs, bodyStored: false };
+}
+
 export function writeZobLivePeerCard(repoRoot: string, peer: ZobLivePeerCard): ZobLivePeerCard {
   if (hasForbiddenPersistedKey(peer)) throw new Error("Refusing to persist ZOB live peer card with forbidden body-like keys");
   if (peer.bodyStored !== false) throw new Error("ZOB live peer card bodyStored must be false");

package/.pi/extensions/zob-harness/src/domains/coms/coms-v2/zpeer.ts

@@ -26,6 +26,9 @@ export interface ZpeerRoomSummary {
   stale: number;
   offline: number;
   aliases: string[];
+  onlineAliases: string[];
+  staleAliases: string[];
+  offlineAliases: string[];
   duplicateAliases: string[];
   membershipCount?: number;
   localOnly: true;
@@ -248,9 +251,15 @@ function peersInRoom(repoRoot: string, roomId: string): ZpeerRoomPeer[] {
 
 function buildZpeerRoomSummaryFromPeers(projectId: string, self: ZobLivePeerCard | undefined, roomId: string, peers: ZpeerRoomPeer[]): ZpeerRoomSummary {
   const counts: Record<ZobLivePeerStatus, number> = { online: 0, stale: 0, offline: 0 };
+  const statusAliases: Record<ZobLivePeerStatus, string[]> = { online: [], stale: [], offline: [] };
   const aliases = peers.map((entry) => entry.membership.alias).sort();
-  for (const entry of peers) counts[zpeerReachableStatus(entry.peer)] += 1;
-  const duplicateAliases = aliases.filter((alias, index) => aliases.indexOf(alias) !== index).filter((alias, index, all) => all.indexOf(alias) === index);
+  for (const entry of peers) {
+    const status = zpeerReachableStatus(entry.peer);
+    counts[status] += 1;
+    statusAliases[status].push(entry.membership.alias);
+  }
+  const onlineAliases = statusAliases.online.sort();
+  const duplicateAliases = onlineAliases.filter((alias, index) => onlineAliases.indexOf(alias) !== index).filter((alias, index, all) => all.indexOf(alias) === index);
   return {
     schema: "zob.zpeer-room-summary.v1",
     projectId,
@@ -261,6 +270,9 @@ function buildZpeerRoomSummaryFromPeers(projectId: string, self: ZobLivePeerCard
     stale: counts.stale,
     offline: counts.offline,
     aliases,
+    onlineAliases,
+    staleAliases: statusAliases.stale.sort(),
+    offlineAliases: statusAliases.offline.sort(),
     duplicateAliases,
     membershipCount: self ? zpeerMembershipsForPeer(self).length : undefined,
     localOnly: true,
@@ -471,8 +483,24 @@ export async function sendZpeerPrompt(repoRoot: string, self: ZobLivePeerCard, t
   const candidates = peersInRoom(repoRoot, roomId).filter((entry) => entry.membership.alias === targetAlias && entry.peer.sessionHash !== self.sessionHash);
   if (targetAlias === senderAlias) return finish("attempt", { status: "blocked", reason: "cannot send to self", targetAlias, taskHash, bodyStored: false });
   if (candidates.length === 0) return finish("attempt", { status: "blocked", reason: `peer @${targetAlias} not found in room '${roomId}'`, targetAlias, taskHash, bodyStored: false }, 0);
-  if (candidates.length > 1) return finish("attempt", { status: "blocked", reason: `duplicate alias @${targetAlias} in room '${roomId}'`, targetAlias, taskHash, bodyStored: false }, candidates.length);
-  const target = candidates[0];
+  let liveCandidates = candidates.filter((entry) => zpeerReachableStatus(entry.peer) === "online");
+  if (liveCandidates.length > 1) {
+    const responsiveCandidates: ZpeerRoomPeer[] = [];
+    for (const entry of liveCandidates) {
+      if (await peerRespondsToAliasPing(entry.peer)) {
+        responsiveCandidates.push(entry);
+      } else {
+        try { writeZobLivePeerCard(repoRoot, { ...entry.peer, heartbeatAt: new Date().toISOString(), status: "offline" }); } catch { /* best-effort ghost alias release */ }
+      }
+    }
+    liveCandidates = responsiveCandidates;
+  }
+  if (liveCandidates.length === 0) {
+    const statuses = [...new Set(candidates.map((entry) => zpeerReachableStatus(entry.peer)))].sort().join("/") || "offline";
+    return finish("attempt", { status: "blocked", reason: `peer @${targetAlias} is ${statuses}`, targetAlias, taskHash, bodyStored: false }, candidates.length);
+  }
+  if (liveCandidates.length > 1) return finish("attempt", { status: "blocked", reason: `duplicate live alias @${targetAlias} in room '${roomId}'`, targetAlias, taskHash, bodyStored: false }, liveCandidates.length);
+  const target = liveCandidates[0];
   const targetReachableStatus = zpeerReachableStatus(target.peer);
   if (targetReachableStatus !== "online") return finish("attempt", { status: "blocked", reason: `peer @${targetAlias} is ${targetReachableStatus}`, targetAlias, taskHash, bodyStored: false }, 1);
   const topologyBlocker = validateZpeerTopology(repoRoot, self, target.peer, roomId, senderAlias, target.membership.alias);

package/.pi/extensions/zob-harness/src/domains/coms/mission-control.ts

@@ -63,6 +63,7 @@ function summarizeZpeerRooms(peers: Array<Record<string, unknown>>): Array<Recor
   }
   return [...rooms.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([roomId, roomPeers]) => {
     const aliases = roomPeers.map((entry) => entry.alias).filter((alias): alias is string => Boolean(alias)).sort();
+    const onlineAliases = roomPeers.filter((entry) => entry.peer.status === "online").map((entry) => entry.alias).filter((alias): alias is string => Boolean(alias)).sort();
     const sessionHashes = roomPeers.map((entry) => typeof entry.peer.sessionHash === "string" ? entry.peer.sessionHash : undefined).filter((sessionHash): sessionHash is string => Boolean(sessionHash));
     return {
       schema: "zob.zpeer-room-summary.v1",
@@ -73,7 +74,9 @@ function summarizeZpeerRooms(peers: Array<Record<string, unknown>>): Array<Recor
       stale: roomPeers.filter((entry) => entry.peer.status === "stale").length,
       offline: roomPeers.filter((entry) => entry.peer.status === "offline").length,
       aliasHashes: aliases.map((alias) => sha256(alias)),
-      duplicateAliasHashes: aliases.filter((alias, index) => aliases.indexOf(alias) !== index).filter((alias, index, all) => all.indexOf(alias) === index).map((alias) => sha256(alias)),
+      onlineAliasHashes: onlineAliases.map((alias) => sha256(alias)),
+      duplicateAliasHashes: onlineAliases.filter((alias, index) => onlineAliases.indexOf(alias) !== index).filter((alias, index, all) => all.indexOf(alias) === index).map((alias) => sha256(alias)),
+      duplicateAliasScope: "online_only",
       localOnly: true,
       networkEnabled: false,
       bodyStored: false,

package/.pi/extensions/zob-harness/src/domains/delegation/output-contracts.ts

@@ -11,17 +11,17 @@ const COMMON_OUTPUT_REQUIREMENTS: OutputRequirement[] = [
   },
   {
     name: "evidence",
-    pattern: "<evidence>|\\bevidence\\b|preuve|preuves",
+    pattern: "<evidence>|\\bevidence\\b|proof",
     message: "Missing evidence/proof section",
   },
   {
     name: "risks_blockers",
-    pattern: "<risks_blockers>|risks?/blockers?|risks?|blockers?|risques?|blocage",
+    pattern: "<risks_blockers>|risks?/blockers?|risks?|blockers?",
     message: "Missing risks/blockers section",
   },
   {
     name: "compliance",
-    pattern: "<compliance>|\\bcompliance\\b|conformité|must not",
+    pattern: "<compliance>|\\bcompliance\\b|must not",
     message: "Missing compliance line",
   },
 ];
@@ -42,10 +42,10 @@ const OUTPUT_CONTRACTS: OutputContract[] = [
       { name: "literal_request", pattern: "<literal_request>|literal request|literal_request", message: "Explore output missing literal_request" },
       { name: "actual_need", pattern: "<actual_need>|actual need|actual_need", message: "Explore output missing actual_need" },
       { name: "success_looks_like", pattern: "<success_looks_like>|success looks like|success_looks_like", message: "Explore output missing success_looks_like" },
-      { name: "files", pattern: "<files>|\\bfiles\\b|fichiers", message: "Explore output missing files section" },
-      { name: "answer", pattern: "<answer>|\\banswer\\b|réponse|reponse", message: "Explore output missing answer section" },
-      { name: "gaps", pattern: "<gaps>|\\bgaps\\b|trous|manques", message: "Explore output missing gaps section" },
-      { name: "next_steps", pattern: "<next_steps>|next steps|next_steps|prochaines étapes", message: "Explore output missing next_steps section" },
+      { name: "files", pattern: "<files>|\\bfiles\\b", message: "Explore output missing files section" },
+      { name: "answer", pattern: "<answer>|\\banswer\\b", message: "Explore output missing answer section" },
+      { name: "gaps", pattern: "<gaps>|\\bgaps\\b", message: "Explore output missing gaps section" },
+      { name: "next_steps", pattern: "<next_steps>|next steps|next_steps", message: "Explore output missing next_steps section" },
     ],
   },
   {
@@ -55,10 +55,10 @@ const OUTPUT_CONTRACTS: OutputContract[] = [
     required: [
       ...COMMON_OUTPUT_REQUIREMENTS,
       { name: "scope", pattern: "scope|in-scope|out-of-scope|forbidden", message: "Plan output missing scope table" },
-      { name: "assumptions", pattern: "assumptions?|hypothèses", message: "Plan output missing assumptions" },
-      { name: "implementation_slices", pattern: "implementation (steps|slices)|slices?|étapes", message: "Plan output missing implementation slices/steps" },
+      { name: "assumptions", pattern: "assumptions?", message: "Plan output missing assumptions" },
+      { name: "implementation_slices", pattern: "implementation (steps|slices)|slices?", message: "Plan output missing implementation slices/steps" },
       { name: "validation_ladder", pattern: "validation ladder|validation", message: "Plan output missing validation ladder" },
-      { name: "stop_conditions", pattern: "stop conditions?|conditions d'arrêt|conditions d’arret", message: "Plan output missing stop conditions" },
+      { name: "stop_conditions", pattern: "stop conditions?", message: "Plan output missing stop conditions" },
       { name: "handoff_contract", pattern: "handoff|TASK:|EXPECTED OUTCOME:|MUST NOT", message: "Plan output missing implementer handoff contract" },
     ],
   },
@@ -69,9 +69,9 @@ const OUTPUT_CONTRACTS: OutputContract[] = [
     required: [
       ...COMMON_OUTPUT_REQUIREMENTS,
       { name: "gap_verdict", pattern: "gap verdict|SUFFICIENT|GAP|no change|no-change", message: "Implement output missing gap/no-change verdict" },
-      { name: "changed_files", pattern: "changed files|fichiers modifiés|no change|no-change", message: "Implement output missing changed files or no-change evidence" },
-      { name: "verification_commands", pattern: "verification|vérification|commands?|commandes?", message: "Implement output missing verification commands" },
-      { name: "results", pattern: "results?|résultats?|exit code|passed|failed", message: "Implement output missing command/results evidence" },
+      { name: "changed_files", pattern: "changed files|no change|no-change", message: "Implement output missing changed files or no-change evidence" },
+      { name: "verification_commands", pattern: "verification|commands?", message: "Implement output missing verification commands" },
+      { name: "results", pattern: "results?|exit code|passed|failed", message: "Implement output missing command/results evidence" },
     ],
   },
   {
@@ -81,8 +81,8 @@ const OUTPUT_CONTRACTS: OutputContract[] = [
     required: [
       ...COMMON_OUTPUT_REQUIREMENTS,
       { name: "verdict", pattern: "<verdict>\\s*(PASS|FAIL|WARN)\\s*</verdict>|\\b(PASS|FAIL|WARN)\\b", message: "Oracle output missing PASS/FAIL/WARN verdict" },
-      { name: "confidence", pattern: "<confidence>|\\bconfidence\\b|confiance", message: "Oracle output missing confidence" },
-      { name: "blocking_issues", pattern: "<blocking_issues>|blocking issues?|blockers?|bloqueurs", message: "Oracle output missing blocking issues" },
+      { name: "confidence", pattern: "<confidence>|\\bconfidence\\b", message: "Oracle output missing confidence" },
+      { name: "blocking_issues", pattern: "<blocking_issues>|blocking issues?|blockers?", message: "Oracle output missing blocking issues" },
       { name: "non_blocking_notes", pattern: "<non_blocking_notes>|non[-_ ]blocking", message: "Oracle output missing non-blocking notes" },
       { name: "no_ship", pattern: "<no_ship>|no_ship|no ship", message: "Oracle output missing no_ship decision" },
     ],
@@ -94,7 +94,7 @@ const OUTPUT_CONTRACTS: OutputContract[] = [
     required: [
       ...COMMON_OUTPUT_REQUIREMENTS,
       { name: "verdict", pattern: "\\b(PASS|FAIL|WARN|INCONCLUSIVE)\\b|verdict", message: "QA output missing verification verdict" },
-      { name: "command", pattern: "commands?|commandes?|cwd", message: "QA output missing command/cwd evidence" },
+      { name: "command", pattern: "commands?|cwd", message: "QA output missing command/cwd evidence" },
       { name: "exit_or_output", pattern: "exit code|output|stdout|stderr|important output", message: "QA output missing exit/output evidence" },
       { name: "reproduction", pattern: "reproduction|reproduce|steps", message: "QA output missing reproduction steps" },
     ],
@@ -106,8 +106,8 @@ const OUTPUT_CONTRACTS: OutputContract[] = [
     required: [
       ...COMMON_OUTPUT_REQUIREMENTS,
       { name: "consensus", pattern: "<consensus>|\\bconsensus\\b", message: "Synthesis output missing consensus section" },
-      { name: "conflicts", pattern: "<conflicts>|conflicts?|désaccords?", message: "Synthesis output missing conflicts section" },
-      { name: "missing_evidence", pattern: "<missing_evidence>|missing_evidence|missing evidence|preuves manquantes", message: "Synthesis output missing missing_evidence section" },
+      { name: "conflicts", pattern: "<conflicts>|conflicts?", message: "Synthesis output missing conflicts section" },
+      { name: "missing_evidence", pattern: "<missing_evidence>|missing_evidence|missing evidence", message: "Synthesis output missing missing_evidence section" },
       { name: "recommended_next_action", pattern: "<recommended_next_action>|recommended_next_action|recommended next action", message: "Synthesis output missing recommended_next_action section" },
       { name: "tasks_to_rerun", pattern: "<tasks_to_rerun>|tasks_to_rerun|tasks to rerun|rerun", message: "Synthesis output missing tasks_to_rerun section" },
     ],
@@ -119,9 +119,9 @@ const OUTPUT_CONTRACTS: OutputContract[] = [
     required: [
       ...COMMON_OUTPUT_REQUIREMENTS,
       { name: "verdict", pattern: "<verdict>\\s*(PASS|FAIL|WARN)\\s*</verdict>|\\b(PASS|FAIL|WARN)\\b", message: "Oracle merge output missing PASS/FAIL/WARN verdict" },
-      { name: "confidence", pattern: "<confidence>|\\bconfidence\\b|confiance", message: "Oracle merge output missing confidence" },
+      { name: "confidence", pattern: "<confidence>|\\bconfidence\\b", message: "Oracle merge output missing confidence" },
       { name: "no_ship", pattern: "<no_ship>|no_ship|no ship", message: "Oracle merge output missing no_ship decision" },
-      { name: "blocking_issues", pattern: "<blocking_issues>|blocking issues?|blockers?|bloqueurs", message: "Oracle merge output missing blocking issues" },
+      { name: "blocking_issues", pattern: "<blocking_issues>|blocking issues?|blockers?", message: "Oracle merge output missing blocking issues" },
       { name: "merged_lanes", pattern: "<merged_lanes>|merged_lanes|merged lanes", message: "Oracle merge output missing merged_lanes" },
     ],
   },
@@ -146,8 +146,8 @@ const OUTPUT_CONTRACTS: OutputContract[] = [
     required: [
       ...COMMON_OUTPUT_REQUIREMENTS,
       { name: "sources", pattern: "sources?|sources_consulted|URLs?|paths?", message: "Research output missing sources" },
-      { name: "unknowns", pattern: "unknowns?|uncertainties|incertitudes", message: "Research output missing unknowns/uncertainties" },
-      { name: "recommendation", pattern: "recommendation|recommandation", message: "Research output missing recommendation" },
+      { name: "unknowns", pattern: "unknowns?|uncertainties", message: "Research output missing unknowns/uncertainties" },
+      { name: "recommendation", pattern: "recommendation", message: "Research output missing recommendation" },
     ],
   },
   {
@@ -163,7 +163,7 @@ const OUTPUT_CONTRACTS: OutputContract[] = [
       { name: "facts_or_patterns", pattern: "facts_or_patterns|facts|patterns", message: "Brain lookup output missing facts_or_patterns" },
       { name: "gaps", pattern: "gaps|source gaps", message: "Brain lookup output missing gaps" },
       { name: "freshness", pattern: "freshness|stale", message: "Brain lookup output missing freshness" },
-      { name: "confidence", pattern: "confidence|confiance", message: "Brain lookup output missing confidence" },
+      { name: "confidence", pattern: "confidence", message: "Brain lookup output missing confidence" },
       { name: "no_body_storage", pattern: "no_body_storage|bodyStored\s*[:=]\s*false|no body storage", message: "Brain lookup output missing no_body_storage" },
     ],
   },
@@ -218,15 +218,15 @@ const OUTPUT_CONTRACTS: OutputContract[] = [
     agentNames: ["specifier", "spec"],
     required: [
       ...COMMON_OUTPUT_REQUIREMENTS,
-      { name: "problem", pattern: "<problem>|\\bproblem\\b|problème|probleme", message: "Spec output missing problem" },
-      { name: "context", pattern: "<context>|\\bcontext\\b|contexte", message: "Spec output missing context" },
-      { name: "objectives", pattern: "<objectives>|objectives?|objectifs?", message: "Spec output missing objectives" },
-      { name: "non_goals", pattern: "<non_goals>|non[-_ ]goals?|non[-_ ]objectifs?", message: "Spec output missing non_goals" },
-      { name: "in_scope", pattern: "<in_scope>|in[-_ ]scope|périmètre inclus|perimetre inclus", message: "Spec output missing in_scope" },
-      { name: "out_of_scope", pattern: "<out_of_scope>|out[-_ ]of[-_ ]scope|hors[-_ ]scope|hors périmètre|hors perimetre", message: "Spec output missing out_of_scope" },
-      { name: "constraints", pattern: "<constraints>|constraints?|contraintes?", message: "Spec output missing constraints" },
-      { name: "acceptance_criteria", pattern: "<acceptance_criteria>|acceptance criteria|acceptance_criteria|critères d'acceptation|criteres d'acceptation", message: "Spec output missing acceptance_criteria" },
-      { name: "open_questions", pattern: "<open_questions>|open questions|open_questions|questions ouvertes", message: "Spec output missing open_questions" },
+      { name: "problem", pattern: "<problem>|\\bproblem\\b", message: "Spec output missing problem" },
+      { name: "context", pattern: "<context>|\\bcontext\\b", message: "Spec output missing context" },
+      { name: "objectives", pattern: "<objectives>|objectives?", message: "Spec output missing objectives" },
+      { name: "non_goals", pattern: "<non_goals>|non[-_ ]goals?", message: "Spec output missing non_goals" },
+      { name: "in_scope", pattern: "<in_scope>|in[-_ ]scope", message: "Spec output missing in_scope" },
+      { name: "out_of_scope", pattern: "<out_of_scope>|out[-_ ]of[-_ ]scope", message: "Spec output missing out_of_scope" },
+      { name: "constraints", pattern: "<constraints>|constraints?", message: "Spec output missing constraints" },
+      { name: "acceptance_criteria", pattern: "<acceptance_criteria>|acceptance criteria|acceptance_criteria", message: "Spec output missing acceptance_criteria" },
+      { name: "open_questions", pattern: "<open_questions>|open questions|open_questions", message: "Spec output missing open_questions" },
       { name: "handoff_to_planner", pattern: "<handoff_to_planner>|handoff to planner|handoff_to_planner|planner", message: "Spec output missing handoff_to_planner" },
     ],
   },
@@ -236,15 +236,15 @@ const OUTPUT_CONTRACTS: OutputContract[] = [
     agentNames: ["clarifier"],
     required: [
       ...COMMON_OUTPUT_REQUIREMENTS,
-      { name: "clarity_score", pattern: "<clarity_score>|clarity_score|clarity score|score de clarté", message: "Clarification output missing clarity_score" },
+      { name: "clarity_score", pattern: "<clarity_score>|clarity_score|clarity score", message: "Clarification output missing clarity_score" },
       { name: "verdict", pattern: "<verdict>\\s*(CLEAR|NEEDS_CLARIFICATION|BLOCKED)\\s*</verdict>|\\b(CLEAR|NEEDS_CLARIFICATION|BLOCKED)\\b", message: "Clarification output missing CLEAR/NEEDS_CLARIFICATION/BLOCKED verdict" },
       { name: "allow_plan", pattern: "<allow_plan>\\s*(yes|no)\\s*</allow_plan>|allow_plan\\s*[:=]\\s*(yes|no)", message: "Clarification output missing allow_plan yes/no" },
-      { name: "ambiguities", pattern: "<ambiguities>|ambiguities|ambiguïtés|ambiguites", message: "Clarification output missing ambiguities" },
+      { name: "ambiguities", pattern: "<ambiguities>|ambiguities", message: "Clarification output missing ambiguities" },
       { name: "questions", pattern: "<questions>|questions?", message: "Clarification output missing questions" },
-      { name: "assumptions", pattern: "<assumptions>|assumptions?|hypothèses|hypotheses", message: "Clarification output missing assumptions" },
-      { name: "refined_spec", pattern: "<refined_spec>|refined spec|refined_spec|spec affinée|spec affinee", message: "Clarification output missing refined_spec" },
+      { name: "assumptions", pattern: "<assumptions>|assumptions?", message: "Clarification output missing assumptions" },
+      { name: "refined_spec", pattern: "<refined_spec>|refined spec|refined_spec", message: "Clarification output missing refined_spec" },
       { name: "minimum_to_plan", pattern: "<minimum_to_plan>|minimum to plan|minimum_to_plan", message: "Clarification output missing minimum_to_plan" },
-      { name: "acceptance_criteria", pattern: "<acceptance_criteria>|acceptance criteria|acceptance_criteria|critères d'acceptation|criteres d'acceptation", message: "Clarification output missing acceptance_criteria" },
+      { name: "acceptance_criteria", pattern: "<acceptance_criteria>|acceptance criteria|acceptance_criteria", message: "Clarification output missing acceptance_criteria" }
     ],
   },
   {

package/.pi/extensions/zob-harness/src/domains/factory/agentic-plan.ts

@@ -5,7 +5,7 @@ function detectCanonicalPatterns(text: string): string[] {
   if (/TASK\s*:|EXPECTED\s+OUTCOME\s*:|MUST\s+NOT/i.test(text)) patterns.add("delegation.contract.structured");
   if (/delegate_(agent|task)|sub-?agent|oracle|explore/i.test(text)) patterns.add("routing.subagent.specialized");
   if (/PASS|FAIL|WARN|verdict/i.test(text)) patterns.add("verification.verdict_first");
-  if (/evidence|preuve|preuves|sentinel|DONE/i.test(text)) patterns.add("verification.evidence_required");
+  if (/evidence|proof|sentinel|DONE/i.test(text)) patterns.add("verification.evidence_required");
   if (/factory_run|software factory|factory|manifest|checkpoint/i.test(text)) patterns.add("factory.workflow.manifest_checkpoint");
   if (/damage-control|destructive|secret|zero-access|sandbox/i.test(text)) patterns.add("safety.damage_control");
   if (/truncat|output cut|silent response/i.test(text)) patterns.add("failure.output.truncation");

package/.pi/extensions/zob-harness/src/domains/goal/goal-todo-types.ts

@@ -69,6 +69,26 @@ export interface TodoSplitRequest {
   hasFinalMarker: boolean;
 }
 
+export type TodoPeerStatusClaim = "done" | "incomplete" | "blocked";
+
+export interface TodoPeerResultItem {
+  todoId?: string;
+  statusClaim?: TodoPeerStatusClaim;
+  evidenceRefs: string[];
+  validationCommands: string[];
+  risks: string[];
+  acceptanceBlockers: string[];
+  noShip?: boolean;
+  hasFinalMarker: boolean;
+}
+
+export interface TodoPeerResultParseResult {
+  contract?: "TODO_PEER_RESULT.v1" | "TODO_PEER_BUNDLE_RESULT.v1";
+  items: TodoPeerResultItem[];
+  hasFinalMarker: boolean;
+  errors: string[];
+}
+
 export interface GoalTodoDelegationRef {
   runId?: string;
   agent?: string;

package/.pi/extensions/zob-harness/src/domains/goal/goal-todos.ts

@@ -30,6 +30,8 @@ import type {
   GoalTodoSummary,
   ResolveGoalTodoAction,
   TodoClaimValidationResult,
+  TodoPeerResultItem,
+  TodoPeerResultParseResult,
   TodoSplitRequest,
 } from "./goal-todo-types.js";
 import { recordZcommitOwnedPaths, type ZcommitChildChangedPathRef } from "../git/git-ops.js";
@@ -67,6 +69,8 @@ export type {
   GoalTodoSummary,
   ResolveGoalTodoAction,
   TodoClaimValidationResult,
+  TodoPeerResultItem,
+  TodoPeerResultParseResult,
   TodoSplitRequest,
   TodoSplitRequestAction,
   TodoSplitRiskLevel,
@@ -395,15 +399,21 @@ function applyEvent(state: GoalTodoState, event: GoalTodoEvent): void {
         childChangedPaths: event.childChangedPaths ?? [],
         returnedAt: event.at,
       };
+      const claimStatus: GoalTodoStatus = event.statusClaim === "blocked"
+        ? "blocked"
+        : event.statusClaim === "incomplete" || event.noShip === true || (event.acceptanceBlockers ?? []).length > 0 || event.targetReadiness === "needs_parent_review" || event.targetReadiness === "blocked"
+          ? "needs_review"
+          : "claim_returned";
       replaceNode(state, applyPatchToNode(existing, {
-        status: "claim_returned",
+        status: claimStatus,
+        owner: claimStatus === "claim_returned" ? existing.owner : "agent",
         evidenceRefs,
         validationCommands,
         delegation: existing.delegation ? { ...existing.delegation, status: "claim_returned" } : undefined,
         claim,
         artifacts: { ...(existing.artifacts ?? {}), outputHash: event.outputHash ?? event.claimHash },
-        blocker: event.noShip === true ? "delegated claim returned advisory no_ship=true; parent review required" : undefined,
-        reviewNoShip: event.noShip === true,
+        blocker: claimStatus === "claim_returned" ? undefined : event.acceptanceBlockers?.[0] ?? (event.noShip === true ? "delegated claim returned advisory no_ship=true; parent review required" : `delegated claim status ${event.statusClaim ?? "needs_review"}; parent review required`),
+        reviewNoShip: claimStatus === "claim_returned" ? undefined : true,
       }));
     }
     return;
@@ -880,7 +890,7 @@ export function splitGoalTodo(pi: ExtensionAPI, state: HarnessRuntimeState, goal
   return children;
 }
 
-export function linkGoalTodoDelegation(pi: ExtensionAPI, state: HarnessRuntimeState, goalId: string, todoId: string, input: { runId: string; agent?: string; childGoalId?: string; requestId?: string; delegationDepth?: number }, source: GoalTodoEventSource = "delegation"): GoalTodoNode | undefined {
+export function linkGoalTodoDelegation(pi: ExtensionAPI, state: HarnessRuntimeState, goalId: string, todoId: string, input: { runId: string; agent?: string; childGoalId?: string; requestId?: string; delegationDepth?: number; status?: GoalTodoDelegationStatus }, source: GoalTodoEventSource = "delegation"): GoalTodoNode | undefined {
   const existing = state.goalTodos.nodes.find((node) => node.goalId === goalId && node.id === todoId);
   if (!existing) return undefined;
   const delegation: GoalTodoDelegationRef = {
@@ -889,7 +899,7 @@ export function linkGoalTodoDelegation(pi: ExtensionAPI, state: HarnessRuntimeSt
     childGoalId: input.childGoalId,
     requestId: input.requestId,
     delegationDepth: Math.max(0, Math.trunc(input.delegationDepth ?? existing.delegation?.delegationDepth ?? 1)),
-    status: "running",
+    status: input.status ?? "running",
   };
   appendGoalTodoEvent(pi, state, { version: 1, kind: "delegate_link", source, goalId, todoId, runId: input.runId, delegation, at: unixSeconds() });
   return state.goalTodos.nodes.find((node) => node.goalId === goalId && node.id === todoId);
@@ -1250,6 +1260,51 @@ function extractLabeledScalar(text: string, label: string): string | undefined {
   return match?.[1]?.trim();
 }
 
+function normalizePeerStatusClaim(value: string | undefined): TodoPeerResultItem["statusClaim"] {
+  const normalized = value?.trim().toLowerCase().replace(/[ -]/g, "_");
+  return normalized === "done" || normalized === "incomplete" || normalized === "blocked" ? normalized : undefined;
+}
+
+function extractTodoPeerResultItemFromText(text: string, hasFinalMarker: boolean): TodoPeerResultItem {
+  const todoIdMatch = text.match(/todo_id\s*[:=]\s*([^\s]+)/i);
+  const statusRaw = extractLabeledScalar(text, "status_claim") ?? extractLabeledScalar(text, "status");
+  const noShipMatch = text.match(/no_ship\s*[:=]\s*(true|yes|false|no)/i);
+  return {
+    todoId: todoIdMatch?.[1]?.trim(),
+    statusClaim: normalizePeerStatusClaim(statusRaw),
+    evidenceRefs: collectLabeledLines(text, /^\s*(?:[-*]\s*)?evidence_refs\s*[:=]/i),
+    validationCommands: collectLabeledLines(text, /^\s*(?:[-*]\s*)?validation_commands\s*[:=]/i),
+    risks: collectLabeledLines(text, /^\s*(?:[-*]\s*)?risks\s*[:=]/i),
+    acceptanceBlockers: collectLabeledLines(text, /^\s*(?:[-*]\s*)?acceptance_blockers\s*[:=]/i),
+    noShip: noShipMatch ? /^(true|yes)$/i.test(noShipMatch[1]) : undefined,
+    hasFinalMarker,
+  };
+}
+
+export function extractTodoPeerResultFromText(text: string): TodoPeerResultParseResult {
+  const bundle = /TODO_PEER_BUNDLE_RESULT\.v1/i.test(text);
+  const single = /TODO_PEER_RESULT\.v1/i.test(text);
+  const hasBundleMarker = /FINAL_MARKER\s*:\s*TODO_PEER_BUNDLE_RESULT_END|TODO_PEER_BUNDLE_RESULT_END/.test(text);
+  const hasSingleMarker = /FINAL_MARKER\s*:\s*TODO_PEER_RESULT_END|TODO_PEER_RESULT_END/.test(text);
+  const contract = bundle ? "TODO_PEER_BUNDLE_RESULT.v1" : single ? "TODO_PEER_RESULT.v1" : undefined;
+  const hasFinalMarker = bundle ? hasBundleMarker : single ? hasSingleMarker : false;
+  const errors: string[] = [];
+  if (!contract) return { items: [], hasFinalMarker: false, errors };
+  if (!hasFinalMarker) errors.push("missing_final_marker");
+  const itemTexts = bundle
+    ? text.split(/(?=^\s*(?:[-*]\s*)?todo_id\s*[:=])/gim).filter((part) => /todo_id\s*[:=]/i.test(part))
+    : [text];
+  const items = itemTexts.map((part) => extractTodoPeerResultItemFromText(part, hasFinalMarker));
+  if (items.length === 0) errors.push("missing_result_items");
+  for (const item of items) {
+    if (!item.todoId) errors.push("missing_todo_id");
+    if (!item.statusClaim) errors.push(`missing_status_claim:${item.todoId ?? "unknown"}`);
+    if (item.statusClaim === "done" && item.evidenceRefs.length === 0 && item.validationCommands.length === 0) errors.push(`missing_evidence_for_done:${item.todoId ?? "unknown"}`);
+    if (item.noShip === true) errors.push(`no_ship_true:${item.todoId ?? "unknown"}`);
+  }
+  return { contract, items, hasFinalMarker, errors: [...new Set(errors)] };
+}
+
 export function extractTodoClaimValidationFromText(text: string): TodoClaimValidationResult {
   const todoIdMatch = text.match(/todo_id\s*[:=]\s*([^\s]+)/i);
   const claimHashMatch = text.match(/claim_hash\s*[:=]\s*([a-f0-9]{64})/i);

package/.pi/extensions/zob-harness/src/domains/project-dna/project-dna.ts

@@ -5,7 +5,7 @@ import { sha256 } from "../../core/utils/hashing.js";
 import { isRecord } from "../../core/utils/records.js";
 import { safeRunId } from "../../core/utils/paths.js";
 
-const STOPWORDS = new Set(["the", "and", "for", "with", "how", "does", "this", "that", "dans", "avec", "pour", "comment", "faire", "using", "use", "project", "style"]);
+const STOPWORDS = new Set(["the", "and", "for", "with", "how", "does", "this", "that", "using", "use", "project", "style"]);
 const DEFAULT_SCAN_DIR = "reports/project-dna-scans/project-dna-factory-smoke";
 const SAFE_SCAN_PREFIXES = ["reports/project-dna-scans/"];
 const MAX_CONTEXT_TOKENS_CAP = 8000;

package/.pi/extensions/zob-harness/src/domains/telemetry/chronicle.ts

@@ -89,7 +89,7 @@ export function evaluateBudgetPreflightDryRun(input: BudgetPreflightDryRunInput)
 
 function outputHasEvidenceMarker(output: string | undefined): boolean {
   if (!output) return false;
-  return /(?:<evidence>[\s\S]*?<\/evidence>|<evidence>|\bevidence\b|preuve|preuves)/i.test(output);
+  return /(?:<evidence>[\s\S]*?<\/evidence>|<evidence>|\bevidence\b|proof)/i.test(output);
 }
 
 export function detectOracleFail(output: string | undefined): { oracleFailed: boolean; noShip: boolean; stopCondition: ChildStopCondition } {

package/.pi/extensions/zob-harness/src/factory/AGENTS.md

@@ -1,24 +1,24 @@
-# Scope du dossier
+# Directory scope
 
-- Validation factory, plan agentic, exécution factory et quarantine review/activate/verify.
-- Ce dossier ne doit pas enregistrer de Pi tools directement; le runtime délègue ici.
+- Factory validation, agentic plans, factory execution, and quarantine review/activate/verify.
+- This directory must not register Pi tools directly; runtime delegates here.
 
 # Invariants
 
-- Préserver `SMOKE_PASSED.sentinel`, `PILOT_PASSED.sentinel`, `BATCH_PASSED.sentinel`, `DONE.sentinel`.
-- `plan_only` ne crée pas de sentinels de complétion.
-- Pilot exige une review oracle persistée et un manifest multi-item.
-- Factory-forge quarantine ne s'auto-active jamais.
-- Activation refuse overwrite et exige phrase exacte.
-- Ne pas changer noms d'artefacts, statuts ou validations.
+- Preserve `SMOKE_PASSED.sentinel`, `PILOT_PASSED.sentinel`, `BATCH_PASSED.sentinel`, and `DONE.sentinel`.
+- `plan_only` does not create completion sentinels.
+- Pilot requires a persisted oracle review and a multi-item manifest.
+- Factory-forge quarantine never self-activates.
+- Activation refuses overwrite and requires the exact phrase.
+- Do not change artifact names, statuses, or validations.
 
 # Imports
 
-- Peut importer utils/safety/output-contracts/telemetry/child-runner selon besoin.
-- Interdit: importer depuis `index.ts`.
-- Imports relatifs runtime avec suffixe `.js`.
+- May import utils/safety/output-contracts/telemetry/child-runner as needed.
+- Forbidden: importing from `index.ts`.
+- Use runtime-relative imports with a `.js` suffix.
 
-# Validation locale
+# Local validation
 
 - `npm run check -- --pretty false`.
-- `npm run smoke:harness` après toute tranche factory/quarantine.
+- `npm run smoke:harness` after any factory/quarantine slice.