zob-harness 0.1.0

package/.pi/extensions/zob-harness/src/orchestration/room.ts

@@ -0,0 +1,346 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { SUPERVISED_READONLY_CHILD_TOOLS, SUPERVISED_SMOKE_CHILD_TOOLS } from "../constants.js";
+import type { OrchestrateExecutionMode, TeamDefinition } from "../types.js";
+import { sha256 } from "../utils/hashing.js";
+import { isRecord } from "../utils/records.js";
+
+function orchestrationLedger(runDir: string, entry: Record<string, unknown>): void {
+  appendFileSync(join(runDir, "ledger.jsonl"), `${JSON.stringify({ ...entry, timestamp: new Date().toISOString() })}\n`, "utf8");
+}
+
+function buildOrchestrationMessages(definition: TeamDefinition, plan: Record<string, unknown>, runId: string, execution: OrchestrateExecutionMode): Array<Record<string, unknown>> {
+  const tasks = Array.isArray(plan.tasks) ? plan.tasks.filter(isRecord) : [];
+  return tasks.map((task, index) => {
+    const taskId = typeof task.id === "string" ? task.id : `task-${index + 1}`;
+    const taskType = typeof task.type === "string" ? task.type : "unknown";
+    const leadId = typeof task.leadId === "string" ? task.leadId : undefined;
+    const workerId = typeof task.workerId === "string" ? task.workerId : undefined;
+    const sender = taskType === "lead_plan" ? definition.orchestrator.id : (typeof task.proposedBy === "string" ? task.proposedBy : definition.orchestrator.id);
+    const receiver = taskType === "lead_plan" ? (leadId ?? "unknown-lead") : (workerId ?? leadId ?? "unknown-worker");
+    const contractFingerprint = JSON.stringify({
+      task: typeof task.task === "string" ? task.task : "",
+      expected_outcome: typeof task.expected_outcome === "string" ? task.expected_outcome : "",
+      required_tools: Array.isArray(task.required_tools) ? task.required_tools : [],
+      output_contract: typeof task.output_contract === "string" ? task.output_contract : "",
+      must_do: Array.isArray(task.must_do) ? task.must_do : [],
+      must_not_do: Array.isArray(task.must_not_do) ? task.must_not_do : [],
+      context: typeof task.context === "string" ? task.context : "",
+    });
+    return {
+      schema: "zob.orchestration-message.v1",
+      msgId: `${runId}:${taskId}`,
+      runId,
+      parentId: typeof task.parent === "string" ? task.parent : definition.orchestrator.id,
+      sender,
+      receiver,
+      receiverAgent: typeof task.agent === "string" ? task.agent : "unknown-agent",
+      role: typeof task.role === "string" ? task.role : "unknown-role",
+      taskId,
+      taskType,
+      goalId: typeof task.goalId === "string" ? task.goalId : undefined,
+      todoId: typeof task.todoId === "string" ? task.todoId : undefined,
+      todoRef: isRecord(task.todoRef) ? task.todoRef : undefined,
+      taskHash: sha256(contractFingerprint),
+      outputHash: null,
+      status: "planned",
+      ack: "not_sent",
+      execution,
+      noExecution: true,
+      timestamp: new Date().toISOString(),
+    };
+  });
+}
+
+function writeOrchestrationMessages(runDir: string, messages: Array<Record<string, unknown>>): void {
+  writeFileSync(join(runDir, "messages.jsonl"), messages.map((message) => JSON.stringify(message)).join("\n") + (messages.length > 0 ? "\n" : ""), "utf8");
+}
+
+function buildOrchestrationStatuses(messages: Array<Record<string, unknown>>, runId: string, execution: OrchestrateExecutionMode): Array<Record<string, unknown>> {
+  return messages.map((message) => ({
+    schema: "zob.orchestration-status.v1",
+    event: "status_planned",
+    runId,
+    msgId: typeof message.msgId === "string" ? message.msgId : "unknown-message",
+    parentId: typeof message.parentId === "string" ? message.parentId : "unknown-parent",
+    sender: typeof message.sender === "string" ? message.sender : "unknown-sender",
+    receiver: typeof message.receiver === "string" ? message.receiver : "unknown-receiver",
+    receiverAgent: typeof message.receiverAgent === "string" ? message.receiverAgent : "unknown-agent",
+    role: typeof message.role === "string" ? message.role : "unknown-role",
+    taskId: typeof message.taskId === "string" ? message.taskId : "unknown-task",
+    taskHash: typeof message.taskHash === "string" ? message.taskHash : "",
+    outputHash: null,
+    status: "planned",
+    ack: "not_sent",
+    ping: "not_started",
+    running: false,
+    startedAt: null,
+    lastPingAt: null,
+    lastAckAt: null,
+    completedAt: null,
+    execution,
+    noExecution: true,
+    supervisedSmoke: execution === "supervised_smoke" ? { planned: true, liveChildExecution: false, allowedTools: [...SUPERVISED_SMOKE_CHILD_TOOLS] } : undefined,
+    supervisedReadonly: execution === "supervised_readonly" ? { planned: true, parentOwnedDispatch: true, allowedTools: [...SUPERVISED_READONLY_CHILD_TOOLS] } : undefined,
+    timestamp: new Date().toISOString(),
+  }));
+}
+
+function writeOrchestrationStatuses(runDir: string, statuses: Array<Record<string, unknown>>, runId: string, execution: OrchestrateExecutionMode): void {
+  writeFileSync(join(runDir, "status.jsonl"), statuses.map((status) => JSON.stringify(status)).join("\n") + (statuses.length > 0 ? "\n" : ""), "utf8");
+  const latestByMsgId = new Map<string, Record<string, unknown>>();
+  statuses.forEach((status, index) => latestByMsgId.set(typeof status.msgId === "string" ? status.msgId : `unknown-${index}`, status));
+  const snapshotStatuses = [...latestByMsgId.values()];
+  const byStatus = snapshotStatuses.reduce<Record<string, number>>((counts, status) => {
+    const key = typeof status.status === "string" ? status.status : "unknown";
+    counts[key] = (counts[key] ?? 0) + 1;
+    return counts;
+  }, {});
+  const byAck = snapshotStatuses.reduce<Record<string, number>>((counts, status) => {
+    const key = typeof status.ack === "string" ? status.ack : "unknown";
+    counts[key] = (counts[key] ?? 0) + 1;
+    return counts;
+  }, {});
+  const byPing = snapshotStatuses.reduce<Record<string, number>>((counts, status) => {
+    const key = typeof status.ping === "string" ? status.ping : "unknown";
+    counts[key] = (counts[key] ?? 0) + 1;
+    return counts;
+  }, {});
+  const snapshot = {
+    schema: "zob.orchestration-status-snapshot.v1",
+    runId,
+    execution,
+    total: snapshotStatuses.length,
+    events: statuses.length,
+    byStatus,
+    byAck,
+    byPing,
+    running: snapshotStatuses.filter((status) => status.running === true).length,
+    noExecution: snapshotStatuses.every((status) => status.noExecution !== false),
+    supervisedSmoke: execution === "supervised_smoke" ? { planned: true, liveChildExecution: false, allowedTools: [...SUPERVISED_SMOKE_CHILD_TOOLS] } : undefined,
+    supervisedReadonly: execution === "supervised_readonly" ? { parentOwnedDispatch: true, allowedTools: [...SUPERVISED_READONLY_CHILD_TOOLS] } : undefined,
+    timestamp: new Date().toISOString(),
+  };
+  writeFileSync(join(runDir, "status-snapshot.json"), JSON.stringify(snapshot, null, 2), "utf8");
+}
+
+export function writeOrchestrationRoomArtifacts(input: {
+  runDir: string;
+  runId: string;
+  definition: TeamDefinition;
+  plan: Record<string, unknown>;
+  messages: Array<Record<string, unknown>>;
+  statuses: Array<Record<string, unknown>>;
+  execution: OrchestrateExecutionMode;
+  goal: string;
+  originalUserAsk: string;
+  goalId?: string;
+  rootTodoId?: string;
+  comsMirrored?: number;
+  adaptiveWorkflow?: Record<string, unknown>;
+}): { roomDir: string; artifacts: string[] } {
+  const roomDir = join(input.runDir, "room");
+  mkdirSync(roomDir, { recursive: true });
+  const participants = [input.definition.orchestrator.id, ...input.definition.leads.map((lead) => lead.id), ...input.definition.workers.map((worker) => worker.id)];
+  const roleById = new Map<string, { agent: string; roleType: string; leadId?: string }>();
+  roleById.set(input.definition.orchestrator.id, { agent: input.definition.orchestrator.agent, roleType: "orchestrator" });
+  for (const lead of input.definition.leads) roleById.set(lead.id, { agent: lead.agent, roleType: "lead" });
+  for (const worker of input.definition.workers) roleById.set(worker.id, { agent: worker.agent, roleType: "worker", leadId: worker.leadId });
+
+  const room = {
+    schema: "zob.room.v1",
+    runId: input.runId,
+    goalHash: sha256(input.goal),
+    originalUserAskHash: sha256(input.originalUserAsk),
+    profile: input.definition.name,
+    participants,
+    policy: {
+      bodyPolicy: "hash_only_by_default",
+      allowedEdges: "from team topology",
+      networked: false,
+      promptBodiesStored: false,
+      outputBodiesStored: false,
+      parentOwnedPreflight: true,
+      parentDispatchOnly: true,
+      workerSpawnsWorker: false,
+    },
+    createdAt: new Date().toISOString(),
+  };
+
+  const roomMessages = input.messages.map((message) => {
+    const receiver = typeof message.receiver === "string" ? message.receiver : "unknown";
+    const sender = typeof message.sender === "string" ? message.sender : "unknown";
+    const taskType = typeof message.taskType === "string" ? message.taskType : "task";
+    return {
+      schema: "zob.room-message.v1",
+      msgId: typeof message.msgId === "string" ? message.msgId : `${input.runId}:${sender}:${receiver}`,
+      runId: input.runId,
+      threadId: taskType,
+      goalId: typeof message.goalId === "string" ? message.goalId : input.goalId,
+      todoId: typeof message.todoId === "string" ? message.todoId : input.rootTodoId,
+      sender,
+      receiver,
+      type: taskType === "lead_plan" || taskType === "worker_contract" ? "task" : "status",
+      status: typeof message.status === "string" ? message.status : "planned",
+      summary: `${sender} -> ${receiver}: ${taskType} handoff (${input.execution})`,
+      taskHash: typeof message.taskHash === "string" ? message.taskHash : null,
+      outputHash: typeof message.outputHash === "string" ? message.outputHash : null,
+      artifactRefs: ["orchestration-plan.json", "messages.jsonl", "status.jsonl"],
+      bodyStored: false,
+      promptBodiesStored: false,
+      outputBodiesStored: false,
+      timestamp: typeof message.timestamp === "string" ? message.timestamp : new Date().toISOString(),
+    };
+  });
+
+  const roomStatuses = input.statuses.map((status) => ({
+    schema: "zob.room-status.v1",
+    runId: input.runId,
+    msgId: typeof status.msgId === "string" ? status.msgId : "unknown-message",
+    actor: typeof status.receiver === "string" ? status.receiver : "unknown-actor",
+    status: typeof status.status === "string" ? status.status : "unknown",
+    ack: typeof status.ack === "string" ? status.ack : "unknown",
+    ping: typeof status.ping === "string" ? status.ping : "unknown",
+    running: status.running === true,
+    outputHash: typeof status.outputHash === "string" ? status.outputHash : null,
+    bodyStored: false,
+    timestamp: typeof status.timestamp === "string" ? status.timestamp : new Date().toISOString(),
+  }));
+
+  const decisions = [
+    {
+      schema: "zob.room-decision.v1",
+      runId: input.runId,
+      decisionId: `${input.runId}:parent-owned-preflight`,
+      summary: "Parent-owned preflight and dispatch boundary preserved; worker-to-worker communication remains blocked by default.",
+      evidenceRefs: ["orchestration-plan.json", "validation.json"],
+      bodyStored: false,
+      timestamp: new Date().toISOString(),
+    },
+  ];
+
+  const blockers = input.statuses
+    .filter((status) => status.status === "failed" || status.ping === "blocked")
+    .map((status, index) => ({
+      schema: "zob.room-blocker.v1",
+      runId: input.runId,
+      blockerId: `${input.runId}:blocker-${index + 1}`,
+      actor: typeof status.receiver === "string" ? status.receiver : "unknown-actor",
+      summary: `Blocked or failed status for ${typeof status.taskId === "string" ? status.taskId : "unknown-task"}`,
+      status: typeof status.status === "string" ? status.status : "unknown",
+      evidenceRefs: ["status.jsonl", "validation.json"],
+      bodyStored: false,
+      timestamp: typeof status.timestamp === "string" ? status.timestamp : new Date().toISOString(),
+    }));
+
+  const latestByRole: Record<string, string> = {};
+  for (const participant of participants) {
+    const role = roleById.get(participant);
+    latestByRole[participant] = `${role?.roleType ?? "role"} ${role?.agent ?? "unknown-agent"}: ${input.execution} planned metadata`;
+  }
+  const tasks = Array.isArray(input.plan.tasks) ? input.plan.tasks.filter(isRecord) : [];
+  const latestStatusByMsgId = new Map<string, Record<string, unknown>>();
+  input.statuses.forEach((status, index) => latestStatusByMsgId.set(typeof status.msgId === "string" ? status.msgId : `unknown-${index}`, status));
+  const latestStatuses = [...latestStatusByMsgId.values()];
+  const contextScope = {
+    schema: "zob.context-scope.v1",
+    scopeId: `${input.runId}-orchestration-context-scope`,
+    runId: input.runId,
+    allowedBrains: ["harness-system"],
+    allowedSources: ["orchestration-run-artifacts", "zob-harness-orchestration-room"],
+    forbiddenSources: [".env", ".env.*", "secrets", "raw-conversation-history", "node_modules", "dist", "build"],
+    agentProfile: "orchestration-room",
+    maxContextTokens: 4000,
+    freshnessPolicy: "current_run_artifacts",
+    readPolicy: "bounded_metadata_only",
+    writePolicy: "proposal_only",
+    citationRequired: true,
+    contextPackRequired: true,
+    sourceScopeRequired: true,
+    bodyStored: false,
+    promptBodiesStored: false,
+    outputBodiesStored: false,
+  };
+  const contextCitations = [
+    `harness-system:orchestration-run-artifacts:${input.runId}/manifest.json`,
+    `harness-system:orchestration-run-artifacts:${input.runId}/validation.json`,
+  ];
+  const adaptiveWorkflow = isRecord(input.adaptiveWorkflow) ? input.adaptiveWorkflow : undefined;
+  const adaptiveWorkflowRefs = Array.isArray(adaptiveWorkflow?.adaptiveWorkflowRefs) ? adaptiveWorkflow.adaptiveWorkflowRefs.filter((ref): ref is string => typeof ref === "string") : [];
+  const documentationRefs = ["documentation-policy.json", "guidance-index.json", "docs/layer-doc-pack.json", "docs/role-doc-packs.json", "docs/writeback-proposals.json"].filter((ref) => adaptiveWorkflowRefs.includes(ref));
+  const contextPack = {
+    schema: "zob.context-pack.v2",
+    runId: input.runId,
+    profile: input.definition.name,
+    goal: "redacted; see goalHash in room.json",
+    goalHash: sha256(input.goal),
+    currentPhase: input.execution === "plan_only" ? "planning" : input.execution,
+    currentState: latestStatuses.some((status) => status.running === true) ? "running" : latestStatuses.some((status) => status.status === "failed") ? "failed" : latestStatuses.some((status) => status.status === "completed") ? "completed" : "planned",
+    decisions: decisions.map((decision) => decision.summary),
+    openQuestions: tasks.length === 0 ? ["No tasks planned"] : [],
+    blockers: blockers.map((blocker) => blocker.summary),
+    evidenceRefs: ["manifest.json", "orchestration-plan.json", "messages.jsonl", "status.jsonl", "validation.json", "room/blockers.jsonl", ...adaptiveWorkflowRefs],
+    todoGraphBinding: input.rootTodoId ? { goalId: input.goalId, rootTodoId: input.rootTodoId, attachmentPolicy: "messages_delegations_blockers_claims_evidence_attach_to_todo", bodyStored: false } : undefined,
+    contextScope,
+    contextLoading: { contextScopeRequired: true, boundedContextPack: true, agentLoadsEntireCorpus: false, citationRequired: true, writePolicy: "proposal_only" },
+    sourceLocks: [
+      { sourceId: "orchestration-run-artifacts", brainId: "harness-system", sourceRoot: `reports/orchestrations/${input.runId}`, sourceRootHash: sha256(`reports/orchestrations/${input.runId}`) },
+      { sourceId: "zob-harness-orchestration-room", brainId: "harness-system", sourceRoot: ".pi/extensions/zob-harness/src/orchestration", sourceRootHash: sha256(".pi/extensions/zob-harness/src/orchestration") },
+    ],
+    citations: contextCitations,
+    latestByRole,
+    ruleProfile: {
+      profile: "orchestration-engineer",
+      rulePacks: ["always", "project", "orchestration", "oracle"],
+      oracleRequired: true,
+      noShipConditions: ["worker-to-worker edge accepted without policy", "networked coms enabled", "DONE.sentinel written without evidence and oracle gate", "plaintext body persisted in coms or room", "documentation policy missing for multi-layer workflow", "model/security downgrade without explicit policy", "large scale without budget/approval/oracle"],
+    },
+    modelRoutingSummary: adaptiveWorkflow ? { modelPolicyRef: adaptiveWorkflow.modelPolicyRef, scalePolicyRef: adaptiveWorkflow.scalePolicyRef } : {},
+    adaptiveWorkflow: adaptiveWorkflow ? {
+      refs: adaptiveWorkflowRefs,
+      promptPolicyRef: adaptiveWorkflow.promptPolicyRef,
+      documentationPolicyRef: adaptiveWorkflow.documentationPolicyRef,
+      guidanceIndexRef: adaptiveWorkflow.guidanceIndexRef,
+      tempAgentRosterRef: adaptiveWorkflow.tempAgentRosterRef,
+      rootNonCoding: adaptiveWorkflow.rootNonCoding,
+      parentOwnedDispatch: adaptiveWorkflow.parentOwnedDispatch,
+      childDirectDispatch: adaptiveWorkflow.childDirectDispatch,
+      bodyStored: false,
+    } : undefined,
+    documentationRefs,
+    roomPolicy: room.policy,
+    promptBodiesStored: false,
+    outputBodiesStored: false,
+    bodyStored: false,
+    generatedAt: new Date().toISOString(),
+  };
+
+  const evidenceIndex = {
+    schema: "zob.evidence-index.v1",
+    runId: input.runId,
+    artifacts: [
+      { artifact: "manifest.json", kind: "manifest", hash: existsSync(join(input.runDir, "manifest.json")) ? sha256(readFileSync(join(input.runDir, "manifest.json"), "utf8")) : null },
+      { artifact: "orchestration-plan.json", kind: "plan", hash: existsSync(join(input.runDir, "orchestration-plan.json")) ? sha256(readFileSync(join(input.runDir, "orchestration-plan.json"), "utf8")) : null },
+      { artifact: "messages.jsonl", kind: "messages", hash: existsSync(join(input.runDir, "messages.jsonl")) ? sha256(readFileSync(join(input.runDir, "messages.jsonl"), "utf8")) : null },
+      { artifact: "status.jsonl", kind: "status", hash: existsSync(join(input.runDir, "status.jsonl")) ? sha256(readFileSync(join(input.runDir, "status.jsonl"), "utf8")) : null },
+      { artifact: "validation.json", kind: "validation", hash: existsSync(join(input.runDir, "validation.json")) ? sha256(readFileSync(join(input.runDir, "validation.json"), "utf8")) : null },
+      ...adaptiveWorkflowRefs.map((artifact) => ({ artifact, kind: "adaptive_workflow", hash: existsSync(join(input.runDir, artifact)) ? sha256(readFileSync(join(input.runDir, artifact), "utf8")) : null })),
+    ],
+    comsMirrored: input.comsMirrored ?? 0,
+    promptBodiesStored: false,
+    outputBodiesStored: false,
+    generatedAt: new Date().toISOString(),
+  };
+
+  writeFileSync(join(roomDir, "room.json"), JSON.stringify(room, null, 2), "utf8");
+  writeFileSync(join(roomDir, "messages.jsonl"), roomMessages.map((message) => JSON.stringify(message)).join("\n") + (roomMessages.length > 0 ? "\n" : ""), "utf8");
+  writeFileSync(join(roomDir, "status.jsonl"), roomStatuses.map((status) => JSON.stringify(status)).join("\n") + (roomStatuses.length > 0 ? "\n" : ""), "utf8");
+  writeFileSync(join(roomDir, "decisions.jsonl"), decisions.map((decision) => JSON.stringify(decision)).join("\n") + "\n", "utf8");
+  writeFileSync(join(roomDir, "blockers.jsonl"), blockers.map((blocker) => JSON.stringify(blocker)).join("\n") + (blockers.length > 0 ? "\n" : ""), "utf8");
+  writeFileSync(join(roomDir, "context-pack.json"), JSON.stringify(contextPack, null, 2), "utf8");
+  writeFileSync(join(roomDir, "evidence-index.json"), JSON.stringify(evidenceIndex, null, 2), "utf8");
+  return { roomDir, artifacts: ["room/room.json", "room/messages.jsonl", "room/status.jsonl", "room/decisions.jsonl", "room/blockers.jsonl", "room/context-pack.json", "room/evidence-index.json"] };
+}
+
+export { buildOrchestrationMessages, buildOrchestrationStatuses, orchestrationLedger, writeOrchestrationMessages, writeOrchestrationStatuses };

