zob-harness 0.1.0

package/.pi/extensions/zob-child-safety/index.ts

@@ -0,0 +1,212 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { isToolCallEventType } from "@earendil-works/pi-coding-agent";
+
+interface DamageRule {
+  pattern: string;
+  reason: string;
+  ask?: boolean;
+}
+
+interface DamageRules {
+  bashToolPatterns: DamageRule[];
+  zeroAccessPaths: string[];
+  readOnlyPaths: string[];
+  noDeletePaths: string[];
+}
+
+const DEFAULT_RULES: DamageRules = {
+  bashToolPatterns: [
+    { pattern: "\\brm\\s+(-rf?|--recursive)", reason: "recursive deletion" },
+    { pattern: "\\bgit\\s+reset\\s+--hard\\b", reason: "destructive git reset" },
+    { pattern: "\\bgit\\s+clean\\s+-", reason: "destructive git clean" },
+    { pattern: "\\bgit\\s+add\\s+(-A|\\.)", reason: "bulk git staging" },
+    { pattern: "\\bsudo\\b", reason: "privileged command" },
+  ],
+  zeroAccessPaths: [".env", ".env.*", "~/.ssh", "~/.aws", "*.pem", "*.key"],
+  readOnlyPaths: [".git/", "node_modules/", "dist/", "build/", "package-lock.json", "pnpm-lock.yaml", "bun.lock"],
+  noDeletePaths: [".git/", "AGENTS.md", "README.md", ".pi/"],
+};
+
+function expandHome(input: string): string {
+  if (input === "~") return homedir();
+  if (input.startsWith("~/")) return join(homedir(), input.slice(2));
+  return input;
+}
+
+function wildcardToRegex(pattern: string): RegExp {
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+  return new RegExp(`(^|/)${escaped}($|/)`);
+}
+
+export function pathMatches(targetPath: string, pattern: string, cwd: string, policyRoot = cwd): boolean {
+  const expanded = expandHome(pattern);
+  const root = resolve(policyRoot);
+  const normalizedTarget = resolve(cwd, expandHome(targetPath));
+  const relativeTarget = normalizedTarget.startsWith(root) ? normalizedTarget.slice(root.length + 1) : normalizedTarget;
+  if (expanded.endsWith("/")) {
+    const prefix = resolve(root, expanded.slice(0, -1));
+    return normalizedTarget === prefix || normalizedTarget.startsWith(`${prefix}/`) || relativeTarget.startsWith(expanded);
+  }
+  const regex = wildcardToRegex(expanded);
+  return regex.test(normalizedTarget) || regex.test(relativeTarget) || relativeTarget.includes(expanded);
+}
+
+export function parsePathListEnv(value: string | undefined): string[] {
+  if (!value) return [];
+  return value
+    .split(/[,:\n]/)
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+export function validateRuntimeWritePolicy(input: {
+  targetPath: string;
+  cwd: string;
+  policyRoot?: string;
+  allowedPaths?: string[];
+  forbiddenPaths?: string[];
+  zeroAccessPaths?: string[];
+  readOnlyPaths?: string[];
+  sandboxRoot?: string;
+}): { allowed: boolean; violations: string[] } {
+  const policyRoot = input.policyRoot ?? input.cwd;
+  const violations: string[] = [];
+  for (const protectedPattern of input.zeroAccessPaths ?? []) {
+    if (pathMatches(input.targetPath, protectedPattern, input.cwd, policyRoot)) violations.push(`zero-access path: ${protectedPattern}`);
+  }
+  for (const forbiddenPattern of input.forbiddenPaths ?? []) {
+    if (pathMatches(input.targetPath, forbiddenPattern, input.cwd, policyRoot)) violations.push(`forbidden path: ${forbiddenPattern}`);
+  }
+  for (const readOnlyPattern of input.readOnlyPaths ?? []) {
+    if (pathMatches(input.targetPath, readOnlyPattern, input.cwd, policyRoot)) violations.push(`read-only path: ${readOnlyPattern}`);
+  }
+  const allowedPaths = input.allowedPaths ?? [];
+  if (allowedPaths.length > 0 && !allowedPaths.some((allowedPath) => pathMatches(input.targetPath, allowedPath, input.cwd, policyRoot))) {
+    violations.push(`outside allowed_paths: ${allowedPaths.join(", ")}`);
+  }
+  if (input.sandboxRoot) {
+    const sandboxRoot = resolve(policyRoot, expandHome(input.sandboxRoot));
+    const target = resolve(input.cwd, expandHome(input.targetPath));
+    if (target !== sandboxRoot && !target.startsWith(`${sandboxRoot}/`)) violations.push(`outside sandbox root: ${input.sandboxRoot}`);
+  }
+  return { allowed: violations.length === 0, violations };
+}
+
+function loadDamageRules(cwd: string): DamageRules {
+  const root = process.env.ZOB_HARNESS_ROOT || cwd;
+  const candidate = join(root, ".pi", "damage-control-rules.json");
+  if (!existsSync(candidate)) return DEFAULT_RULES;
+  try {
+    const loaded = JSON.parse(readFileSync(candidate, "utf8")) as Partial<DamageRules>;
+    return {
+      bashToolPatterns: loaded.bashToolPatterns ?? DEFAULT_RULES.bashToolPatterns,
+      zeroAccessPaths: loaded.zeroAccessPaths ?? DEFAULT_RULES.zeroAccessPaths,
+      readOnlyPaths: loaded.readOnlyPaths ?? DEFAULT_RULES.readOnlyPaths,
+      noDeletePaths: loaded.noDeletePaths ?? DEFAULT_RULES.noDeletePaths,
+    };
+  } catch {
+    return DEFAULT_RULES;
+  }
+}
+
+function blockedFeedback(toolName: string, reason: string, attempted: string): string {
+  return [
+    `ZOB child safety blocked ${toolName}: ${reason}`,
+    "",
+    `Attempted: ${attempted}`,
+    "",
+    "Continue safely:",
+    "- Do not retry the same blocked call.",
+    "- If a secret or destructive operation is required, stop and ask the parent/user for explicit approval.",
+    "- Produce a safe partial result with evidence and blockers instead.",
+  ].join("\n");
+}
+
+export default function zobChildSafety(pi: ExtensionAPI): void {
+  let rules: DamageRules = DEFAULT_RULES;
+
+  pi.on("session_start", async (_event, ctx) => {
+    rules = loadDamageRules(ctx.cwd);
+    ctx.ui.setStatus("zob-child-safety", ctx.ui.theme.fg("accent", "child-safe"));
+  });
+
+  pi.on("tool_call", async (event, ctx) => {
+    let violation: string | undefined;
+    let attempted = JSON.stringify(event.input);
+    const pathInputs: string[] = [];
+    const policyRoot = process.env.ZOB_HARNESS_ROOT || ctx.cwd;
+
+    if (isToolCallEventType("read", event) || isToolCallEventType("write", event) || isToolCallEventType("edit", event)) {
+      pathInputs.push(event.input.path);
+    }
+    if (isToolCallEventType("grep", event) || isToolCallEventType("find", event) || isToolCallEventType("ls", event)) {
+      pathInputs.push(event.input.path ?? ".");
+    }
+
+    const inheritedAllowedPaths = parsePathListEnv(process.env.ZOB_ALLOWED_PATHS);
+    const inheritedForbiddenPaths = parsePathListEnv(process.env.ZOB_FORBIDDEN_PATHS);
+    const sandboxRoot = process.env.ZOB_SANDBOX_ROOT;
+
+    for (const inputPath of pathInputs) {
+      for (const protectedPattern of rules.zeroAccessPaths) {
+        if (pathMatches(inputPath, protectedPattern, ctx.cwd, policyRoot)) violation = `zero-access path: ${protectedPattern}`;
+      }
+      if (!violation) {
+        for (const forbiddenPattern of inheritedForbiddenPaths) {
+          if (pathMatches(inputPath, forbiddenPattern, ctx.cwd, policyRoot)) violation = `forbidden path: ${forbiddenPattern}`;
+        }
+      }
+      if ((event.toolName === "write" || event.toolName === "edit") && !violation) {
+        const writePolicy = validateRuntimeWritePolicy({
+          targetPath: inputPath,
+          cwd: ctx.cwd,
+          policyRoot,
+          allowedPaths: inheritedAllowedPaths,
+          forbiddenPaths: inheritedForbiddenPaths,
+          zeroAccessPaths: rules.zeroAccessPaths,
+          readOnlyPaths: rules.readOnlyPaths,
+          sandboxRoot,
+        });
+        if (!writePolicy.allowed) violation = writePolicy.violations[0];
+      }
+    }
+
+    if (isToolCallEventType("bash", event)) {
+      const command = event.input.command;
+      attempted = command;
+      for (const rule of rules.bashToolPatterns) {
+        if (new RegExp(rule.pattern, "i").test(command)) {
+          violation = rule.reason;
+          break;
+        }
+      }
+      if (!violation) {
+        for (const protectedPattern of rules.zeroAccessPaths) {
+          if (command.includes(protectedPattern)) violation = `bash references zero-access path: ${protectedPattern}`;
+        }
+      }
+      if (!violation) {
+        for (const forbiddenPattern of inheritedForbiddenPaths) {
+          if (command.includes(forbiddenPattern)) violation = `bash references forbidden path: ${forbiddenPattern}`;
+        }
+      }
+      if (!violation) {
+        for (const noDelete of rules.noDeletePaths) {
+          if (command.includes(noDelete) && /\b(rm|mv)\b/.test(command)) violation = `delete/move protected path: ${noDelete}`;
+        }
+      }
+    }
+
+    if (violation) {
+      pi.appendEntry("zob-child-safety", { tool: event.toolName, input: event.input, violation, timestamp: Date.now() });
+      return { block: true, reason: blockedFeedback(event.toolName, violation, attempted) };
+    }
+  });
+
+  pi.on("session_shutdown", async (_event, ctx) => {
+    ctx.ui.setStatus("zob-child-safety", undefined);
+  });
+}

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

@@ -0,0 +1,28 @@
+# Scope du dossier
+
+- Ce dossier contient l'extension Pi `zob-harness`, son entrypoint `index.ts` et les modules sidecar du refactor split-only.
+- `index.ts` reste l'entrypoint Pi déclaré dans `package.json` jusqu'à approval explicite d'une bascule finale.
+- Les sous-dossiers `src/**` contiennent uniquement de la logique extraite ou du contexte local; ils ne remplacent pas l'entrypoint sans review.
+
+# Invariants
+
+- Split-only: déplacer du code sans changer le comportement observable.
+- Préserver le `default export` `zobHarness(pi)`.
+- Préserver tous les exports publics utilisés par `scripts/harness-smoke.mjs`.
+- Ne pas changer noms de tools, commandes, event handlers, sentinels, artefacts, messages d'erreur, descriptions Typebox, snippets de prompts ou guidelines.
+- Ne pas changer l'ordre des arrays observables ni les defaults runtime.
+- Ne pas convertir les opérations `fs` sync en async.
+
+# Imports
+
+- En NodeNext, utiliser des imports relatifs avec suffixe `.js`.
+- `index.ts` peut rester hybride pendant la migration.
+- Aucun fichier `src/**` ne doit importer depuis `index.ts`.
+- Préférer `import type` pour les types.
+
+# Validation locale
+
+- Baseline avant tranche: `npm run check -- --pretty false`.
+- Après toute tranche code: `npm run check -- --pretty false`.
+- Après tranche domaine/runtime: `npm run smoke:harness`.
+- Avant bascule finale: `npm run check:all` et oracle read-only.

package/.pi/extensions/zob-harness/index.ts

@@ -0,0 +1,391 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+import zobHarnessRuntime from "./src/runtime/zobHarness.js";
+
+export { renderHarnessWidget } from "./src/runtime/widget.js";
+export { createHarnessRuntimeState, inferModeFromUserIntent } from "./src/runtime/state.js";
+
+export type {
+  AdaptiveDelegationGovernorState,
+  AdaptiveDelegationMode,
+  AdaptiveDelegationOracleMode,
+  AdaptiveDelegationPolicy,
+  AdaptiveDelegationPolicyInput,
+  AdaptiveDelegationRisk,
+  DelegationRequestProposal,
+  DelegationScore,
+  GovernorDecision,
+  ParentDispatchContract,
+  SupervisedReadonlyDispatchContract,
+  SupervisedReadonlyDispatchResult,
+  SupervisedReadonlyDispatcher,
+} from "./src/types.js";
+
+export { CHRONICLE_STATES } from "./src/chronicle.js";
+
+export type { ChronicleState } from "./src/chronicle.js";
+
+export type {
+  ChildStopCondition,
+  RuleAppliesTo,
+  RuleEnforcementLevel,
+  RuleOracleRequirement,
+  RulePack,
+  RuleResolution,
+  RuleResolverInput,
+} from "./src/types.js";
+
+export { pathMatches } from "./src/utils/paths.js";
+
+export { parseGoalState, validateGoalState, validateStrictGoalSpecAnchor, parseBillableJobIntake, validateBillableJobIntake } from "./src/goal.js";
+export type { StrictGoalSpecAnchor, StrictGoalSpecAnchorKind } from "./src/goal.js";
+export { DEFAULT_GOAL_ACTIVATION_MODE, clearRuntimeGoalContinuationState, clearRuntimeGoalContinuationStateFor, formatGoalActivationMode, formatRuntimeGoalSummary, queueRuntimeGoalContinuation, restoreRuntimeGoalFromBranch, resumeRuntimeGoal, runtimeGoalStatusLine } from "./src/goal-runtime.js";
+export type { GoalActivationMode, RuntimeGoal, RuntimeGoalStatus, RuntimeGoalOracleStatus, RuntimeGoalOracleVerdict } from "./src/goal-runtime.js";
+export { extractModeIntent, looksLikeCompletePlanResponse, stripModeIntentMarkup, validateModeIntent } from "./src/runtime/mode-intent.js";
+export type { ZobModeIntent, ZobModeIntentConfidence, ZobModeIntentRisk, ZobModeIntentValidation } from "./src/runtime/mode-intent.js";
+export { capturePlanArtifact, extractPlanTitle, shouldCapturePlanResponse } from "./src/runtime/plan-capture.js";
+export type { PlanCaptureInput, PlanCaptureResult, PlanIndexEntry } from "./src/runtime/plan-capture.js";
+export { ZOB_COMPACTION_CONTINUITY_CONTRACT, ZOB_TOOL_ROUTING_CONTRACT } from "./src/constants.js";
+export { ZOB_COMPACTION_DETAILS_SCHEMA, ZOB_COMPACTION_ENTRY_TYPE, ZOB_COMPACTION_HARD_CAP_TOKENS, ZOB_COMPACTION_LEDGER_SCHEMA, ZOB_COMPACTION_SUMMARY_SCHEMA, ZOB_COMPACTION_TARGET_TOKENS, buildDeterministicZobCompactionResult, buildDeterministicZobCompactionSummary, buildZobCompactionDetails, buildZobCompactionInstructions, buildZobCompactionLedgerEntry, buildZobCompactionStateCapsule, withZobCompactionDetails, zobCompactionBodyFreeViolations } from "./src/runtime/compaction-policy.js";
+export type { ZobCompactionDetails, ZobCompactionFileRefsInput, ZobCompactionInstructionInput, ZobCompactionLedgerEntry, ZobCompactionStateCapsule } from "./src/runtime/compaction-policy.js";
+export { isAdaptiveZmodeAlias, renderAdaptiveZmodeTemplate, resolveAdaptiveZmodeEntrypoint, validateAdaptiveZmodeEntrypoint } from "./src/runtime/adaptive-zmode.js";
+export type { AdaptiveZmodeAlias, AdaptiveZmodeEntrypoint } from "./src/runtime/adaptive-zmode.js";
+export {
+  ZOB_GOAL_TODO_ENTRY_TYPE,
+  acceptGoalTodoClaim,
+  addGoalTodo,
+  blockGoalTodo,
+  completeGoalTodo,
+  applyGoalRoomEventTodoReducer,
+  applyTodoSplitRequest,
+  createGoalTodoState,
+  defaultGoalTodoPolicy,
+  extractTodoClaimFromText,
+  extractTodoClaimValidationFromText,
+  extractTodoSplitRequestFromText,
+  formatGoalTodoDiagnostics,
+  formatGoalTodoHudLine,
+  formatGoalTodoPromptHint,
+  formatGoalTodoSummary,
+  formatGoalTodoTree,
+  goalTodoCompletionBlockers,
+  goalTodoCompletionDiagnostics,
+  handleGoalTodoTextCommand,
+  nextValidGoalTodoActions,
+  linkGoalTodoDelegation,
+  patchGoalTodo,
+  recordGoalTodoClaimValidationResult,
+  reduceGoalRoomEventToTodoDecision,
+  requestGoalTodoClaimValidation,
+  rejectGoalTodoClaim,
+  restoreGoalTodosFromBranch,
+  returnGoalTodoClaim,
+  resolveGoalTodo,
+  splitGoalTodo,
+  summarizeGoalTodos,
+  validateGoalTodoGraph,
+} from "./src/goal-todos.js";
+export type { GoalRoomTodoReducerAction, GoalRoomTodoReducerDecision, GoalTodoClaimRef, GoalTodoClaimValidationRef, GoalTodoCompletionDiagnostics, GoalTodoNode, GoalTodoOwner, GoalTodoPolicy, GoalTodoPriority, GoalTodoState, GoalTodoStatus, GoalTodoSummary, ResolveGoalTodoAction, TodoClaimValidationResult, TodoSplitRequest, TodoSplitRequestAction, TodoSplitRiskLevel } from "./src/goal-todos.js";
+export { importChainRunTodos, importFactoryRunTodos, importOrchestrationRunTodos } from "./src/goal-todo-imports.js";
+export type { GoalTodoImportResult } from "./src/goal-todo-imports.js";
+export { appendGoalRoomMessage, buildGoalRoomMessage, goalRoomBodyFreeViolations, isGoalRoomMessage, listGoalRoomMessages, validateGoalRoomMessageInput, validateGoalRoomMessageRecord } from "./src/goal-room.js";
+export type { GoalRoomAudience, GoalRoomListInput, GoalRoomMessageInput, GoalRoomMessageKind, GoalRoomPriority } from "./src/goal-room.js";
+export { buildPromptPackReport, defaultFactoryAgentPromptPacks, promptPackBodyFreeViolations, validatePromptPack } from "./src/prompt-packs.js";
+export type { PromptPackContextPolicy, PromptPackDefinition, PromptPackEvalResult, PromptPackEventPolicy, PromptPackReport, PromptPackRole } from "./src/prompt-packs.js";
+export { buildFactorySelectorSmokeReport, detectFactoryDemandSignals, loadFactorySelectorCandidates, selectFactoryForDemands } from "./src/factory-selector.js";
+export type { FactoryDemandInput, FactoryDemandSignal, FactorySelectionStatus, FactorySelectorCandidateInput, FactorySelectorCandidateScore, FactorySelectorDemandSummary, FactorySelectorResult, FactorySelectorSmokeReport } from "./src/factory-selector.js";
+export { buildControlledWorkerPoolPlan, buildLaunchAuthorizedApplySmokeReport, evaluateLaunchAuthorizedApplyGate } from "./src/launch-apply.js";
+export type { ApplyGateStatus, ControlledWorkerPoolLane, ControlledWorkerPoolPlan, LaunchAuthorizedApplyGate, LaunchAuthorizedApplyInput, LaunchAuthorizedApplySmokeReport, WorkerPoolLaneKind } from "./src/launch-apply.js";
+export { writeFullAutonomyTestRun } from "./src/full-autonomy-test.js";
+export type { FullAutonomyTestInput, FullAutonomyTestRun } from "./src/full-autonomy-test.js";
+export {
+  DEFAULT_INTERACTIVE_AUTONOMY_POLICY,
+  INTERACTIVE_AUTONOMY_MODES,
+  asInteractiveAutonomyMode,
+  buildInteractiveLaunchAuthorization,
+  createInteractiveAutonomyRuntimeState,
+  formatInteractiveAutonomyPromptHint,
+  formatInteractiveAutonomyStatus,
+  formatMissionReadinessForUi,
+  hashInteractiveAutonomyPolicy,
+  readInteractiveAutonomyPolicy,
+  restoreInteractiveAutonomyState,
+  scoreMissionReadiness,
+  toAutonomyStateLedgerEntry,
+  toMissionReadinessLedgerEntry,
+} from "./src/interactive-autonomy.js";
+export type { InteractiveAutonomyLaunchPolicy, InteractiveAutonomyMode, InteractiveAutonomyPolicy, InteractiveAutonomyRuntimeState, InteractiveAutonomySafetyPolicy, InteractiveAutonomyThresholds, InteractiveLaunchAuthorization, MissionReadinessDecision, MissionReadinessReport, MissionReadinessSignals, MissionReadinessVerdict, MissionRiskLevel } from "./src/interactive-autonomy.js";
+export { appendGovernedRequestsToGoalRoom, extractGovernedRequestsFromText, governedRequestBodyFreeViolations, isGovernedRequest, validateGovernedRequest } from "./src/governed-requests.js";
+export type { GovernedRequestExtractionResult, GovernedRequestKind, GovernedRequestPriority, GovernedRequestRecord, GovernedRequestRisk } from "./src/governed-requests.js";
+export { createWorkspaceClaim, isWorkspaceClaimRecord, isWorkspaceReleaseRecord, listWorkspaceClaims, releaseWorkspaceClaim, workspaceClaimBodyFreeViolations } from "./src/workspace-claims.js";
+export type { WorkspaceClaimInput, WorkspaceClaimMode, WorkspaceClaimRecord, WorkspaceClaimsListInput, WorkspaceClaimStatus, WorkspaceConflictWarning, WorkspaceReleaseInput, WorkspaceReleaseRecord } from "./src/workspace-claims.js";
+export { createWorkerPoolOwnerDecision, createWorkerPoolOwnerRequest, createWorkerPoolPlan, isWorkerPoolPlanRecord, listWorkerPoolPlans, workerPoolBodyFreeViolations } from "./src/worker-pool.js";
+export type { WorkerPoolAssignmentInput, WorkerPoolAssignmentRecord, WorkerPoolCommunicationPolicyInput, WorkerPoolCommunicationPolicyMode, WorkerPoolCommunicationPolicyRecord, WorkerPoolConflictRecord, WorkerPoolDecision, WorkerPoolOwnerDecisionInput, WorkerPoolOwnerDecisionRecord, WorkerPoolOwnerRequestInput, WorkerPoolOwnerRequestRecord, WorkerPoolPlanInput, WorkerPoolPlanRecord, WorkerPoolStatusInput } from "./src/worker-pool.js";
+export { decideMergeCandidate, isMergeCandidateRecord, isMergeDecisionRecord, listMergeQueue, mergeQueueBodyFreeViolations, submitMergeCandidate } from "./src/merge-queue.js";
+export type { MergeCandidateInput, MergeCandidatePriority, MergeCandidateRecord, MergeCandidateRisk, MergeDecision, MergeDecisionInput, MergeDecisionRecord, MergeQueueListInput } from "./src/merge-queue.js";
+export { DEFAULT_PROMOTION_GATES, advancePromotionCandidate, appendPromotionLedger, createPromotionCandidate, promotionCandidateDir, promotionCandidateRef, promotionReportsDir, summarizePromotionCandidates, transitionAllowed, validatePromotionCandidate, writePromotionCandidate } from "./src/promotion/candidate.js";
+export { addPromotionComsMessageRef, buildPromotionComsMessageRef, buildPromotionComsThread, validatePromotionComsMessageRef, validatePromotionComsReadiness, validatePromotionComsThread, writePromotionComsThread } from "./src/promotion/coms.js";
+export { applyDocumentationPromotionInQuarantine, prepareDocumentationPromotion, validateDocumentationPromotion, validateDocumentationPromotionCandidate } from "./src/promotion/documentation.js";
+export { activateFactoryPromotionInQuarantine, prepareFactoryPromotion, validateFactoryPromotionCandidate, validateFactoryPromotionManifest } from "./src/promotion/factory.js";
+export { applyTempAgentPromotionInQuarantine, prepareTempAgentPromotion, validateTempAgentCardForPromotion, validateTempAgentPromotionArtifact, validateTempAgentPromotionCandidate } from "./src/promotion/temp-agent.js";
+export { markWriteLaneAppliedInQuarantine, prepareWriteLanePromotion, validateWriteLaneDiffMetadata, validateWriteLanePromotionCandidate } from "./src/promotion/write-lane.js";
+export type { PromotionApplyScope, PromotionCandidateInput, PromotionCandidateRecord, PromotionComsMessageRef, PromotionComsThreadInput, PromotionComsThreadRecord, PromotionGates, PromotionKind, PromotionStatus, PromotionTransitionInput, PromotionValidationResult } from "./src/promotion/types.js";
+
+export {
+  listRulePackPaths,
+  loadRulePack,
+  loadRulePacks,
+  validateRulePack,
+  inferRuleProfile,
+  resolveRuleProfile,
+  formatRuleResolution,
+} from "./src/rules.js";
+
+export {
+  validateSixPartContract,
+  parseToolList,
+  validateToolList,
+  resolveChildCwd,
+  validateAllowedPathPolicy,
+  validateForbiddenPathPolicy,
+  validatePathPolicy,
+  parsePathListEnv,
+  validateRuntimeWritePolicy,
+  validateDelegationWriteScope,
+  validateDelegateTaskWriteScope,
+  createSandboxMetadata,
+  createDiffGateResult,
+  createRollbackMetadata,
+} from "./src/safety.js";
+
+export {
+  listOutputContracts,
+  getOutputContractDefinitions,
+  inferOutputContract,
+  validateOutputContractId,
+  validateOutputContract,
+  validateChildOutput,
+  applyChildGates,
+} from "./src/output-contracts.js";
+
+export { buildChildEnv } from "./src/safety.js";
+
+export {
+  validateSandboxWritePlanInputs,
+  runSandboxWritePlan,
+  validateSandboxIsolatedExecutionInputs,
+  runSandboxIsolatedExecution,
+  validateSandboxDiffReviewGateInputs,
+  runSandboxDiffReviewGate,
+  validateSandboxApplyReadinessInputs,
+  runSandboxApplyReadiness,
+  validateSandboxApplySimulationInputs,
+  runSandboxApplySimulation,
+  validateSandboxManualApplyPreflightInputs,
+  runSandboxManualApplyPreflight,
+} from "./src/sandbox.js";
+
+export {
+  buildAutonomyReadinessAudit,
+  writeAutonomyReadinessAuditReport,
+  buildFactoryRegistryReadinessAudit,
+  writeFactoryRegistryReadinessAuditReport,
+} from "./src/autonomy-readiness.js";
+
+export { validateBudgetPolicyConfig, evaluateStrictBudgetDispatchGate, buildBudgetReadinessAudit, writeBudgetReadinessAuditReport } from "./src/budget-policy.js";
+
+export {
+  evaluateBudgetPreflightDryRun,
+  detectOracleFail,
+  summarizeRunawayGuard,
+  classifyChildStopCondition,
+  classifyChronicleCompletion,
+  classifyDelegationChronicleCompletion,
+  classifyFactoryChronicleCompletion,
+  writeChronicleSnapshot,
+} from "./src/chronicle.js";
+
+export { buildCapabilityIndex, buildReuseScoutReport, writeCapabilityIndex, writeReuseScoutReport } from "./src/capabilities.js";
+
+export { buildAutonomousRuntimeDryRun, buildAutonomousRuntimeDryRunFinalReport, buildAutonomousRuntimeDryRunValidation, validateAutonomousReadOnlySmokeRunArtifacts, validateAutonomousRuntimeDryRunArtifacts, writeAutonomousReadOnlySmokeRunReport, writeAutonomousRuntimeDryRunReport } from "./src/autonomous-runtime.js";
+export type { AutonomousApplyPolicy, AutonomousBudgetProfile, AutonomousReadOnlySmokeRunInput, AutonomousRisk, AutonomousRuntimeDryRunInput } from "./src/autonomous-runtime.js";
+
+export { buildDaemonReadinessDryRun, writeDaemonReadinessDryRunReport } from "./src/daemon-readiness.js";
+
+export { validateDaemonPolicyConfig, buildDaemonPolicyReadinessAudit, writeDaemonPolicyReadinessAuditReport } from "./src/daemon-policy.js";
+
+export { DEFAULT_DAEMON_RUNTIME_POLICY, DAEMON_RUNTIME_STATUSES, buildDaemonRuntimeState, buildDaemonTickPlan, evaluateDaemonStopCondition, selectNextActionableTodo } from "./src/daemon-runtime.js";
+export type { DaemonLoopSnapshot, DaemonLoopStatus, DaemonRuntimeActionKind, DaemonRuntimeAutonomySnapshot, DaemonRuntimePolicy, DaemonRuntimeState, DaemonRuntimeStateInput, DaemonRuntimeStatus, DaemonRuntimeTodoCounts, DaemonRuntimeTodoRef, DaemonStopCondition, DaemonTickPlan } from "./src/daemon-runtime.js";
+
+export {
+  evaluateModelRoutingDryRun,
+  evaluateModelRoutingDispatchGate,
+  writeModelRoutingDryRunReport,
+  validateModelRoutingConfig,
+  buildModelRoutingReadinessAudit,
+  writeModelRoutingReadinessAuditReport,
+} from "./src/model-routing.js";
+
+export {
+  buildComputePreview,
+  resolveComputeProfile,
+  validateComputeProfileArtifacts,
+  writeComputeProfileReports,
+} from "./src/compute-profile.js";
+export type { ComputeCapsInput, ComputeDomain, ComputeEffectiveProfile, ComputePreviewConfidence, ComputePreviewInput, ComputeProfileValidationInput, ComputeRequestedProfile } from "./src/compute-profile.js";
+export { buildComputeWorkflowShape, validateComputeWorkflowShape } from "./src/compute-workflow-shape.js";
+export type { ComputeWorkflowShapeInput } from "./src/compute-workflow-shape.js";
+
+export {
+  buildProjectDnaFederatedQueryResult,
+  buildProjectDnaQueryResult,
+  buildProjectDnaReadinessAudit,
+  writeProjectDnaWritebackProposal,
+} from "./src/project-dna.js";
+export type { ProjectDnaFederatedQueryInput, ProjectDnaQueryInput, ProjectDnaWritebackProposalInput } from "./src/project-dna.js";
+
+export {
+  buildDelegationTelemetrySummary,
+  writeDelegationTelemetrySummary,
+  buildFactoryTelemetrySummary,
+  writeFactoryTelemetrySummary,
+  buildDailyTelemetrySummary,
+  writeDailyTelemetrySummary,
+} from "./src/telemetry.js";
+
+export {
+  READ_ONLY_QUEUE_JOB_TYPES,
+  getQueuePaths,
+  ensureQueueDirs,
+  validateReadOnlyQueueJob,
+  writeQueueLifecycleEvent,
+  runQueueDaemonTick,
+  buildQueueDashboardSummary,
+} from "./src/queue.js";
+
+export { loadTeamDefinition, validateTeamDefinition } from "./src/topology/teams.js";
+
+export {
+  listOrchestrationProfiles,
+  loadOrchestrationProfile,
+  validateOrchestrationProfile,
+  teamDefinitionFromOrchestrationProfile,
+  validateOrchestrateRunInputs,
+} from "./src/topology/orchestration-profiles.js";
+
+export {
+  listChainDefinitions,
+  loadChainDefinition,
+  validateChainDefinition,
+  validateChainRunInputs,
+  buildChainPlan,
+  runChainPlanOnly,
+} from "./src/topology/chains.js";
+
+export {
+  validateZobComsEdge,
+  buildZobComsMessage,
+  validateZobComsMessage,
+  appendZobComsMessage,
+  listZobComsMessages,
+  getZobComsMessage,
+  ackZobComsMessage,
+  transitionZobComsStatus,
+  replyZobComsMessage,
+  awaitZobComsMessage,
+} from "./src/topology/coms.js";
+
+export {
+  MISSION_CONTROL_COMMANDS,
+  validateMissionControlCommandProposal,
+  buildMissionControlCommandProposal,
+  writeMissionControlCommandProposal,
+  buildZobComsTransportReadiness,
+  buildZobCommunicationReadinessAudit,
+  buildMissionControlSnapshot,
+} from "./src/mission-control.js";
+
+export { readZobComsV2Policy, zobComsRegistryEnabled } from "./src/coms-v2/policy.js";
+export { buildZobComsProjectId, buildCurrentZobLivePeerCard } from "./src/coms-v2/identity.js";
+export { registerCurrentZobLivePeer, touchCurrentZobLivePeer, unregisterCurrentZobLivePeer, writeZobLivePeerCard, readZobLiveRegistrySnapshot } from "./src/coms-v2/registry.js";
+export { buildZobLivePresenceSummary, redactZobLivePeerForMissionControl } from "./src/coms-v2/presence.js";
+export { buildZobLiveEnvelope, buildZobLiveAckEnvelope, buildZobLivePongEnvelope, buildZobLiveErrorEnvelope, validateZobLiveEnvelope, parseZobLiveEnvelopeLine } from "./src/coms-v2/envelope.js";
+export { makeZobLocalEndpoint, bindZobLocalEndpoint, sendZobLocalEnvelope, pingZobLocalEndpoint, pruneZobLocalEndpoint } from "./src/coms-v2/local-transport.js";
+export { ZobPendingReplies } from "./src/coms-v2/pending-replies.js";
+export { buildZobLiveResponseCapture, buildZobLiveResponseEnvelope } from "./src/coms-v2/response-capture.js";
+export { appendLiveSendRequestedRef, appendLiveDeliveredStatus, appendLiveRunningStatus, appendLiveCompletedRef, appendLiveErrorStatus, appendPeerStaleStatus } from "./src/coms-v2/ledger-bridge.js";
+export { redactZobComsText, writeZobComsRedactedCapture } from "./src/coms-v2/transcript-capture.js";
+export type { ZobLiveEnvelope, ZobLiveEnvelopeType } from "./src/coms-v2/envelope.js";
+export type { ZobComsTranscriptCapturePolicy, ZobComsTranscriptMode, ZobComsTranscriptRetentionClass, ZobComsTransportMode, ZobComsV2Policy, ZobLivePeerCard, ZobLivePeerStatus, ZobLivePresenceSummary, ZobLiveRegistrySnapshot } from "./src/coms-v2/types.js";
+
+export {
+  buildContextBrainSourceRegistry,
+  buildDefaultContextScope,
+  validateContextScope,
+  buildBrainLookupResult,
+  validateBrainLookupResult,
+  buildContextPack,
+  validateContextPack,
+  buildContextWritebackProposal,
+  validateContextWritebackProposal,
+  writeContextWritebackProposal,
+  buildContextGbrainReadinessAudit,
+  writeContextGbrainReadinessAuditReport,
+} from "./src/context-gbrain.js";
+
+export { readLatestOrchestrationWidgetSummary, readHarnessReadinessWidgetSummary } from "./src/orchestration/widget-readers.js";
+
+export {
+  ADAPTIVE_DELEGATION_DEFAULT_MAX_TOTAL_AGENTS,
+  ADAPTIVE_DELEGATION_HARD_MAX_DEPTH,
+  ADAPTIVE_DELEGATION_HARD_MAX_TOTAL_AGENTS_WITH_ORACLE,
+  buildInitialAdaptiveDelegationGovernorState,
+  buildParentDispatchContractForDecision,
+  computeAdaptiveDelegationDuplicateSignature,
+  computeAdaptiveDelegationLineageHash,
+  computeAdaptiveDelegationNormalizedTaskHash,
+  computeAdaptiveDelegationRequestId,
+  decideDelegationRequest,
+  extractDelegationRequestsFromText,
+  normalizeAdaptiveDelegationPolicy,
+  scoreDelegationRequest,
+  updateGovernorState,
+  validateAdaptiveDelegationEvidenceRefs,
+  validateAdaptiveDelegationPolicy,
+  validateDelegationRequestHardGates,
+} from "./src/orchestration/adaptive-delegation.js";
+
+export { extractLeadPlanWorkerContracts, redactLeadPlanWorkerContractsForPersistence, validateLeadPlanWorkerContracts } from "./src/orchestration/lead-plan.js";
+
+export { writeAdaptiveWorkflowArtifacts, validateAdaptiveWorkflowArtifacts } from "./src/orchestration/adaptive-workflow.js";
+export type { AdaptiveWorkflowArtifactsInput, AdaptiveWorkflowArtifactsResult } from "./src/orchestration/adaptive-workflow.js";
+
+export { writeOrchestrationRoomArtifacts } from "./src/orchestration/room.js";
+
+export { runOrchestrateRun } from "./src/orchestration/run.js";
+
+export { buildSupervisedReadonlyNoMockFinalGate, buildSupervisedReadonlyRuntimeInvariants, runSupervisedReadonlyOrchestration } from "./src/orchestration/supervised-readonly.js";
+
+export {
+  factoryPhaseSentinelForMode,
+  validateFactoryStages,
+  loadFactoryDefinition,
+  loadFactoryInputManifest,
+  normalizeFactoryAdaptiveDispatchGate,
+  validateFactoryAdaptiveDispatchGate,
+  validateFactoryRunInputs,
+} from "./src/factory/validation.js";
+
+export { buildFactoryAgenticPlan } from "./src/factory/agentic-plan.js";
+
+export { buildAgenticFactoryNoMockFinalGate, runFactoryRun } from "./src/factory/run.js";
+
+export {
+  runFactoryQuarantineReview,
+  runFactoryQuarantineActivate,
+  runFactoryQuarantineVerifyActivation,
+} from "./src/factory/quarantine.js";
+
+export default function zobHarness(pi: ExtensionAPI): void {
+  return zobHarnessRuntime(pi);
+}

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

@@ -0,0 +1,25 @@
+# Scope du dossier
+
+- `src/**` reçoit les modules extraits de `.pi/extensions/zob-harness/index.ts`.
+- Chaque module doit correspondre à une tranche claire du playbook de refactor.
+- Ce dossier ne contient pas de nouvelle fonctionnalité produit.
+
+# Invariants
+
+- Move-only: conserver logique, strings, validations, defaults et ordre observable.
+- Les exports publics doivent rester disponibles depuis `index.ts` jusqu'à la bascule finale.
+- Éviter les cycles; isoler types, constantes et utils avant runtime.
+- Ne pas stocker de prompt/output bodies dans telemetry/coms.
+
+# Imports
+
+- Imports relatifs NodeNext avec suffixe `.js` pour les imports runtime.
+- `import type` pour les types.
+- Interdit: importer depuis `../index.js`, `../../index.js` ou `index.ts`.
+- Les modules bas niveau ne doivent pas dépendre de runtime Pi.
+
+# Validation locale
+
+- `npm run check -- --pretty false` après chaque tranche.
+- `npm run smoke:harness` après safety, output-contracts, queue, topology, orchestration, factory, child-runner ou runtime.
+- Oracle read-only avant de passer à la tranche suivante si une API publique est touchée.