zob-harness 0.1.0

package/.pi/extensions/zob-harness/src/runtime/tools-goal-room.ts

@@ -0,0 +1,46 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+import { appendGoalRoomMessage, listGoalRoomMessages } from "../goal-room.js";
+import { ZobGoalRoomListParams, ZobGoalRoomSendParams } from "../schemas.js";
+import { loadTeamDefinition, validateTeamDefinition } from "../topology/teams.js";
+import type { TeamDefinition } from "../types.js";
+
+export function registerGoalRoomTools(pi: ExtensionAPI): void {
+  pi.registerTool({
+    name: "zob_goal_room_send",
+    label: "ZOB Goal Room Send",
+    description: "Append a visible typed GOAL_ROOM_MESSAGE.v1 to the parent-visible goal room. Metadata/hash-only; no hidden worker-to-worker free chat; no action execution.",
+    promptSnippet: "Post a typed metadata-only message to the shared goal room.",
+    parameters: ZobGoalRoomSendParams,
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const team = loadTeamDefinition(ctx.cwd, params.team ?? "zob-core");
+      const errors = [...team.errors, ...validateTeamDefinition(ctx.cwd, team.definition)];
+      if (errors.length > 0 || !team.definition) return { content: [{ type: "text", text: `zob_goal_room_send failed_preflight:\n- ${errors.join("\n- ")}` }], details: { status: "failed_preflight", errors } };
+      try {
+        const message = appendGoalRoomMessage(ctx.cwd, team.definition as TeamDefinition, params);
+        pi.appendEntry("zob-goal-room", { event: "message_appended", msgId: message.msgId, goalId: message.goalId, sender: message.sender, kind: message.kind, bodyStored: false, promptBodiesStored: false, outputBodiesStored: false });
+        return { content: [{ type: "text", text: `zob_goal_room_send: ${message.msgId}` }], details: { schema: "zob.goal-room-send-result.v1", message } };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { content: [{ type: "text", text: `zob_goal_room_send blocked: ${message}` }], details: { status: "blocked", errors: [message] } };
+      }
+    },
+  });
+
+  pi.registerTool({
+    name: "zob_goal_room_list",
+    label: "ZOB Goal Room List",
+    description: "List parent-visible typed goal-room messages. Bodies are never returned because only hashes/metadata are persisted.",
+    promptSnippet: "List metadata-only messages in the shared goal room.",
+    parameters: ZobGoalRoomListParams,
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      try {
+        const messages = listGoalRoomMessages(ctx.cwd, params);
+        return { content: [{ type: "text", text: `zob_goal_room_list: ${messages.length} message(s)` }], details: { schema: "zob.goal-room-list.v1", messages } };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { content: [{ type: "text", text: `zob_goal_room_list blocked: ${message}` }], details: { status: "blocked", errors: [message] } };
+      }
+    },
+  });
+}

package/.pi/extensions/zob-harness/src/runtime/tools-governed-requests.ts

@@ -0,0 +1,38 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+import { appendGovernedRequestsToGoalRoom, extractGovernedRequestsFromText, governedRequestBodyFreeViolations } from "../governed-requests.js";
+import { GovernedRequestExtractParams } from "../schemas.js";
+import { loadTeamDefinition, validateTeamDefinition } from "../topology/teams.js";
+
+export function registerGovernedRequestTools(pi: ExtensionAPI): void {
+  pi.registerTool({
+    name: "zob_governed_request_extract",
+    label: "ZOB Governed Request Extract",
+    description: "Extract DELEGATION_REQUEST.v1 / ORACLE_REQUEST.v1 / CONTEXT_REQUEST.v1 / OWNER_CHANGE_REQUEST.v1 from transient text, append parent-visible Goal Room requests, and never dispatch, apply, or mutate TODO state.",
+    promptSnippet: "Extract governed requests from transient child output without executing actions.",
+    parameters: GovernedRequestExtractParams,
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const team = loadTeamDefinition(ctx.cwd, params.team ?? "zob-core");
+      const errors = [...team.errors, ...validateTeamDefinition(ctx.cwd, team.definition)];
+      if (!team.definition || errors.length > 0) return { content: [{ type: "text", text: `zob_governed_request_extract failed_preflight:\n- ${errors.join("\n- ")}` }], details: { status: "failed_preflight", errors } };
+      const extraction = extractGovernedRequestsFromText(params.transient_text);
+      const persisted = params.append_to_goal_room === false ? extraction : appendGovernedRequestsToGoalRoom(ctx.cwd, team.definition, params.goal_id, extraction);
+      const bodyFreeViolations = governedRequestBodyFreeViolations(persisted);
+      const details = {
+        ...persisted,
+        bodyFreeViolations,
+        appendToGoalRoom: params.append_to_goal_room !== false,
+        parentOwnedActions: true,
+        childDirectDispatch: false,
+        dispatchExecuted: false,
+        canonicalTodoMutation: false,
+      };
+      const status = persisted.extractionErrors.length === 0 && bodyFreeViolations.length === 0 ? "ok" : "blocked";
+      pi.appendEntry("zob-governed-request", { event: "extracted", status, requests: persisted.requests.length, goalRoomMessages: persisted.goalRoomMessageIds.length, sourceOutputHash: persisted.sourceOutputHash, bodyStored: false, promptBodiesStored: false, outputBodiesStored: false, dispatchExecuted: false, childDirectDispatch: false });
+      return {
+        content: [{ type: "text", text: `zob_governed_request_extract: ${status}; requests=${persisted.requests.length}; goal_room_messages=${persisted.goalRoomMessageIds.length}` }],
+        details,
+      };
+    },
+  });
+}

