zob-harness 0.9.0 → 0.9.2

package/.pi/extensions/zob-harness/src/domains/compute/compute-profile.ts

@@ -1,3 +1,4 @@
+import type { Dirent } from "node:fs";
 import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { basename, extname, join, relative, resolve } from "node:path";
 
@@ -261,7 +262,7 @@ function collectTargetStats(repoRoot: string, targetPath: string | undefined): T
       stats.maxFilesReached = true;
       return;
     }
-    let entries;
+    let entries: Dirent[];
     try {
       entries = readdirSync(absolutePath, { withFileTypes: true });
     } catch (error) {

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

@@ -97,6 +97,21 @@ function readLeasesFromDir(dir: string, nowMs: number, teamName?: string): ZobLi
     .map((lease) => leaseToPeerCard(lease, nowMs));
 }
 
+function peerRegistryKey(peer: Pick<ZobLivePeerCard, "projectId" | "roleId" | "sessionHash">): string {
+  return `${peer.projectId}:${peer.roleId}:${peer.sessionHash}`;
+}
+
+function mergeLeaseBackedAndAdhocPeers(leasePeers: ZobLivePeerCard[], agentPeers: ZobLivePeerCard[]): ZobLivePeerCard[] {
+  const byKey = new Map<string, ZobLivePeerCard>();
+  for (const peer of leasePeers) byKey.set(peerRegistryKey(peer), peer);
+  for (const peer of agentPeers) {
+    if (peer.zpeerAdhoc !== true) continue;
+    const key = peerRegistryKey(peer);
+    if (!byKey.has(key)) byKey.set(key, peer);
+  }
+  return [...byKey.values()];
+}
+
 function boundedOfflinePeerRetentionMs(value: number | undefined): number {
   const env = Number.parseInt(process.env.ZOB_COMS_OFFLINE_PEER_RETENTION_MS ?? "", 10);
   const raw = typeof value === "number" && Number.isFinite(value) ? value : Number.isFinite(env) ? env : DEFAULT_OFFLINE_PEER_RETENTION_MS;
@@ -514,8 +529,13 @@ export function unregisterCurrentZobLivePeer(repoRoot: string, teamName = "zob-c
 export function readZobLiveRegistrySnapshot(repoRoot: string, teamName?: string): ZobLiveRegistrySnapshot {
   const { dir, projectId, kind } = projectLeasesDir(repoRoot);
   const nowMs = Date.now();
-  if (existsSync(dir)) return buildSnapshot(projectId, kind, readLeasesFromDir(dir, nowMs, teamName), teamName);
   const agents = projectAgentsDir(repoRoot);
+  if (existsSync(dir)) {
+    return buildSnapshot(projectId, kind, mergeLeaseBackedAndAdhocPeers(
+      readLeasesFromDir(dir, nowMs, teamName),
+      readPeerCardsFromAgentsDir(agents.dir, nowMs, teamName),
+    ), teamName);
+  }
   return buildSnapshot(agents.projectId, agents.kind, readPeerCardsFromAgentsDir(agents.dir, nowMs, teamName), teamName);
 }
 
@@ -523,9 +543,10 @@ export function readZobLiveRegistryAllProjectsSnapshot(repoRoot: string, teamNam
   const { projectId, kind } = projectAgentsDir(repoRoot);
   const nowMs = Date.now();
   const leaseDirs = allProjectLeasesDirs();
+  const agentPeers = allProjectAgentsDirs().flatMap((dir) => readPeerCardsFromAgentsDir(dir, nowMs, teamName));
   const hasLeaseDomain = leaseDirs.some((dir) => existsSync(dir));
   const peers = hasLeaseDomain
-    ? leaseDirs.flatMap((dir) => readLeasesFromDir(dir, nowMs, teamName))
-    : allProjectAgentsDirs().flatMap((dir) => readPeerCardsFromAgentsDir(dir, nowMs, teamName));
+    ? mergeLeaseBackedAndAdhocPeers(leaseDirs.flatMap((dir) => readLeasesFromDir(dir, nowMs, teamName)), agentPeers)
+    : agentPeers;
   return buildSnapshot(projectId, kind, peers, teamName);
 }

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

@@ -109,6 +109,7 @@ export interface ZobLivePeerCard {
   zpeerActiveRoomId?: string;
   zpeerMemberships?: ZpeerRoomMembership[];
   zpeerLocalOnly?: true;
+  zpeerAdhoc?: true;
   staleAfterMs: number;
   offlineAfterMs: number;
   bodyStored: false;

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

@@ -234,7 +234,7 @@ export function refreshZpeerSelf(repoRoot: string, peer: ZobLivePeerCard, roomId
   const ensured = ensureZpeerFields(repoRoot, peer, roomId, alias, restoredMemberships);
   if (!hasLocalSocketEndpointEvidence(ensured)) return ensured;
   const refreshed = writeZobLivePeerCard(repoRoot, { ...ensured, heartbeatAt: new Date().toISOString(), status: "online" });
-  writeZobLiveTeamAgentLease(repoRoot, refreshed, { reason: "zpeer_refresh" });
+  if (refreshed.zpeerAdhoc !== true) writeZobLiveTeamAgentLease(repoRoot, refreshed, { reason: "zpeer_refresh" });
   return refreshed;
 }
 
@@ -479,8 +479,10 @@ export async function sendZpeerPrompt(repoRoot: string, self: ZobLivePeerCard, t
   };
 
   if (!selfMembership) return finish("attempt", { status: "blocked", reason: `current peer is not a member of room '${roomId}'`, targetAlias: targetAlias ?? undefined, taskHash, bodyStored: false });
-  const leaseOwnership = ownsZobLiveTeamAgentLease(repoRoot, self);
-  if (!leaseOwnership.owned) return finish("attempt", { status: "blocked", reason: `current peer does not own stable team-agent lease (${leaseOwnership.reason})`, targetAlias: targetAlias ?? undefined, taskHash, bodyStored: false });
+  if (self.zpeerAdhoc !== true) {
+    const leaseOwnership = ownsZobLiveTeamAgentLease(repoRoot, self);
+    if (!leaseOwnership.owned) return finish("attempt", { status: "blocked", reason: `current peer does not own stable team-agent lease (${leaseOwnership.reason})`, targetAlias: targetAlias ?? undefined, taskHash, bodyStored: false });
+  }
   if (selfMembership.role === "observer") return finish("attempt", { status: "blocked", reason: `current peer is observer-only in room '${roomId}'`, targetAlias: targetAlias ?? undefined, taskHash, bodyStored: false });
   if (!targetAlias) return finish("attempt", { status: "blocked", reason: "invalid target alias", bodyStored: false });
   if (!transientPrompt.trim()) return finish("attempt", { status: "blocked", reason: "empty peer prompt", targetAlias, bodyStored: false });

package/.pi/extensions/zob-harness/src/domains/delegation/child-runner.ts

@@ -3,7 +3,7 @@ import { existsSync, mkdirSync } from "node:fs";
 import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { getAgentDir, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 
 import { discoverAgents } from "./agents.js";
 import { SUPERVISED_READONLY_CHILD_TOOLS } from "../../core/constants.js";
@@ -24,6 +24,28 @@ function getPiInvocation(args: string[]): { command: string; args: string[] } {
   return { command: "pi", args };
 }
 
+function childModelPattern(ctx: ExtensionContext, agent: HarnessAgent, modelOverride: string | undefined): string | undefined {
+  if (modelOverride?.trim()) return modelOverride.trim();
+  if (agent.model?.trim()) return agent.model.trim();
+  const model = ctx.model;
+  if (!model?.provider || !model.id) return undefined;
+  return `${model.provider}/${model.id}`;
+}
+
+function providerFromModelPattern(model: string | undefined): string | undefined {
+  if (!model) return undefined;
+  const [provider] = model.split("/");
+  return provider && provider !== model ? provider : undefined;
+}
+
+function resolveCodexFastModeExtension(ctx: ExtensionContext, model: string | undefined): string | undefined {
+  const provider = ctx.model?.provider ?? providerFromModelPattern(model);
+  const usesCodexProvider = provider === "openai-codex" || provider === "codex-auto" || provider?.startsWith("codex-") === true;
+  if (!usesCodexProvider) return undefined;
+  const extensionPath = join(getAgentDir(), "extensions", "codex-fast-mode.ts");
+  return existsSync(extensionPath) ? extensionPath : undefined;
+}
+
 const CHILD_THINKING_LEVELS = new Set<string>(["low", "medium", "high", "xhigh"]);
 
 function validateChildThinkingOverride(thinking: string | undefined, fieldName = "thinking"): string[] {
@@ -90,13 +112,14 @@ async function runChildAgent(
   pathPolicy?: { allowedPaths?: string[]; forbiddenPaths?: string[]; sandboxRoot?: string },
   thinkingOverride?: ChildThinkingLevel,
 ): Promise<ChildResult> {
+  const resolvedModel = childModelPattern(ctx, agent, modelOverride);
   const result: ChildResult = {
     agent: agent.name,
     task,
     exitCode: 0,
     output: "",
     stderr: "",
-    model: modelOverride ?? agent.model,
+    model: resolvedModel,
     usage: usageEmpty(),
   };
 
@@ -123,10 +146,12 @@ async function runChildAgent(
 
   try {
     const childSafetyExtension = join(ctx.cwd, ".pi", "extensions", "zob-child-safety", "index.ts");
+    const childCodexFastModeExtension = resolveCodexFastModeExtension(ctx, resolvedModel);
     const args = ["--mode", "json", "-p", "--no-extensions"];
+    if (childCodexFastModeExtension) args.push("-e", childCodexFastModeExtension);
     if (existsSync(childSafetyExtension)) args.push("-e", childSafetyExtension);
     args.push("--session", sessionPath);
-    const model = modelOverride ?? agent.model;
+    const model = resolvedModel;
     if (model) args.push("--model", model);
     const thinking = resolveChildThinking(agent, thinkingOverride);
     if (thinking) args.push("--thinking", thinking);

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

@@ -0,0 +1,19 @@
+import type { GoalTodoChildGoalStatus, GoalTodoClaimTargetReadiness, GoalTodoClaimValidationConfidence, GoalTodoClaimValidationRecommendedAction, GoalTodoClaimValidationStatus, GoalTodoClaimValidationVerdict, GoalTodoDelegationStatus, GoalTodoOwner, GoalTodoPriority, GoalTodoStatus, GoalTodoStatusClaim } from "../goal-todo-types.js";
+
+export const ZOB_GOAL_TODO_ENTRY_TYPE = "zob-goal-todo";
+
+export const OPEN_REQUIRED_STATUSES = new Set<GoalTodoStatus>(["planned", "ready", "in_progress", "delegated", "claim_returned", "needs_review", "needs_oracle", "needs_user", "blocked"]);
+export const ACTIVE_STATUSES = new Set<GoalTodoStatus>(["ready", "in_progress", "delegated", "claim_returned", "needs_review"]);
+export const ACTIONABLE_STATUSES = new Set<GoalTodoStatus>(["planned", "ready", "in_progress", "needs_review", "needs_user", "needs_oracle", "blocked"]);
+export const VALID_STATUS: readonly GoalTodoStatus[] = ["planned", "ready", "in_progress", "delegated", "claim_returned", "needs_review", "needs_oracle", "needs_user", "blocked", "done", "skipped"];
+export const VALID_OWNER: readonly GoalTodoOwner[] = ["agent", "user", "oracle", "subagent", "factory", "orchestration"];
+export const VALID_PRIORITY: readonly GoalTodoPriority[] = ["low", "normal", "high", "critical"];
+export const VALID_DELEGATION_STATUS: readonly GoalTodoDelegationStatus[] = ["queued", "running", "claim_returned", "accepted", "rejected", "failed"];
+export const VALID_CHILD_GOAL_STATUS: readonly GoalTodoChildGoalStatus[] = ["ready_for_oracle", "incomplete", "blocked"];
+export const VALID_STATUS_CLAIM: readonly GoalTodoStatusClaim[] = ["done", "incomplete", "blocked"];
+export const VALID_TARGET_READINESS: readonly GoalTodoClaimTargetReadiness[] = ["ready_for_parent_acceptance", "needs_parent_review", "blocked"];
+export const VALID_VALIDATION_STATUS: readonly GoalTodoClaimValidationStatus[] = ["queued", "running", "passed", "warn", "failed", "blocked"];
+export const VALID_VALIDATION_VERDICT: readonly GoalTodoClaimValidationVerdict[] = ["PASS", "WARN", "FAIL"];
+export const VALID_VALIDATION_ACTION: readonly GoalTodoClaimValidationRecommendedAction[] = ["accept_claim", "needs_review", "reject_claim", "block"];
+export const VALID_VALIDATION_CONFIDENCE: readonly GoalTodoClaimValidationConfidence[] = ["LOW", "MEDIUM", "HIGH"];
+export const SHA256_HEX = /^[a-f0-9]{64}$/i;

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

@@ -0,0 +1,148 @@
+import type { GoalTodoCompletionDiagnostics, GoalTodoNode, GoalTodoState, GoalTodoSummary } from "../goal-todo-types.js";
+import { ACTIONABLE_STATUSES, ACTIVE_STATUSES, OPEN_REQUIRED_STATUSES } from "./constants.js";
+import { cloneNode } from "./normalize.js";
+import { childrenOf, nextValidGoalTodoActions, validateGoalTodoGraph } from "./operations.js";
+import { goalNodes } from "./reducer.js";
+
+export function summarizeGoalTodos(todoState: GoalTodoState, goalId?: string): GoalTodoSummary {
+  const nodes = goalId ? goalNodes(todoState, goalId) : todoState.nodes.map(cloneNode);
+  const done = nodes.filter((node) => node.status === "done").length;
+  const skipped = nodes.filter((node) => node.status === "skipped").length;
+  const open = nodes.filter((node) => OPEN_REQUIRED_STATUSES.has(node.status)).length;
+  const active = nodes.filter((node) => ACTIVE_STATUSES.has(node.status)).length;
+  const blocked = nodes.filter((node) => node.status === "blocked").length;
+  const delegated = nodes.filter((node) => node.status === "delegated" || node.delegation?.status === "running" || node.delegation?.status === "queued").length;
+  const claimReturned = nodes.filter((node) => node.status === "claim_returned").length;
+  const validationQueued = nodes.filter((node) => node.validation?.status === "queued").length;
+  const validationRunning = nodes.filter((node) => node.validation?.status === "running").length;
+  const validationPassed = nodes.filter((node) => node.validation?.status === "passed").length;
+  const validationFailed = nodes.filter((node) => node.validation?.status === "failed" || node.validation?.status === "blocked" || node.validation?.status === "warn").length;
+  const needsUser = nodes.filter((node) => node.status === "needs_user").length;
+  const needsOracle = nodes.filter((node) => node.status === "needs_oracle").length;
+  const nextAgent = nodes.find((node) => node.owner === "agent" && (node.status === "ready" || node.status === "planned" || node.status === "in_progress"));
+  const nextUser = nodes.find((node) => ACTIONABLE_STATUSES.has(node.status) && (node.owner === "user" || node.status === "needs_user"));
+  return {
+    goalId,
+    total: nodes.length,
+    required: nodes.filter((node) => node.required).length,
+    done,
+    skipped,
+    open,
+    active,
+    blocked,
+    delegated,
+    claimReturned,
+    validationQueued,
+    validationRunning,
+    validationPassed,
+    validationFailed,
+    needsUser,
+    needsOracle,
+    nextAgent,
+    nextUser,
+  };
+}
+
+export function formatGoalTodoSummary(summary: GoalTodoSummary): string {
+  if (summary.total === 0) return "todos unset";
+  const closed = summary.done + summary.skipped;
+  const validation = summary.validationQueued + summary.validationRunning > 0 ? ` · validation ${summary.validationQueued + summary.validationRunning}` : summary.validationFailed > 0 ? ` · validation_alerts ${summary.validationFailed}` : "";
+  return `todos ${closed}/${summary.total} · open ${summary.open} · active ${summary.active} · blocked ${summary.blocked} · delegated ${summary.delegated} · claims ${summary.claimReturned}${validation}`;
+}
+
+export function formatGoalTodoHudLine(todoState: GoalTodoState, goalId: string | undefined): string {
+  if (!goalId) return "todos unset";
+  const summary = summarizeGoalTodos(todoState, goalId);
+  const next = summary.nextAgent ? ` · next agent ${summary.nextAgent.path} ${summary.nextAgent.title}` : summary.nextUser ? ` · next user ${summary.nextUser.path} ${summary.nextUser.title}` : "";
+  return `${formatGoalTodoSummary(summary)}${next}`;
+}
+
+export function formatGoalTodoPromptHint(todoState: GoalTodoState, goalId: string | undefined): string {
+  if (!goalId) return "- goal_todos: no active runtime goal";
+  const summary = summarizeGoalTodos(todoState, goalId);
+  if (summary.total === 0) return "- goal_todos: none set; create TODOs for long, multi-step goal work when appropriate";
+  return [
+    `- goal_todos: ${formatGoalTodoSummary(summary)}`,
+    summary.nextAgent ? `- next_agent_todo: ${summary.nextAgent.path} ${summary.nextAgent.title}` : undefined,
+    summary.nextUser ? `- next_user_todo: ${summary.nextUser.path} ${summary.nextUser.title}` : undefined,
+    summary.claimReturned > 0 ? "- delegated_claims: claim_returned TODOs require parent evidence checks or agentic validation; use resolve_goal_todo(action=auto|complete|accept_claim), complete_goal_todo, /goal todo done, or accept_goal_todo_claim to accept returned claims" : undefined,
+    summary.validationQueued + summary.validationRunning > 0 ? `- claim_validation: ${summary.validationQueued + summary.validationRunning} oracle validation(s) queued/running; auto-accept only after PASS/no_ship=false` : undefined,
+    "- completion rule: use resolve_goal_todo for done/skip/claim/block/reopen transitions; required TODOs must be done/skipped with evidence before propose_goal_completion",
+  ].filter((line): line is string => typeof line === "string").join("\n");
+}
+
+export function formatGoalTodoTree(todoState: GoalTodoState, goalId: string | undefined): string {
+  if (!goalId) return "No active runtime goal; goal TODOs require a goalId.";
+  const nodes = goalNodes(todoState, goalId);
+  if (nodes.length === 0) return "No goal TODOs set. Use /goal todo add <title>.";
+  const icon = (node: GoalTodoNode): string => {
+    if (node.status === "done") return "✓";
+    if (node.status === "skipped") return "↷";
+    if (node.status === "blocked") return "▲";
+    if (node.status === "delegated") return "⇄";
+    if (node.status === "claim_returned") return "◇";
+    if (node.status === "needs_user") return "?";
+    if (node.status === "needs_oracle") return "◆";
+    if (node.status === "in_progress") return "●";
+    return "○";
+  };
+  const diagnostics = goalTodoCompletionDiagnostics(todoState, goalId);
+  const lines = [formatGoalTodoSummary(summarizeGoalTodos(todoState, goalId)), formatGoalTodoDiagnostics(diagnostics)];
+  const walk = (parentId: string | undefined, indent = ""): void => {
+    const children = childrenOf(todoState, goalId, parentId);
+    children.forEach((node, index) => {
+      const last = index === children.length - 1;
+      const branch = indent ? (last ? "└─" : "├─") : "";
+      const required = node.required ? "req" : "opt";
+      const delegation = node.delegation?.runId ? ` · run ${node.delegation.runId}` : "";
+      const claim = node.claim?.claimHash ? ` · claim ${node.claim.claimHash.slice(0, 12)}` : "";
+      const validation = node.validation ? ` · validation ${node.validation.status}${node.validation.verdict ? `/${node.validation.verdict}` : ""}${node.validation.runId ? ` ${node.validation.runId}` : ""}` : "";
+      const blocker = node.blocker ? ` · blocker ${node.blocker}` : "";
+      lines.push(`${indent}${branch}${icon(node)} ${node.path} ${node.title} [${node.status}/${node.owner}/${required}/${node.priority}] · id ${node.id}${delegation}${claim}${validation}${blocker}`);
+      walk(node.id, `${indent}${last ? "  " : "│ "}`);
+    });
+  };
+  walk(undefined);
+  return lines.join("\n");
+}
+
+export function goalTodoCompletionBlockers(todoState: GoalTodoState, goalId: string | undefined): string[] {
+  if (!goalId) return [];
+  const nodes = goalNodes(todoState, goalId);
+  if (nodes.length === 0) return [];
+  const blockers: string[] = [];
+  for (const node of nodes) {
+    if (node.required && OPEN_REQUIRED_STATUSES.has(node.status)) blockers.push(`todo ${node.path} '${node.title}' is required and ${node.status}`);
+    if (node.required && node.status === "skipped" && !node.skipReason?.trim()) blockers.push(`todo ${node.path} '${node.title}' skipped without explicit reason`);
+    const evidenceRequired = todoState.policy.requireEvidenceForCritical && (node.priority === "critical" || Boolean(node.delegation) || node.owner === "factory" || node.owner === "orchestration");
+    if (node.status === "done" && evidenceRequired && node.evidenceRefs.length === 0 && node.validationCommands.length === 0 && !node.artifacts?.outputHash) blockers.push(`todo ${node.path} '${node.title}' done without evidence`);
+    if (node.status === "skipped" && evidenceRequired && node.evidenceRefs.length === 0 && node.validationCommands.length === 0 && !node.artifacts?.outputHash) blockers.push(`todo ${node.path} '${node.title}' skipped without evidence`);
+    if (node.status === "done" && node.delegation && node.delegation.status !== "accepted") blockers.push(`todo ${node.path} '${node.title}' delegated claim is not parent-accepted`);
+    if (node.status === "done") {
+      const openChildren = nodes.filter((candidate) => candidate.parentId === node.id && candidate.required && OPEN_REQUIRED_STATUSES.has(candidate.status));
+      if (openChildren.length > 0) blockers.push(`todo ${node.path} '${node.title}' is done but has open required child TODOs`);
+    }
+  }
+  blockers.push(...validateGoalTodoGraph(todoState, goalId));
+  return blockers;
+}
+
+export function goalTodoCompletionDiagnostics(todoState: GoalTodoState, goalId: string | undefined): GoalTodoCompletionDiagnostics {
+  const nodes = goalId ? goalNodes(todoState, goalId) : [];
+  const completionBlockers = goalTodoCompletionBlockers(todoState, goalId);
+  const reviewNoShip = nodes.some((node) => node.reviewNoShip === true);
+  const hardNoShip = completionBlockers.length > 0;
+  return {
+    completionReady: completionBlockers.length === 0 && !reviewNoShip,
+    hardNoShip,
+    reviewNoShip,
+    effectiveNoShip: hardNoShip || reviewNoShip,
+    completionBlockers,
+    nextValidActions: Object.fromEntries(nodes.map((node) => [node.id, nextValidGoalTodoActions(node)])),
+  };
+}
+
+export function formatGoalTodoDiagnostics(diagnostics: GoalTodoCompletionDiagnostics): string {
+  const blockers = diagnostics.completionBlockers.slice(0, 3).join(" | ") || "none";
+  return `completion_ready=${diagnostics.completionReady} · hard_no_ship=${diagnostics.hardNoShip} · review_no_ship=${diagnostics.reviewNoShip} · effective_no_ship=${diagnostics.effectiveNoShip} · completion_blockers=${blockers}`;
+}