package/.pi/extensions/zob-harness/src/orchestration/run.ts

@@ -0,0 +1,134 @@
+import { existsSync, mkdirSync, unlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { resolveComputeProfile } from "../compute-profile.js";
+import { SUPERVISED_SMOKE_CHILD_TOOLS } from "../constants.js";
+import type { OrchestrateExecutionMode, OrchestrateRunInput, OrchestrateRunResult, TeamDefinition } from "../types.js";
+import { mirrorOrchestrationToComs } from "../topology/coms.js";
+import { loadOrchestrationProfile, teamDefinitionFromOrchestrationProfile, validateOrchestrateRunInputs } from "../topology/orchestration-profiles.js";
+import { loadTeamDefinition } from "../topology/teams.js";
+import { sha256 } from "../utils/hashing.js";
+import { safeRunId } from "../utils/paths.js";
+import { isRecord } from "../utils/records.js";
+import { buildInitialAdaptiveDelegationGovernorState, normalizeAdaptiveDelegationPolicy } from "./adaptive-delegation.js";
+import { writeAdaptiveWorkflowArtifacts } from "./adaptive-workflow.js";
+import { buildOrchestrationPlan, redactBodyLikeFieldsForPersistence, redactOrchestrationPlanForPersistence } from "./plan.js";
+import { buildOrchestrationMessages, buildOrchestrationStatuses, orchestrationLedger, writeOrchestrationMessages, writeOrchestrationRoomArtifacts, writeOrchestrationStatuses } from "./room.js";
+
+export function runOrchestrateRun(repoRoot: string, input: OrchestrateRunInput): OrchestrateRunResult {
+  const errors = validateOrchestrateRunInputs(repoRoot, input);
+  const runId = safeRunId(input.run_id, "orchestrate");
+  const runDir = join(repoRoot, "reports", "orchestrations", runId);
+  if (existsSync(runDir) && !input.resume) errors.push(`Orchestration run directory already exists. Use resume=true or choose another run_id: ${runDir}`);
+  if (errors.length > 0) return { runId, runDir, status: "failed_preflight", tasks: 0, artifacts: [], errors };
+
+  mkdirSync(runDir, { recursive: true });
+  const sentinelPath = join(runDir, "DONE.sentinel");
+  if (existsSync(sentinelPath)) unlinkSync(sentinelPath);
+  const profile = input.profile ? loadOrchestrationProfile(repoRoot, input.profile) : undefined;
+  const team = input.profile ? undefined : loadTeamDefinition(repoRoot, input.team ?? "zob-core");
+  const definition = profile?.definition ? teamDefinitionFromOrchestrationProfile(profile.definition) : team?.definition as TeamDefinition;
+  const execution: OrchestrateExecutionMode = input.execution ?? "plan_only";
+  const adaptiveDelegation = normalizeAdaptiveDelegationPolicy(input.adaptive_delegation);
+  const computeProfile = resolveComputeProfile(repoRoot, {
+    runId,
+    domain: "orchestration",
+    requestedProfile: input.compute_profile ?? "auto",
+    targetPath: ".pi/teams",
+    taskHash: sha256(input.original_user_ask ?? input.goal),
+    computeCaps: input.compute_caps,
+    riskHints: execution === "supervised_readonly" ? ["durable"] : [],
+  });
+  const originalUserAsk = input.original_user_ask ?? input.goal;
+  const persistedInput = adaptiveDelegation.enabled || input.compute_profile || input.compute_caps ? { ...input, adaptive_delegation: adaptiveDelegation, compute_profile_resolution: computeProfile } : input;
+  const plan = buildOrchestrationPlan(definition, input, { runId, runDir, execution });
+  const tasks = Array.isArray(plan.tasks) ? plan.tasks.length : 0;
+  const adaptiveArtifacts = adaptiveDelegation.enabled ? ["adaptive-delegation-policy.json", "delegation-governor-state.json", "delegation-requests.json", "delegation-decisions.json", "delegation-oracle-decisions.json", "delegation-dispatches.json", "adaptive-delegation-summary.md"] : [];
+  const adaptiveWorkflow = writeAdaptiveWorkflowArtifacts({ repoRoot, runDir, runId, definition, profileDefinition: profile?.definition, input, computeProfile, adaptiveDelegation, execution, goal: input.goal, originalUserAsk });
+  const adaptiveWorkflowArtifacts = adaptiveWorkflow.artifacts;
+
+  const redactPersistentBodies = execution === "supervised_readonly" || input.profile === "adaptive-chief-vision";
+  const manifest = { team: definition, input: persistedInput, sourceTeamPath: team?.teamPath, sourceProfilePath: profile?.profilePath, execution, computeProfile, adaptiveWorkflow: adaptiveWorkflow.context };
+  writeFileSync(join(runDir, "manifest.json"), JSON.stringify(redactPersistentBodies ? redactBodyLikeFieldsForPersistence(manifest) : manifest, null, 2), "utf8");
+  writeFileSync(join(runDir, "compute-profile-resolution.json"), JSON.stringify(computeProfile, null, 2), "utf8");
+  const persistedPlan = redactPersistentBodies ? redactOrchestrationPlanForPersistence(plan) : plan;
+  writeFileSync(join(runDir, "orchestration-plan.json"), JSON.stringify(persistedPlan, null, 2), "utf8");
+  const messages = buildOrchestrationMessages(definition, plan, runId, execution);
+  const statuses = buildOrchestrationStatuses(messages, runId, execution);
+  writeOrchestrationMessages(runDir, messages);
+  writeOrchestrationStatuses(runDir, statuses, runId, execution);
+  const comsMirrored = mirrorOrchestrationToComs(repoRoot, definition, messages);
+  if (adaptiveDelegation.enabled) {
+    const rootGoalHash = sha256(originalUserAsk);
+    const governorState = buildInitialAdaptiveDelegationGovernorState({ runId, rootGoalHash, policy: adaptiveDelegation });
+    writeFileSync(join(runDir, "adaptive-delegation-policy.json"), JSON.stringify(adaptiveDelegation, null, 2), "utf8");
+    writeFileSync(join(runDir, "delegation-governor-state.json"), JSON.stringify(governorState, null, 2), "utf8");
+    writeFileSync(join(runDir, "delegation-requests.json"), JSON.stringify({ schema: "zob.delegation-request-set.v1", runId, requests: [], bodyStored: false, promptBodiesStored: false, outputBodiesStored: false }, null, 2), "utf8");
+    writeFileSync(join(runDir, "delegation-decisions.json"), JSON.stringify({ schema: "zob.governor-decision-set.v1", runId, decisions: [], bodyStored: false, promptBodiesStored: false, outputBodiesStored: false }, null, 2), "utf8");
+    writeFileSync(join(runDir, "delegation-oracle-decisions.json"), JSON.stringify({ schema: "zob.delegation-oracle-decision-set.v1", runId, oracleRequired: 0, decisions: [], liveOracleDispatched: false, bodyStored: false, promptBodiesStored: false, outputBodiesStored: false }, null, 2), "utf8");
+    writeFileSync(join(runDir, "delegation-dispatches.json"), JSON.stringify({ schema: "zob.parent-dispatch-contract-set.v1", runId, dispatches: [], dispatchContractsQueued: 0, liveDispatches: 0, adaptiveLiveDispatchEnabled: false, bodyStored: false, promptBodiesStored: false, outputBodiesStored: false }, null, 2), "utf8");
+    writeFileSync(join(runDir, "adaptive-delegation-summary.md"), [`# Adaptive Delegation Summary`, ``, `- runId: ${runId}`, `- enabled: ${adaptiveDelegation.enabled}`, `- mode: ${adaptiveDelegation.mode}`, `- dispatch: ${adaptiveDelegation.dispatch}`, `- configuredMaxDepth: ${adaptiveDelegation.configuredMaxDepth}`, `- runtimeMaxDepth: ${adaptiveDelegation.runtimeMaxDepth}`, `- parent_owned_dispatch: ${adaptiveDelegation.parentOwnedDispatch}`, `- child_direct_dispatch: ${adaptiveDelegation.childDirectDispatch}`, `- live_dispatches: 0`, `- sentinel: not written`, ``].join("\n"), "utf8");
+  }
+  const roomArtifacts = writeOrchestrationRoomArtifacts({ runDir, runId, definition, plan: persistedPlan, messages, statuses, execution, goal: input.goal, originalUserAsk, goalId: input.goal_id, rootTodoId: input.todo_id, comsMirrored, adaptiveWorkflow: adaptiveWorkflow.context });
+  orchestrationLedger(runDir, { event: "initialized", runId, team: definition.name, execution });
+  orchestrationLedger(runDir, { event: "team_loaded", leads: definition.leads.length, workers: definition.workers.length });
+  orchestrationLedger(runDir, { event: "plan_written", tasks, execution, noExecution: true });
+  orchestrationLedger(runDir, { event: "messages_written", messages: messages.length, execution, noExecution: true });
+  orchestrationLedger(runDir, { event: "status_written", statuses: statuses.length, running: 0, execution, noExecution: true });
+  orchestrationLedger(runDir, { event: "coms_mirrored", messages: comsMirrored, path: ".pi/coms/messages.jsonl", execution, noExecution: true });
+  orchestrationLedger(runDir, { event: "room_written", artifacts: roomArtifacts.artifacts, path: "room/", execution, noExecution: true });
+  if (adaptiveDelegation.enabled) orchestrationLedger(runDir, { event: "adaptive_delegation_policy_written", artifacts: adaptiveArtifacts, execution, noExecution: true, dispatch: adaptiveDelegation.dispatch });
+
+  const supervisedSmoke = execution === "supervised_smoke" ? {
+    schema: "zob.orchestration-supervised-smoke.v1",
+    mode: "read_only",
+    parentOwnedPreflight: true,
+    parentOwnedDispatch: true,
+    workerSpawnsWorker: false,
+    allowedTools: [...SUPERVISED_SMOKE_CHILD_TOOLS],
+    blockedTools: ["bash", "edit", "write", "delegate_agent", "delegate_task", "orchestrate_run", "factory_run", "factory_quarantine_review", "factory_quarantine_activate", "factory_quarantine_verify_activation"],
+    liveChildExecution: false,
+    modelRouterUsed: false,
+    budgetEnforced: false,
+    finalGate: {
+      status: "planned_not_executed",
+      passed: false,
+      reason: "supervised_smoke records parent-owned read-only execution metadata without live child/model execution in smoke validation",
+      requiresLiveChildEvidence: true,
+    },
+  } : undefined;
+
+  const validation = {
+    runId,
+    team: definition.name,
+    execution,
+    status: "planned",
+    noExecution: true,
+    tasks,
+    messages: messages.length,
+    statuses: statuses.length,
+    comsMirrored,
+    artifactsPresent: ["manifest.json", "ledger.jsonl", "compute-profile-resolution.json", "orchestration-plan.json", "messages.jsonl", "status.jsonl", "status-snapshot.json", ...adaptiveWorkflowArtifacts, "room/room.json", "room/context-pack.json", "room/evidence-index.json", "final-report.md"].map((artifact) => ({ artifact, exists: artifact === "final-report.md" ? false : existsSync(join(runDir, artifact)) })),
+    roomArtifactsPresent: roomArtifacts.artifacts.map((artifact) => ({ artifact, exists: existsSync(join(runDir, artifact)) })),
+    room: { schema: "zob.room.v1", path: "room/", contextPack: "room/context-pack.json", evidenceIndex: "room/evidence-index.json", promptBodiesStored: false, outputBodiesStored: false },
+    invariants: isRecord(plan.invariants) ? plan.invariants : {},
+    todoGraphBinding: input.todo_id ? { goalId: input.goal_id, rootTodoId: input.todo_id, parentOwned: true, bodyStored: false } : undefined,
+    supervisedSmoke,
+    computeProfile,
+    adaptiveDelegation: adaptiveDelegation.enabled ? { schema: "zob.adaptive-delegation-validation.v1", enabled: true, mode: adaptiveDelegation.mode, dispatch: adaptiveDelegation.dispatch, recordDecisionsOnly: adaptiveDelegation.recordDecisionsOnly, configuredMaxDepth: adaptiveDelegation.configuredMaxDepth, runtimeMaxDepth: adaptiveDelegation.runtimeMaxDepth, parentOwnedDispatch: true, childDirectDispatch: false, liveDispatches: 0, advisoryOnly: adaptiveDelegation.dispatch === false, artifacts: adaptiveArtifacts, noExecution: true, bodyStored: false, promptBodiesStored: false, outputBodiesStored: false } : { enabled: false },
+    adaptiveWorkflow: adaptiveWorkflow.validationSummary,
+    budgetEnforced: false,
+    modelRouterUsed: false,
+    sentinelWritten: existsSync(join(runDir, "DONE.sentinel")),
+    bodyStored: false,
+    promptBodiesStored: false,
+    outputBodiesStored: false,
+  };
+  writeFileSync(join(runDir, "validation.json"), JSON.stringify(validation, null, 2), "utf8");
+  writeFileSync(join(runDir, "final-report.md"), [`# Orchestration Run Report`, ``, `- runId: ${runId}`, `- team: ${definition.name}`, `- status: planned`, `- execution: ${execution}`, `- tasks: ${tasks}`, `- messages: ${messages.length}`, `- statuses: ${statuses.length}`, `- coms_mirrored: ${comsMirrored}`, `- room: room/context-pack.json`, `- running: 0`, `- child_agents_executed: no`, `- supervised_smoke_read_only: ${execution === "supervised_smoke" ? "yes" : "n/a"}`, `- supervised_readonly: ${execution === "supervised_readonly" ? "yes" : "n/a"}`, `- sentinel: not written`, ``].join("\n"), "utf8");
+  const finalValidation = { ...validation, artifactsPresent: ["manifest.json", "ledger.jsonl", "compute-profile-resolution.json", "orchestration-plan.json", "messages.jsonl", "status.jsonl", "status-snapshot.json", ...adaptiveWorkflowArtifacts, "room/room.json", "room/messages.jsonl", "room/status.jsonl", "room/decisions.jsonl", "room/blockers.jsonl", "room/context-pack.json", "room/evidence-index.json", ...adaptiveArtifacts, "validation.json", "final-report.md"].map((artifact) => ({ artifact, exists: existsSync(join(runDir, artifact)) })) };
+  writeFileSync(join(runDir, "validation.json"), JSON.stringify(finalValidation, null, 2), "utf8");
+  orchestrationLedger(runDir, { event: "planned", tasks, sentinel: "not written" });
+
+  return { runId, runDir, status: "planned", tasks, artifacts: ["manifest.json", "ledger.jsonl", "compute-profile-resolution.json", "orchestration-plan.json", "messages.jsonl", "status.jsonl", "status-snapshot.json", ...adaptiveWorkflowArtifacts, ...roomArtifacts.artifacts, ...adaptiveArtifacts, "validation.json", "final-report.md"], errors: [] };
+}