package/.pi/extensions/zob-harness/src/runtime/tools-merge-queue.ts

@@ -0,0 +1,61 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+import { decideMergeCandidate, listMergeQueue, mergeQueueBodyFreeViolations, submitMergeCandidate } from "../merge-queue.js";
+import { MergeCandidateSubmitParams, MergeQueueDecideParams, MergeQueueListParams } from "../schemas.js";
+import { loadTeamDefinition, validateTeamDefinition } from "../topology/teams.js";
+
+export function registerMergeQueueTools(pi: ExtensionAPI): void {
+  pi.registerTool({
+    name: "zob_merge_candidate_submit",
+    label: "ZOB Merge Candidate Submit",
+    description: "Submit a sandbox diff as a parent-owned merge-queue candidate. Metadata-only; never applies changes or writes source files.",
+    promptSnippet: "Queue a sandboxed merge candidate for parent review.",
+    parameters: MergeCandidateSubmitParams,
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const team = loadTeamDefinition(ctx.cwd, params.team ?? "zob-core");
+      const errors = [...team.errors, ...validateTeamDefinition(ctx.cwd, team.definition)];
+      if (!team.definition || errors.length > 0) return { content: [{ type: "text", text: `zob_merge_candidate_submit failed_preflight:\n- ${errors.join("\n- ")}` }], details: { status: "failed_preflight", errors } };
+      try {
+        const candidate = submitMergeCandidate(ctx.cwd, team.definition, params);
+        pi.appendEntry("zob-merge-queue", { event: "candidate_queued", candidateId: candidate.candidateId, runId: candidate.runId, applyPerformed: false, productionWritesPerformed: false, autoApply: false, bodyStored: false, promptBodiesStored: false, outputBodiesStored: false });
+        return { content: [{ type: "text", text: `zob_merge_candidate_submit: queued ${candidate.candidateId}` }], details: { schema: "zob.merge-candidate-submit-result.v1", candidate, bodyFreeViolations: mergeQueueBodyFreeViolations(candidate) } };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { content: [{ type: "text", text: `zob_merge_candidate_submit blocked: ${message}` }], details: { status: "blocked", errors: [message] } };
+      }
+    },
+  });
+
+  pi.registerTool({
+    name: "zob_merge_queue_decide",
+    label: "ZOB Merge Queue Decide",
+    description: "Record a parent-owned merge queue decision. Approval means manual-apply eligible only; this tool never applies changes.",
+    promptSnippet: "Record a parent-owned merge queue decision.",
+    parameters: MergeQueueDecideParams,
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const team = loadTeamDefinition(ctx.cwd, params.team ?? "zob-core");
+      const errors = [...team.errors, ...validateTeamDefinition(ctx.cwd, team.definition)];
+      if (!team.definition || errors.length > 0) return { content: [{ type: "text", text: `zob_merge_queue_decide failed_preflight:\n- ${errors.join("\n- ")}` }], details: { status: "failed_preflight", errors } };
+      try {
+        const decision = decideMergeCandidate(ctx.cwd, team.definition, params);
+        pi.appendEntry("zob-merge-queue", { event: "decision_recorded", candidateId: decision.candidateId, decision: decision.decision, applyPerformed: false, productionWritesPerformed: false, autoApply: false, bodyStored: false, promptBodiesStored: false, outputBodiesStored: false });
+        return { content: [{ type: "text", text: `zob_merge_queue_decide: ${decision.decision} ${decision.candidateId}` }], details: { schema: "zob.merge-decision-result.v1", decision, bodyFreeViolations: mergeQueueBodyFreeViolations(decision) } };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { content: [{ type: "text", text: `zob_merge_queue_decide blocked: ${message}` }], details: { status: "blocked", errors: [message] } };
+      }
+    },
+  });
+
+  pi.registerTool({
+    name: "zob_merge_queue_list",
+    label: "ZOB Merge Queue List",
+    description: "List metadata-only parent merge-queue candidates and latest decisions. Bodies/diffs are never returned.",
+    promptSnippet: "List parent-owned merge queue metadata.",
+    parameters: MergeQueueListParams,
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const candidates = listMergeQueue(ctx.cwd, params);
+      return { content: [{ type: "text", text: `zob_merge_queue_list: ${candidates.length} candidate(s)` }], details: { schema: "zob.merge-queue-list.v1", candidates, bodyFreeViolations: mergeQueueBodyFreeViolations(candidates) } };
+    },
+  });
+}

package/.pi/extensions/zob-harness/src/runtime/tools-mission-control.ts

@@ -0,0 +1,77 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+import {
+  MissionControlProposeCommandParams,
+  MissionControlSnapshotParams,
+  ZobComsReadinessParams,
+} from "../schemas.js";
+import type { TeamDefinition } from "../types.js";
+import {
+  buildMissionControlSnapshot,
+  buildZobCommunicationReadinessAudit,
+  writeMissionControlCommandProposal,
+} from "../mission-control.js";
+import { loadTeamDefinition, validateTeamDefinition } from "../topology/teams.js";
+
+function loadValidTeam(repoRoot: string, teamName: string | undefined): { definition?: TeamDefinition; errors: string[] } {
+  const team = loadTeamDefinition(repoRoot, teamName ?? "zob-core");
+  const errors = [...team.errors, ...validateTeamDefinition(repoRoot, team.definition)];
+  return { definition: team.definition, errors };
+}
+
+export function registerMissionControlTools(pi: ExtensionAPI): void {
+  pi.registerTool({
+    name: "zob_coms_readiness",
+    label: "ZOB Coms Readiness",
+    description: "Audit local ZOB communication readiness: topology guard, hash-only ledgers, bounded awaits, disabled transport, proposal-only commands. No network coms.",
+    parameters: ZobComsReadinessParams,
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const team = loadValidTeam(ctx.cwd, params.team);
+      if (team.errors.length > 0 || !team.definition) return { content: [{ type: "text", text: `zob_coms_readiness failed_preflight:\n- ${team.errors.join("\n- ")}` }], details: { status: "failed_preflight", errors: team.errors } };
+      const audit = buildZobCommunicationReadinessAudit(ctx.cwd, team.definition);
+      return { content: [{ type: "text", text: `zob_coms_readiness: ${audit.verdict}` }], details: audit };
+    },
+  });
+
+  pi.registerTool({
+    name: "zob_mission_control_snapshot",
+    label: "ZOB Mission Control Snapshot",
+    description: "Read a metadata-only Mission Control dashboard snapshot over queue, runs, factories, telemetry, coms, autonomy audit, and disabled transport status.",
+    parameters: MissionControlSnapshotParams,
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const team = loadValidTeam(ctx.cwd, params.team);
+      if (team.errors.length > 0 || !team.definition) return { content: [{ type: "text", text: `zob_mission_control_snapshot failed_preflight:\n- ${team.errors.join("\n- ")}` }], details: { status: "failed_preflight", errors: team.errors } };
+      const snapshot = buildMissionControlSnapshot(ctx.cwd, team.definition, { runId: params.runId, limit: params.limit });
+      return { content: [{ type: "text", text: "zob_mission_control_snapshot: metadata-only" }], details: snapshot };
+    },
+  });
+
+  pi.registerTool({
+    name: "zob_mission_control_propose_command",
+    label: "ZOB Mission Control Propose Command",
+    description: "Create a typed parent-owned Mission Control command proposal. Proposal-only; no direct worker writes, no transport dispatch, no raw rationale/body storage.",
+    parameters: MissionControlProposeCommandParams,
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const team = loadValidTeam(ctx.cwd, params.team);
+      if (team.errors.length > 0 || !team.definition) return { content: [{ type: "text", text: `zob_mission_control_propose_command failed_preflight:\n- ${team.errors.join("\n- ")}` }], details: { status: "failed_preflight", errors: team.errors } };
+      try {
+        const proposal = writeMissionControlCommandProposal(ctx.cwd, team.definition, {
+          proposalId: params.proposalId,
+          runId: params.runId,
+          command: params.command,
+          requestedBy: params.requestedBy,
+          targetRole: params.targetRole,
+          priority: params.priority,
+          rationaleHash: params.rationaleHash,
+          artifactRefs: params.artifactRefs,
+          todoId: params.todoId,
+          subtreeRootTodoId: params.subtreeRootTodoId,
+        });
+        return { content: [{ type: "text", text: `zob_mission_control_propose_command proposed: ${proposal.proposalId}` }], details: proposal };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { content: [{ type: "text", text: `zob_mission_control_propose_command blocked: ${message}` }], details: { status: "blocked", errors: [message] } };
+      }
+    },
+  });
+}

package/.pi/extensions/zob-harness/src/runtime/tools-orchestration.ts

@@ -0,0 +1,106 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+import { buildZobLivePresenceSummary } from "../coms-v2/presence.js";
+import { readZobComsV2Policy } from "../coms-v2/policy.js";
+import { OrchestrateRunParams, ChainRunParams } from "../schemas.js";
+import { createSupervisedReadonlyDispatcher } from "../child-runner.js";
+import { runOrchestrateRun } from "../orchestration/run.js";
+import { runSupervisedReadonlyOrchestration } from "../orchestration/supervised-readonly.js";
+import { runChainPlanOnly } from "../topology/chains.js";
+import { sha256 } from "../utils/hashing.js";
+import { isRecord } from "../utils/records.js";
+import type { HarnessRuntimeState } from "./state.js";
+import { strictGoalSpecErrors } from "./state.js";
+
+function agenticComsLivePreflightErrors(repoRoot: string, execution: string | undefined): string[] {
+  if (execution !== "supervised_readonly") return [];
+  const policy = readZobComsV2Policy(repoRoot);
+  if (!policy.agenticWorkflowsRequireLive) return [];
+  if (policy.legacy.appendOnlySendEnabled !== false) return ["ZOB coms v2 blocks supervised_readonly: legacy append-only send must be disabled for agentic workflows"];
+  if (policy.mode !== "required_local" && policy.mode !== "required_network") return [`ZOB coms v2 blocks supervised_readonly: agentic workflows require required_local live transport, current mode=${policy.mode}`];
+  if (policy.mode === "required_network") return ["ZOB coms v2 blocks supervised_readonly: required_network remains gated; use required_local live transport"];
+  const presence = buildZobLivePresenceSummary(repoRoot);
+  if (presence.dispatchEnabled !== true || presence.online <= 0 || presence.networkEnabled !== false) return [`ZOB coms v2 blocks supervised_readonly: live local registry is not ready (${JSON.stringify({ online: presence.online, stale: presence.stale, offline: presence.offline, dispatchEnabled: presence.dispatchEnabled, networkEnabled: presence.networkEnabled })})`];
+  return [];
+}
+
+export function registerOrchestrationTools(pi: ExtensionAPI, state: HarnessRuntimeState): void {
+  pi.registerTool({
+    name: "orchestrate_run",
+    label: "Orchestrate Run",
+    description: [
+      "Plan a ZOB Orchestrator -> Lead -> Worker run from a team topology manifest.",
+      "v1.4 supports plan_only, model-free supervised_smoke metadata, and explicit supervised_readonly parent-owned read-only child dispatch.",
+    ].join(" "),
+    promptSnippet: "Plan an Orchestrator/Lead/Worker run; only execution=supervised_readonly dispatches read-only child agents",
+    promptGuidelines: [
+      "Use orchestrate_run when a task needs multiple leads/workers but should remain parent-preflighted.",
+      "Use execution=plan_only for contracts only, execution=supervised_smoke for model-free read-only planning metadata, or execution=supervised_readonly only when live parent-owned read-only child dispatch is explicitly intended.",
+      "Do not treat a planned orchestration as completed implementation work.",
+    ],
+    parameters: OrchestrateRunParams,
+    async execute(_toolCallId, params, signal, onUpdate, ctx) {
+      const goalErrors = strictGoalSpecErrors(state, { kind: "orchestrate_run", goal: params.goal, originalUserAsk: params.original_user_ask });
+      if (goalErrors.length > 0) {
+        const result = { status: "failed_preflight", runId: params.run_id ?? "not-started", runDir: "", tasks: 0, artifacts: [], errors: goalErrors };
+        return { content: [{ type: "text", text: `orchestrate_run failed_preflight:\n- ${goalErrors.join("\n- ")}\nSet /goal_gate or /job_intake before dispatch.` }], details: result };
+      }
+      const liveComsErrors = agenticComsLivePreflightErrors(ctx.cwd, params.execution);
+      if (liveComsErrors.length > 0) {
+        const result = { status: "failed_preflight", runId: params.run_id ?? "not-started", runDir: "", tasks: 0, artifacts: [], errors: liveComsErrors, comsLiveRequired: true };
+        return { content: [{ type: "text", text: `orchestrate_run failed_preflight:\n- ${liveComsErrors.join("\n- ")}` }], details: result };
+      }
+      const result = params.execution === "supervised_readonly"
+        ? await runSupervisedReadonlyOrchestration(ctx.cwd, params, createSupervisedReadonlyDispatcher(ctx, signal, undefined, (partial) => {
+          onUpdate?.({ content: [{ type: "text", text: partial.output || partial.stderr || "supervised_readonly child running..." }], details: { status: "running", agent: partial.agent, outputHash: partial.output ? sha256(partial.output) : undefined } });
+        }))
+        : runOrchestrateRun(ctx.cwd, params);
+      const resultRecord = isRecord(result) ? result : {};
+      pi.appendEntry("zob-orchestrate-run", {
+        runId: typeof resultRecord.runId === "string" ? resultRecord.runId : params.run_id ?? "unknown-run",
+        team: params.team ?? "zob-core",
+        execution: params.execution ?? "plan_only",
+        status: typeof resultRecord.status === "string" ? resultRecord.status : "unknown",
+        tasks: typeof resultRecord.tasks === "number" ? resultRecord.tasks : 0,
+        artifacts: Array.isArray(resultRecord.artifacts) ? resultRecord.artifacts : [],
+        errors: Array.isArray(resultRecord.errors) ? resultRecord.errors : [],
+      });
+      const artifacts = Array.isArray(resultRecord.artifacts) ? resultRecord.artifacts.filter((artifact): artifact is string => typeof artifact === "string") : [];
+      const errors = Array.isArray(resultRecord.errors) ? resultRecord.errors.filter((error): error is string => typeof error === "string") : [];
+      const text = [
+        `orchestrate_run ${String(resultRecord.status ?? "unknown")}: ${String(resultRecord.runId ?? "unknown-run")}`,
+        `runDir: ${String(resultRecord.runDir ?? "")}`,
+        `execution: ${params.execution ?? "plan_only"}`,
+        `tasks: ${String(resultRecord.tasks ?? 0)}`,
+        typeof resultRecord.dispatched === "number" ? `dispatched: ${resultRecord.dispatched}` : undefined,
+        typeof resultRecord.completed === "number" ? `completed: ${resultRecord.completed}` : undefined,
+        typeof resultRecord.failed === "number" ? `failed: ${resultRecord.failed}` : undefined,
+        artifacts.length > 0 ? `artifacts:\n- ${artifacts.join("\n- ")}` : "artifacts: none",
+        errors.length > 0 ? `errors:\n- ${errors.join("\n- ")}` : "errors: none",
+      ].filter((line): line is string => typeof line === "string").join("\n");
+      return { content: [{ type: "text", text }], details: result };
+    },
+  });
+
+  pi.registerTool({
+    name: "chain_run",
+    label: "Chain Run",
+    description: [
+      "Plan a typed contract-first chain from .pi/chains without live child execution.",
+      "Only plan_only read-only chains are supported; unsafe tools, unknown agents, and unknown output contracts fail preflight.",
+    ].join(" "),
+    promptSnippet: "Plan a typed read-only chain run without executing child agents",
+    promptGuidelines: [
+      "Use chain_run for reusable explore/plan/oracle flows where delegate_task-shaped contracts should be planned first.",
+      "Do not use chain_run for write-enabled execution; sandboxed execution is not implemented.",
+    ],
+    parameters: ChainRunParams,
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const result = runChainPlanOnly(ctx.cwd, params);
+      const text = result.status === "planned"
+        ? `chain_run planned ${result.steps} step(s) for ${result.chain} at ${result.runDir}`
+        : `chain_run preflight failed:\n- ${result.errors.join("\n- ")}`;
+      return { content: [{ type: "text", text }], details: result };
+    },
+  });
+}

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

@@ -0,0 +1,123 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+import { buildProjectDnaAgenticPlan, buildProjectDnaFederatedQueryResult, buildProjectDnaQueryResult, buildProjectDnaReadinessAudit, writeProjectDnaWritebackProposal } from "../project-dna.js";
+import { ProjectDnaFederatedQueryParams, ProjectDnaPlanWorkflowParams, ProjectDnaQueryParams, ProjectDnaReadinessParams, ProjectDnaWritebackProposalParams } from "../schemas.js";
+
+export function registerProjectDnaTools(pi: ExtensionAPI): void {
+  pi.registerTool({
+    name: "zob_project_dna_readiness",
+    label: "ZOB ProjectDNA Readiness",
+    description: "Audit ProjectDNA plan/runtime readiness from repo-local artifacts. Read-only, metadata-only, no source scan or backend write.",
+    parameters: ProjectDnaReadinessParams,
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      try {
+        const audit = buildProjectDnaReadinessAudit(ctx.cwd, { scanDir: params.scan_dir });
+        const verdict = typeof audit.verdict === "string" ? audit.verdict : "unknown";
+        const noShip = audit.no_ship === true ? " no_ship=true" : "";
+        return { content: [{ type: "text", text: `zob_project_dna_readiness: ${verdict}${noShip}` }], details: audit };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { content: [{ type: "text", text: `zob_project_dna_readiness blocked: ${message}` }], details: { schema: "zob.project-dna-readiness.v1", verdict: "blocked", errors: [message], no_ship: true, source_project_modified: false, knowledge_backend_write_enabled: false } };
+      }
+    },
+  });
+
+  pi.registerTool({
+    name: "zob_project_dna_plan_workflow",
+    label: "ZOB ProjectDNA Plan Workflow",
+    description: "Build a metadata-only agentic ProjectDNA workflow plan from a repo-local manifest v2. No source scan, child dispatch, network, source write, or backend write.",
+    parameters: ProjectDnaPlanWorkflowParams,
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      try {
+        const plan = buildProjectDnaAgenticPlan(ctx.cwd, {
+          manifestPath: params.manifest_path,
+          scanDir: params.scan_dir,
+        });
+        const profile = typeof plan.effective_compute_profile === "string" ? plan.effective_compute_profile : "unknown";
+        const capture = typeof plan.effective_capture_mode === "string" ? plan.effective_capture_mode : "unknown";
+        const lanes = Array.isArray(plan.lanes) ? plan.lanes.length : 0;
+        return { content: [{ type: "text", text: `zob_project_dna_plan_workflow: profile=${profile} capture=${capture} lanes=${lanes}` }], details: plan };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { content: [{ type: "text", text: `zob_project_dna_plan_workflow blocked: ${message}` }], details: { schema: "zob.project-dna-agentic-plan.v1", status: "blocked", errors: [message], metadata_only: true, no_execution: true, source_project_modified: false, knowledge_backend_write_enabled: false, child_direct_dispatch: false } };
+      }
+    },
+  });
+
+  pi.registerTool({
+    name: "zob_project_dna_query",
+    label: "ZOB ProjectDNA Query",
+    description: "Return a bounded cited ProjectDNA context pack from repo-local scan artifacts. Read-only; no source scan, no backend write, no child dispatch.",
+    parameters: ProjectDnaQueryParams,
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      try {
+        const result = buildProjectDnaQueryResult(ctx.cwd, {
+          scanDir: params.scan_dir,
+          query: params.query,
+          maxFiles: params.max_files,
+          maxContextTokens: params.max_context_tokens,
+          allowedSources: params.allowed_sources,
+          contextScopeId: params.context_scope_id,
+        });
+        const sourceId = typeof result.source_id === "string" ? result.source_id : "unknown-source";
+        const files = Array.isArray(result.files_to_read_first) ? result.files_to_read_first.length : 0;
+        const citations = Array.isArray(result.citations) ? result.citations.length : 0;
+        return { content: [{ type: "text", text: `zob_project_dna_query: source=${sourceId} files=${files} citations=${citations}` }], details: result };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { content: [{ type: "text", text: `zob_project_dna_query blocked: ${message}` }], details: { schema: "zob.project-dna-query-result.v1", status: "blocked", errors: [message], raw_query_persisted: false, source_project_modified: false, knowledge_backend_write_enabled: false, child_dispatch_allowed: false } };
+      }
+    },
+  });
+
+  pi.registerTool({
+    name: "zob_project_dna_federated_query",
+    label: "ZOB ProjectDNA Federated Query",
+    description: "Merge bounded cited ProjectDNA context from multiple repo-local scan artifact directories. Metadata-only and proposal-only.",
+    parameters: ProjectDnaFederatedQueryParams,
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      try {
+        const result = buildProjectDnaFederatedQueryResult(ctx.cwd, {
+          scanDirs: params.scan_dirs,
+          query: params.query,
+          maxFilesPerSource: params.max_files_per_source,
+          maxTotalFiles: params.max_total_files,
+          maxContextTokens: params.max_context_tokens,
+          allowedSources: params.allowed_sources,
+          contextScopeId: params.context_scope_id,
+        });
+        const sourceCount = typeof result.source_count === "number" ? result.source_count : 0;
+        const files = Array.isArray(result.files_to_read_first) ? result.files_to_read_first.length : 0;
+        return { content: [{ type: "text", text: `zob_project_dna_federated_query: sources=${sourceCount} files=${files}` }], details: result };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { content: [{ type: "text", text: `zob_project_dna_federated_query blocked: ${message}` }], details: { schema: "zob.project-dna-federated-query-result.v1", status: "blocked", errors: [message], raw_query_persisted: false, source_project_modified: false, knowledge_backend_write_enabled: false, child_dispatch_allowed: false } };
+      }
+    },
+  });
+
+  pi.registerTool({
+    name: "zob_project_dna_writeback_proposal",
+    label: "ZOB ProjectDNA Writeback Proposal",
+    description: "Append a hash-only ProjectDNA learning/writeback proposal. No durable promotion and no external knowledge-backend write.",
+    parameters: ProjectDnaWritebackProposalParams,
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      try {
+        const proposal = writeProjectDnaWritebackProposal(ctx.cwd, {
+          runId: params.run_id,
+          proposalId: params.proposal_id,
+          sourceIds: params.source_ids,
+          observedPatternHash: params.observed_pattern_hash,
+          proposedCapsuleHash: params.proposed_capsule_hash,
+          evidenceRefs: params.evidence_refs,
+          recommendedArtifact: params.recommended_artifact,
+        });
+        const proposalId = typeof proposal.proposal_id === "string" ? proposal.proposal_id : "unknown";
+        return { content: [{ type: "text", text: `zob_project_dna_writeback_proposal proposed: ${proposalId}` }], details: proposal };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { content: [{ type: "text", text: `zob_project_dna_writeback_proposal blocked: ${message}` }], details: { schema: "zob.project-dna-writeback-proposal.v1", status: "blocked", errors: [message], raw_problem_stored: false, raw_pattern_stored: false, external_knowledge_backend_write_enabled: false } };
+      }
+    },
+  });
+}

package/.pi/extensions/zob-harness/src/runtime/tools-worker-pool.ts

@@ -0,0 +1,93 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+import { createWorkerPoolOwnerDecision, createWorkerPoolOwnerRequest, createWorkerPoolPlan, listWorkerPoolPlans, workerPoolBodyFreeViolations } from "../worker-pool.js";
+import { WorkerPoolOwnerDecisionParams, WorkerPoolOwnerRequestParams, WorkerPoolPlanParams, WorkerPoolStatusParams } from "../schemas.js";
+import { loadTeamDefinition, validateTeamDefinition } from "../topology/teams.js";
+
+export function registerWorkerPoolTools(pi: ExtensionAPI): void {
+  pi.registerTool({
+    name: "zob_worker_pool_plan",
+    label: "ZOB Worker Pool Plan",
+    description: "Create a parent-owned metadata-only worker pool plan for read-across/write-by-owner coordination. Enforces write paths within owned paths, integrates active workspace claims, records sandbox/merge/rollback/oracle gates, and never applies changes.",
+    promptSnippet: "Plan parent-owned worker pool assignments with owned/write/read-across paths, workspace claims, and no-apply safety gates.",
+    parameters: WorkerPoolPlanParams,
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const team = loadTeamDefinition(ctx.cwd, params.team ?? "zob-core");
+      const errors = [...team.errors, ...validateTeamDefinition(ctx.cwd, team.definition)];
+      if (!team.definition || errors.length > 0) return { content: [{ type: "text", text: `zob_worker_pool_plan failed_preflight:\n- ${errors.join("\n- ")}` }], details: { status: "failed_preflight", errors } };
+      try {
+        const { team: _team, ...input } = params;
+        const plan = createWorkerPoolPlan(ctx.cwd, team.definition, input);
+        const bodyFreeViolations = workerPoolBodyFreeViolations(plan);
+        pi.appendEntry("zob-worker-pool", { event: "plan_recorded", poolId: plan.poolId, goalId: plan.goalId, status: plan.status, conflicts: plan.conflicts.length, productionWritesPerformed: false, autoApply: false, bodyStored: false, promptBodiesStored: false, outputBodiesStored: false });
+        return { content: [{ type: "text", text: `zob_worker_pool_plan: ${plan.status} ${plan.poolId}` }], details: { schema: "zob.worker-pool-plan-result.v1", plan, bodyFreeViolations } };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { content: [{ type: "text", text: `zob_worker_pool_plan blocked: ${message}` }], details: { status: "blocked", errors: [message] } };
+      }
+    },
+  });
+
+  pi.registerTool({
+    name: "zob_worker_pool_status",
+    label: "ZOB Worker Pool Status",
+    description: "List parent-owned metadata-only worker pool plans, ownership coverage, workspace-claim posture, and sandbox/merge gate blockers. Bodies are never persisted or returned.",
+    promptSnippet: "List worker pool metadata, ownership coverage, claim coverage, and conflict posture.",
+    parameters: WorkerPoolStatusParams,
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      try {
+        const plans = listWorkerPoolPlans(ctx.cwd, params);
+        return { content: [{ type: "text", text: `zob_worker_pool_status: ${plans.length} plan(s)` }], details: { schema: "zob.worker-pool-status.v1", plans, bodyFreeViolations: workerPoolBodyFreeViolations(plans) } };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { content: [{ type: "text", text: `zob_worker_pool_status blocked: ${message}` }], details: { status: "blocked", errors: [message] } };
+      }
+    },
+  });
+
+  pi.registerTool({
+    name: "zob_worker_pool_owner_request",
+    label: "ZOB Worker Pool Owner Request",
+    description: "Validate an owner request against the existing pool plan, then append a body-free OWNER_CHANGE_REQUEST to parent-visible Goal Room. No direct worker-to-worker free chat or apply.",
+    promptSnippet: "Request an owner-handled change through canonical Goal Room metadata after owner path coverage validation.",
+    parameters: WorkerPoolOwnerRequestParams,
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const team = loadTeamDefinition(ctx.cwd, params.team ?? "zob-core");
+      const errors = [...team.errors, ...validateTeamDefinition(ctx.cwd, team.definition)];
+      if (!team.definition || errors.length > 0) return { content: [{ type: "text", text: `zob_worker_pool_owner_request failed_preflight:\n- ${errors.join("\n- ")}` }], details: { status: "failed_preflight", errors } };
+      try {
+        const { team: _team, ...input } = params;
+        const request = createWorkerPoolOwnerRequest(ctx.cwd, team.definition, input);
+        const bodyFreeViolations = workerPoolBodyFreeViolations(request);
+        pi.appendEntry("zob-worker-pool", { event: "owner_request_recorded", requestId: request.requestId, poolId: request.poolId, goalRoomMsgId: request.goalRoomMsgId, parentVisible: true, hiddenPeerChat: false, workerToWorkerDirect: false, bodyStored: false, promptBodiesStored: false, outputBodiesStored: false });
+        return { content: [{ type: "text", text: `zob_worker_pool_owner_request: ${request.requestId}` }], details: { schema: "zob.worker-pool-owner-request-result.v1", request, bodyFreeViolations } };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { content: [{ type: "text", text: `zob_worker_pool_owner_request blocked: ${message}` }], details: { status: "blocked", errors: [message] } };
+      }
+    },
+  });
+
+  pi.registerTool({
+    name: "zob_worker_pool_owner_decision",
+    label: "ZOB Worker Pool Owner Decision",
+    description: "Append a body-free OWNER_CHANGE_DECISION to the parent-visible Goal Room and record parent-owned owner decision metadata. Does not apply diffs.",
+    promptSnippet: "Record an owner decision for a worker pool change request.",
+    parameters: WorkerPoolOwnerDecisionParams,
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const team = loadTeamDefinition(ctx.cwd, params.team ?? "zob-core");
+      const errors = [...team.errors, ...validateTeamDefinition(ctx.cwd, team.definition)];
+      if (!team.definition || errors.length > 0) return { content: [{ type: "text", text: `zob_worker_pool_owner_decision failed_preflight:\n- ${errors.join("\n- ")}` }], details: { status: "failed_preflight", errors } };
+      try {
+        const { team: _team, ...input } = params;
+        const decision = createWorkerPoolOwnerDecision(ctx.cwd, team.definition, input);
+        const bodyFreeViolations = workerPoolBodyFreeViolations(decision);
+        pi.appendEntry("zob-worker-pool", { event: "owner_decision_recorded", decisionId: decision.decisionId, requestId: decision.requestId, poolId: decision.poolId, goalRoomMsgId: decision.goalRoomMsgId, parentVisible: true, hiddenPeerChat: false, workerToWorkerDirect: false, productionWritesPerformed: false, autoApply: false, bodyStored: false, promptBodiesStored: false, outputBodiesStored: false });
+        return { content: [{ type: "text", text: `zob_worker_pool_owner_decision: ${decision.decisionId}` }], details: { schema: "zob.worker-pool-owner-decision-result.v1", decision, bodyFreeViolations } };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { content: [{ type: "text", text: `zob_worker_pool_owner_decision blocked: ${message}` }], details: { status: "blocked", errors: [message] } };
+      }
+    },
+  });
+}

package/.pi/extensions/zob-harness/src/runtime/tools-workspace-claims.ts

@@ -0,0 +1,62 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+import { createWorkspaceClaim, listWorkspaceClaims, releaseWorkspaceClaim, workspaceClaimBodyFreeViolations } from "../workspace-claims.js";
+import { WorkspaceClaimParams, WorkspaceClaimsListParams, WorkspaceReleaseParams } from "../schemas.js";
+import { loadTeamDefinition, validateTeamDefinition } from "../topology/teams.js";
+
+export function registerWorkspaceClaimTools(pi: ExtensionAPI): void {
+  pi.registerTool({
+    name: "zob_workspace_claim",
+    label: "ZOB Workspace Claim",
+    description: "Create a metadata-only workspace path lease for parallel write intent. Detects conflicts and never writes source files or applies changes.",
+    promptSnippet: "Claim workspace paths for governed parallel write intent.",
+    parameters: WorkspaceClaimParams,
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const team = loadTeamDefinition(ctx.cwd, params.team ?? "zob-core");
+      const errors = [...team.errors, ...validateTeamDefinition(ctx.cwd, team.definition)];
+      if (!team.definition || errors.length > 0) return { content: [{ type: "text", text: `zob_workspace_claim failed_preflight:\n- ${errors.join("\n- ")}` }], details: { status: "failed_preflight", errors } };
+      try {
+        const claim = createWorkspaceClaim(ctx.cwd, team.definition, params);
+        const bodyFreeViolations = workspaceClaimBodyFreeViolations(claim);
+        pi.appendEntry("zob-workspace-claim", { event: claim.status, claimId: claim.claimId, conflicts: claim.conflicts.length, productionWritesPerformed: false, autoApply: false, bodyStored: false, promptBodiesStored: false, outputBodiesStored: false });
+        return { content: [{ type: "text", text: `zob_workspace_claim: ${claim.status} ${claim.claimId}` }], details: { schema: "zob.workspace-claim-result.v1", claim, bodyFreeViolations } };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { content: [{ type: "text", text: `zob_workspace_claim blocked: ${message}` }], details: { status: "blocked", errors: [message] } };
+      }
+    },
+  });
+
+  pi.registerTool({
+    name: "zob_workspace_release",
+    label: "ZOB Workspace Release",
+    description: "Release a metadata-only workspace path lease. Does not apply changes or mutate source files.",
+    promptSnippet: "Release a governed workspace claim.",
+    parameters: WorkspaceReleaseParams,
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const team = loadTeamDefinition(ctx.cwd, params.team ?? "zob-core");
+      const errors = [...team.errors, ...validateTeamDefinition(ctx.cwd, team.definition)];
+      if (!team.definition || errors.length > 0) return { content: [{ type: "text", text: `zob_workspace_release failed_preflight:\n- ${errors.join("\n- ")}` }], details: { status: "failed_preflight", errors } };
+      try {
+        const release = releaseWorkspaceClaim(ctx.cwd, team.definition, params);
+        pi.appendEntry("zob-workspace-claim", { event: "released", claimId: release.claimId, releaseId: release.releaseId, bodyStored: false, promptBodiesStored: false, outputBodiesStored: false });
+        return { content: [{ type: "text", text: `zob_workspace_release: ${release.claimId}` }], details: { schema: "zob.workspace-release-result.v1", release } };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { content: [{ type: "text", text: `zob_workspace_release blocked: ${message}` }], details: { status: "blocked", errors: [message] } };
+      }
+    },
+  });
+
+  pi.registerTool({
+    name: "zob_workspace_claims_list",
+    label: "ZOB Workspace Claims List",
+    description: "List active metadata-only workspace claims/leases. Bodies are never stored or returned.",
+    promptSnippet: "List governed workspace claims.",
+    parameters: WorkspaceClaimsListParams,
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const claims = listWorkspaceClaims(ctx.cwd, params);
+      return { content: [{ type: "text", text: `zob_workspace_claims_list: ${claims.length} claim(s)` }], details: { schema: "zob.workspace-claims-list.v1", claims, bodyFreeViolations: workspaceClaimBodyFreeViolations(claims) } };
+    },
+  });
+}