zob-harness 0.1.0

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

@@ -0,0 +1,147 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+import { buildZcommitPlan, runGovernedZcommitCommit, runGovernedZcommitPush, type ZcommitCommandResult, type ZcommitPlan, type ZcommitPlanOptions } from "../git-ops.js";
+import { ZcommitRunParams } from "../schemas.js";
+import type { HarnessRuntimeState } from "./state.js";
+import { sha256 } from "../utils/hashing.js";
+
+function uniqueSorted(values: string[]): string[] {
+  return [...new Set(values.filter((value) => value.trim().length > 0))].sort();
+}
+
+function sessionModifiedPathspecs(state: HarnessRuntimeState): string[] {
+  const sessionStartedAt = Date.parse(state.zcommit.sessionStartedAt ?? "");
+  const touched = Object.keys(state.zcommit.touchedFiles ?? {});
+  const ownedThisSession = Object.values(state.zcommit.ownedPathRefs ?? {})
+    .filter((ref) => {
+      if (Number.isNaN(sessionStartedAt)) return true;
+      const lastOwnedAt = Date.parse(ref.lastOwnedAt);
+      return !Number.isNaN(lastOwnedAt) && lastOwnedAt >= sessionStartedAt;
+    })
+    .map((ref) => ref.path);
+  return uniqueSorted([...touched, ...ownedThisSession]);
+}
+
+function resolvePathspecs(state: HarnessRuntimeState, scope: string | undefined, paths: string[] | undefined): { pathspecs: string[]; errors: string[] } {
+  const selectedScope = scope ?? (paths && paths.length > 0 ? "pathspecs" : "all_safe_dirty");
+  if (selectedScope === "all_safe_dirty") return { pathspecs: [], errors: [] };
+  if (selectedScope === "pathspecs") {
+    if (!paths || paths.length === 0) return { pathspecs: [], errors: ["scope=pathspecs requires non-empty paths"] };
+    return { pathspecs: uniqueSorted(paths), errors: [] };
+  }
+  if (selectedScope === "session_modified") {
+    const sessionPaths = sessionModifiedPathspecs(state);
+    if (paths && paths.length > 0) {
+      const allowed = new Set(sessionPaths);
+      const requested = uniqueSorted(paths);
+      const outside = requested.filter((path) => !allowed.has(path));
+      if (outside.length > 0) return { pathspecs: requested.filter((path) => allowed.has(path)), errors: outside.map((path) => `path is not recorded as modified in this session: ${path}`) };
+      return { pathspecs: requested, errors: [] };
+    }
+    if (sessionPaths.length === 0) return { pathspecs: [], errors: ["scope=session_modified found no current-session modified paths; use scope=pathspecs or all_safe_dirty"] };
+    return { pathspecs: sessionPaths, errors: [] };
+  }
+  return { pathspecs: [], errors: [`unknown zcommit scope: ${selectedScope}`] };
+}
+
+function zcommitLedgerEntry(action: string, scope: string, params: { paths?: string[]; message?: string; body?: string[]; user_requested?: boolean }, plan: ZcommitPlan, result?: ZcommitCommandResult): Record<string, unknown> {
+  return {
+    schema: "zob.zcommit-tool.v1",
+    bodyStored: false,
+    action,
+    scope,
+    status: result ? (result.ok ? "ok" : "blocked_or_failed") : "planned",
+    userRequested: params.user_requested === true,
+    policyLoaded: plan.policyLoaded,
+    selectionMode: plan.selectionMode,
+    validationMode: plan.validationMode,
+    selectionPathspecHashes: plan.selectionPathspecs.map((pathspec) => sha256(pathspec)),
+    requestedPathHashes: (params.paths ?? []).map((path) => sha256(path)),
+    messageHash: params.message ? sha256(params.message) : undefined,
+    bodyLineHashes: (params.body ?? []).map((line) => sha256(line)),
+    eligibleCount: plan.eligible.length,
+    excludedCount: plan.excluded.length,
+    forbiddenCount: plan.forbidden.length,
+    unexpectedStagedCount: plan.unexpectedStaged.length,
+    noShip: plan.noShip,
+    commitEnabled: plan.commitEnabled,
+    pushEnabled: plan.pushEnabled,
+    validationOk: result?.validation?.ok,
+    lastCommitHash: result?.commit?.hash,
+    lastCommitShortHash: result?.commit?.shortHash,
+    errorHashes: result?.errors.map((error) => sha256(error)),
+    actualGitCommitRun: result?.actualGitCommitRun ?? false,
+    actualGitPushRun: result?.actualGitPushRun ?? false,
+    generatedAt: new Date().toISOString(),
+  };
+}
+
+function planSummary(plan: ZcommitPlan): string {
+  const commit = `${plan.conventionalCommit.type}(${plan.conventionalCommit.scope}): ${plan.conventionalCommit.subject}`;
+  const pathspecs = plan.selectionPathspecs.join(", ") || "all-safe-dirty";
+  return `mode=${plan.selectionMode} scope_pathspecs=[${pathspecs}] eligible=${plan.eligible.length} excluded=${plan.excluded.length} forbidden=${plan.forbidden.length} commit=${plan.commitEnabled ? "ready" : "blocked"} conventional_commit="${commit}"`;
+}
+
+export function registerZcommitTools(pi: ExtensionAPI, state: HarnessRuntimeState): void {
+  pi.registerTool({
+    name: "zob_zcommit_run",
+    label: "ZOB Zcommit Run",
+    description: "Agent-executable governed zcommit workflow. Plan, commit, push, or commit_and_push via the /zcommit engine when the user explicitly asks; never use direct git commit/push/tag or global staging.",
+    promptSnippet: "Use zob_zcommit_run when the user asks you to commit/push. Prefer action=commit_and_push with scope=session_modified or paths; do not ask the user to paste /zcommit commands.",
+    parameters: ZcommitRunParams,
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const action = params.action ?? "plan";
+      const scope = params.scope ?? (params.paths && params.paths.length > 0 ? "pathspecs" : "all_safe_dirty");
+      const { pathspecs, errors } = resolvePathspecs(state, scope, params.paths);
+      const options: ZcommitPlanOptions = { pathspecs, message: params.message, body: params.body };
+      const plan = buildZcommitPlan(ctx.cwd, state.zcommit, options);
+      if (errors.length > 0) {
+        pi.appendEntry("zob-zcommit", zcommitLedgerEntry(action, scope, params, plan));
+        return { content: [{ type: "text", text: `zob_zcommit_run blocked: ${errors.join(" | ")}; ${planSummary(plan)}` }], details: { schema: "zob.zcommit-tool-result.v1", status: "blocked", errors, plan } };
+      }
+
+      const wantsCommit = action === "commit" || action === "commit_and_push";
+      const wantsPush = action === "push" || action === "commit_and_push" || params.push === true;
+      if ((wantsCommit || wantsPush) && params.user_requested !== true && state.zcommit.autocommit !== "on") {
+        const authorizationErrors = ["commit/push actions require user_requested=true or /zcommit autocommit on"];
+        pi.appendEntry("zob-zcommit", zcommitLedgerEntry(action, scope, params, plan));
+        return { content: [{ type: "text", text: `zob_zcommit_run blocked: ${authorizationErrors.join(" | ")}; ${planSummary(plan)}` }], details: { schema: "zob.zcommit-tool-result.v1", status: "blocked", errors: authorizationErrors, plan } };
+      }
+
+      if (action === "plan") {
+        pi.appendEntry("zob-zcommit", zcommitLedgerEntry("tool_plan", scope, params, plan));
+        return { content: [{ type: "text", text: `zob_zcommit_run plan: ${planSummary(plan)}` }], details: { schema: "zob.zcommit-tool-result.v1", status: "planned", plan } };
+      }
+
+      if (action === "commit") {
+        const result = runGovernedZcommitCommit(ctx.cwd, state.zcommit, options);
+        pi.appendEntry("zob-zcommit", zcommitLedgerEntry(result.ok ? "tool_commit_created" : "tool_commit_blocked", scope, params, result.plan, result));
+        if (params.push === true && result.ok) {
+          const pushResult = runGovernedZcommitPush(ctx.cwd, state.zcommit, { explicitPush: true });
+          pi.appendEntry("zob-zcommit", zcommitLedgerEntry(pushResult.ok ? "tool_push_completed" : "tool_push_blocked", scope, params, pushResult.plan, pushResult));
+          return { content: [{ type: "text", text: `zob_zcommit_run commit+push: ${result.message}; ${pushResult.message}` }], details: { schema: "zob.zcommit-tool-result.v1", status: pushResult.ok ? "ok" : "blocked_or_failed", commitResult: result, pushResult } };
+        }
+        return { content: [{ type: "text", text: `zob_zcommit_run commit: ${result.message}` }], details: { schema: "zob.zcommit-tool-result.v1", status: result.ok ? "ok" : "blocked_or_failed", result } };
+      }
+
+      if (action === "push") {
+        const result = runGovernedZcommitPush(ctx.cwd, state.zcommit, { explicitPush: true });
+        pi.appendEntry("zob-zcommit", zcommitLedgerEntry(result.ok ? "tool_push_completed" : "tool_push_blocked", scope, params, result.plan, result));
+        return { content: [{ type: "text", text: `zob_zcommit_run push: ${result.message}` }], details: { schema: "zob.zcommit-tool-result.v1", status: result.ok ? "ok" : "blocked_or_failed", result } };
+      }
+
+      if (action === "commit_and_push") {
+        const commitResult = runGovernedZcommitCommit(ctx.cwd, state.zcommit, options);
+        pi.appendEntry("zob-zcommit", zcommitLedgerEntry(commitResult.ok ? "tool_commit_created" : "tool_commit_blocked", scope, params, commitResult.plan, commitResult));
+        if (!commitResult.ok) return { content: [{ type: "text", text: `zob_zcommit_run commit_and_push blocked during commit: ${commitResult.message}` }], details: { schema: "zob.zcommit-tool-result.v1", status: "blocked_or_failed", commitResult } };
+        const pushResult = runGovernedZcommitPush(ctx.cwd, state.zcommit, { explicitPush: true });
+        pi.appendEntry("zob-zcommit", zcommitLedgerEntry(pushResult.ok ? "tool_push_completed" : "tool_push_blocked", scope, params, pushResult.plan, pushResult));
+        return { content: [{ type: "text", text: `zob_zcommit_run commit_and_push: ${commitResult.message}; ${pushResult.message}` }], details: { schema: "zob.zcommit-tool-result.v1", status: pushResult.ok ? "ok" : "blocked_or_failed", commitResult, pushResult } };
+      }
+
+      const unknownErrors = [`unknown zcommit action: ${action}`];
+      pi.appendEntry("zob-zcommit", zcommitLedgerEntry("tool_unknown_action", scope, params, plan));
+      return { content: [{ type: "text", text: `zob_zcommit_run blocked: ${unknownErrors.join(" | ")}` }], details: { schema: "zob.zcommit-tool-result.v1", status: "blocked", errors: unknownErrors, plan } };
+    },
+  });
+}

package/.pi/extensions/zob-harness/src/runtime/widget.ts

@@ -0,0 +1,353 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+
+import { MODE_TOOLS } from "../constants.js";
+import { buildDaemonRuntimeState, buildDaemonTickPlan } from "../daemon-runtime.js";
+import { goalTodoCompletionDiagnostics, summarizeGoalTodos } from "../goal-todos.js";
+import { isRecord } from "../utils/records.js";
+import type { AssistantLikeMessage, ModeName } from "../types.js";
+import { readHarnessReadinessWidgetData } from "../orchestration/widget-readers.js";
+import { buildZpeerPeerRoomSummaries } from "../coms-v2/zpeer.js";
+import { delegationCost, delegationDurationMs, formatDelegationCost, formatDuration, summarizeDelegations } from "./delegation-monitor.js";
+import { disposeDelegationMouseSupport } from "./delegation-mouse.js";
+import { formatZcompactHudLine } from "./auto-compaction.js";
+import type { HarnessRuntimeState } from "./state.js";
+
+const PRODUCT_HUD_IGNORED_READINESS_BLOCKERS = new Set(["global_autonomy_not_proven_for_arbitrary_factories"]);
+
+function isProductHudReadinessBlocker(blocker: string): boolean {
+  return !PRODUCT_HUD_IGNORED_READINESS_BLOCKERS.has(blocker.trim());
+}
+
+function formatHudTokenCount(value: number): string {
+  const safe = Math.max(0, Math.floor(value));
+  if (safe < 1_000) return String(safe);
+  if (safe < 1_000_000) return `${(safe / 1_000).toFixed(safe < 10_000 ? 1 : 0)}k`;
+  return `${(safe / 1_000_000).toFixed(1)}m`;
+}
+
+function formatAgentSeconds(seconds: number | undefined): string {
+  if (typeof seconds !== "number" || !Number.isFinite(seconds)) return "—";
+  return formatDuration(Math.max(0, Math.trunc(seconds)) * 1000);
+}
+
+function goalEndTimeMs(runtimeGoal: { status?: string; updatedAt?: unknown } | undefined, nowMs: number): number {
+  if (!runtimeGoal || runtimeGoal.status === "active") return nowMs;
+  const updatedAt = runtimeGoal.updatedAt;
+  if (typeof updatedAt !== "number" || !Number.isFinite(updatedAt)) return nowMs;
+  return updatedAt * 1000;
+}
+
+function formatGoalElapsed(goalCreatedAt: number | undefined, endMs: number): string {
+  if (typeof goalCreatedAt !== "number" || !Number.isFinite(goalCreatedAt)) return "—";
+  const startedAtMs = goalCreatedAt * 1000;
+  return formatDuration(Math.max(0, endMs - startedAtMs));
+}
+
+function numberFrom(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+
+function assistantCostFromMessage(message: AssistantLikeMessage): number | undefined {
+  if (message.role !== "assistant" || !isRecord(message.usage)) return undefined;
+  if (!isRecord(message.usage.cost)) return undefined;
+  return numberFrom(message.usage.cost.total);
+}
+
+function collectAssistantMessagesFromEntry(entry: unknown): AssistantLikeMessage[] {
+  const result: AssistantLikeMessage[] = [];
+  if (!isRecord(entry)) return result;
+
+  const addRecordMessage = (value: unknown): void => {
+    if (isRecord(value) && value.role === "assistant") result.push(value as AssistantLikeMessage);
+  };
+
+  const addMessages = (value: unknown): void => {
+    if (!Array.isArray(value)) return;
+    for (const item of value) addRecordMessage(item);
+  };
+
+  addRecordMessage(entry);
+  addRecordMessage(entry.message);
+  addMessages(entry.messages);
+  const data = entry.data;
+  if (isRecord(data)) {
+    addRecordMessage(data);
+    addRecordMessage(data.message);
+    addMessages(data.messages);
+  }
+  return result;
+}
+
+function readConversationCostFromBranch(ctx: ExtensionContext): number | undefined {
+  if (!ctx.sessionManager || typeof ctx.sessionManager.getBranch !== "function") return undefined;
+  let total = 0;
+  let foundNumeric = false;
+  try {
+    for (const entry of ctx.sessionManager.getBranch()) {
+      for (const message of collectAssistantMessagesFromEntry(entry)) {
+        const messageCost = assistantCostFromMessage(message);
+        if (messageCost === undefined) continue;
+        total += Math.max(0, messageCost);
+        foundNumeric = true;
+      }
+    }
+  } catch {
+    return undefined;
+  }
+  return foundNumeric ? total : undefined;
+}
+
+export function renderHarnessWidget(pi: ExtensionAPI, state: HarnessRuntimeState, ctx: ExtensionContext): void {
+  void pi;
+  const scopeGateText = state.activeGoal ? state.activeGoal.activeGoal : "unset";
+  const runtimeGoal = state.runtimeGoal;
+  const runtimeObjectiveText = runtimeGoal ? runtimeGoal.objective : "unset";
+  const runtimeTodoSummary = runtimeGoal ? summarizeGoalTodos(state.goalTodos, runtimeGoal.goalId) : undefined;
+  const todoDiagnostics = runtimeGoal ? goalTodoCompletionDiagnostics(state.goalTodos, runtimeGoal.goalId) : undefined;
+  const readiness = readHarnessReadinessWidgetData(ctx.cwd);
+  const daemonStatus = buildDaemonRuntimeState({
+    policy: state.daemon.policy,
+    runtimeGoal: state.runtimeGoal,
+    goalTodos: state.goalTodos,
+    autonomy: {
+      mode: state.autonomy.mode,
+      enabled: state.autonomy.enabled,
+      lastReadiness: state.autonomy.lastReadiness,
+      lastLaunchAuthorization: state.autonomy.lastLaunchAuthorization,
+    },
+    loop: state.daemon.loop,
+  });
+  const daemonPlan = state.daemon.lastPlan ?? buildDaemonTickPlan(daemonStatus);
+  if (typeof ctx.ui.setStatus === "function") ctx.ui.setStatus("zob-goal", undefined);
+
+  ctx.ui.setWidget("zob-harness", (_tui, theme) => {
+    const mouseOwner = Symbol("zob-harness-widget");
+
+    const fit = (text: string, innerWidth: number): string => {
+      const clipped = truncateToWidth(text, Math.max(1, innerWidth), "…");
+      return clipped + " ".repeat(Math.max(0, innerWidth - visibleWidth(clipped)));
+    };
+
+    const border = (kind: "top" | "bottom", width: number, label?: string): string => {
+      if (width < 8) return truncateToWidth(label ?? "", width, "");
+      if (kind === "bottom") return theme.fg("dim", `╰${"─".repeat(width - 2)}╯`);
+      const title = label ? ` ${label} ` : "";
+      const fillWidth = Math.max(0, width - visibleWidth("╭─") - visibleWidth(title) - visibleWidth("╮"));
+      return theme.fg("dim", "╭─") + title + theme.fg("dim", `${"─".repeat(fillWidth)}╮`);
+    };
+
+    const row = (width: number, content: string): string => {
+      if (width < 8) return truncateToWidth(content, width, "");
+      const innerWidth = Math.max(1, width - 4);
+      return theme.fg("dim", "│ ") + fit(content, innerWidth) + theme.fg("dim", " │");
+    };
+
+    const twoColumnRow = (leftWidth: number, rightWidth: number, left: string, right: string): string => {
+      return `${theme.fg("dim", "│ ")}${fit(left, leftWidth)}${theme.fg("dim", " │ ")}${fit(right, rightWidth)}${theme.fg("dim", " │")}`;
+    };
+
+    const threeColumnRow = (leftWidth: number, middleWidth: number, rightWidth: number, left: string, middle: string, right: string): string => {
+      return `${theme.fg("dim", "│ ")}${fit(left, leftWidth)}${theme.fg("dim", " │ ")}${fit(middle, middleWidth)}${theme.fg("dim", " │ ")}${fit(right, rightWidth)}${theme.fg("dim", " │")}`;
+    };
+
+    const meter = (done: number, total: number, size: number): string => {
+      const safeTotal = Math.max(1, total);
+      const ratio = Math.min(1, Math.max(0, done / safeTotal));
+      const filled = Math.min(size, Math.max(0, Math.round(ratio * size)));
+      const color: "success" | "muted" = ratio >= 1 ? "success" : "muted";
+      return `${theme.fg(color, "█".repeat(filled))}${theme.fg("dim", "░".repeat(Math.max(0, size - filled)))}`;
+    };
+
+    const humanTodo = (title: string | undefined, fallback: string): string => truncateToWidth(title?.trim() || fallback, 96, "…");
+
+    return {
+      dispose() { disposeDelegationMouseSupport(state, { owner: mouseOwner }); },
+      invalidate() {},
+      render(width: number): string[] {
+        disposeDelegationMouseSupport(state, { owner: mouseOwner });
+        const panelWidth = Math.max(1, width);
+        const delegationSummary = summarizeDelegations(state.delegations);
+        const nowMs = Date.now();
+        const agentTokens = runtimeGoal?.usage.tokensUsed;
+        const subTokenRuns = state.delegations.runs.filter((run) => run.usage);
+        const subTokens = subTokenRuns.reduce((sum, run) => sum + Math.max(0, Math.trunc((run.usage?.input ?? 0) + (run.usage?.output ?? 0))), 0);
+        const totalKnownTokens = (agentTokens ?? 0) + subTokens;
+        const hasKnownTokens = runtimeGoal !== undefined || subTokenRuns.length > 0;
+        const knownCostRuns = state.delegations.runs.filter((run) => run.usage);
+        const knownSubCost = knownCostRuns.reduce((sum, run) => sum + delegationCost(run), 0);
+        const conversationCost = readConversationCostFromBranch(ctx);
+        const hasConversationCost = typeof conversationCost === "number";
+        const totalKnownCost = hasConversationCost ? knownSubCost + conversationCost : undefined;
+        const subDurationMs = state.delegations.runs.reduce((sum, run) => sum + delegationDurationMs(run, nowMs), 0);
+        const statusCost = hasConversationCost
+          ? `cost total ${formatDelegationCost(totalKnownCost)} · convo ${formatDelegationCost(conversationCost)} · sub ${formatDelegationCost(knownSubCost)}`
+          : `cost total n/a · convo n/a · sub ${formatDelegationCost(knownSubCost)}`;
+        const statusTokens = hasKnownTokens ? formatHudTokenCount(totalKnownTokens) : "—";
+        const elapsedTime = runtimeGoal
+          ? formatGoalElapsed(runtimeGoal.createdAt, goalEndTimeMs(runtimeGoal, nowMs))
+          : "—";
+        const statusTime = runtimeGoal || state.delegations.runs.length > 0
+          ? `elapsed ${elapsedTime} · agent ${formatAgentSeconds(runtimeGoal?.usage.activeSeconds)} · sub ${state.delegations.runs.length > 0 ? formatDuration(subDurationMs) : "—"} cum`
+          : "—";
+        const zcompactLine = formatZcompactHudLine(state.zcompact, ctx);
+        const zcompactColor = state.zcompact.running ? "warning" : state.zcompact.mode === "auto" ? "success" : state.zcompact.mode === "observe" ? "accent" : "dim";
+        ctx.ui.setStatus("zob-usage", theme.fg("muted", `usage ${statusCost} · tok total ${statusTokens} · time ${statusTime}`));
+        ctx.ui.setStatus("zob-zcompact", theme.fg(zcompactColor, zcompactLine));
+        const closedTodos = runtimeTodoSummary ? runtimeTodoSummary.done + runtimeTodoSummary.skipped : 0;
+        const totalTodos = runtimeTodoSummary?.total ?? 0;
+        const progress = totalTodos > 0
+          ? `${closedTodos}/${totalTodos} ${meter(closedTodos, totalTodos, 10)}`
+          : runtimeGoal
+            ? "not broken down yet"
+            : "no active mission";
+        const mission = runtimeGoal
+          ? humanTodo(runtimeObjectiveText, "Mission in progress")
+          : scopeGateText !== "unset"
+            ? humanTodo(scopeGateText, "Mission scoped")
+            : "Choose a mission with /goal";
+
+        const productReadinessBlocker = readiness.blockers.find(isProductHudReadinessBlocker);
+        const missionNoShip = Boolean(productReadinessBlocker) || runtimeGoal?.oracle.noShip === true || todoDiagnostics?.effectiveNoShip === true;
+        const alerts: string[] = [];
+        if (runtimeGoal?.status === "blocked" || runtimeTodoSummary?.blocked) alerts.push("Blocked");
+        if (runtimeTodoSummary?.needsUser) alerts.push("Waiting for user");
+        if (missionNoShip) alerts.push("Delivery blocked");
+        if (runtimeTodoSummary?.claimReturned) alerts.push("Result to review");
+        if (runtimeTodoSummary?.needsOracle || runtimeGoal?.status === "ready_for_oracle" || runtimeGoal?.oracle.status === "needed") alerts.push("Review required");
+        const uniqueAlerts = [...new Set(alerts)];
+
+        const assistantsWorking = delegationSummary.running > 0 || delegationSummary.queued > 0 || (runtimeTodoSummary?.delegated ?? 0) > 0;
+        const mainState = uniqueAlerts[0]
+          ?? (assistantsWorking ? "Assistants working" : runtimeGoal ? "In progress" : "Ready");
+        const need = uniqueAlerts.length > 0 ? uniqueAlerts.join(" · ") : mainState;
+        const blockerText = runtimeGoal?.oracle.blockerSummary ?? productReadinessBlocker;
+        const needLine = blockerText && uniqueAlerts.length > 0
+          ? `${need} — ${truncateToWidth(blockerText, 96, "…")}`
+          : need;
+
+        const nextTitle = runtimeTodoSummary?.nextUser?.title ?? runtimeTodoSummary?.nextAgent?.title;
+        const daemonBlocker = daemonStatus.reasonCodes.find((code) => code.includes("blocked") || code.includes("missing") || code.includes("needs"));
+        const loop = daemonStatus.loop;
+        const loopText = loop ? ` loop=${loop.status} ${loop.tickCount}${loop.maxTicks ? `/${loop.maxTicks}` : ""}` : "";
+        const daemonLine = `mode=${daemonStatus.policy.enabled ? "plan-only" : "off"} status=${daemonStatus.status}${loopText} last=${daemonPlan.action}${daemonBlocker ? ` blocker=${daemonBlocker}` : ""}`;
+        const nextAction = runtimeTodoSummary?.blocked
+          ? "Clear the blocker before continuing"
+          : runtimeTodoSummary?.needsUser
+            ? humanTodo(runtimeTodoSummary.nextUser?.title, "Wait for user input")
+            : runtimeTodoSummary?.claimReturned
+              ? "Review the returned result"
+              : runtimeTodoSummary?.needsOracle
+                ? "Request or wait for review"
+                : nextTitle
+                  ? humanTodo(nextTitle, "Continue the next step")
+                  : runtimeGoal
+                    ? "Continue the mission or propose delivery"
+                    : "Set the mission";
+
+        const reviewState = runtimeTodoSummary?.claimReturned
+          ? "Result to review"
+          : runtimeTodoSummary?.needsOracle || runtimeGoal?.status === "ready_for_oracle" || runtimeGoal?.oracle.status === "needed"
+            ? "Review required"
+            : "clear";
+        const qualityState = missionNoShip
+          ? "delivery blocked"
+          : runtimeGoal?.status === "blocked" || runtimeTodoSummary?.blocked
+            ? "blocked"
+            : totalTodos > 0 || runtimeGoal
+              ? "check OK"
+              : "check needed";
+        const activityState = assistantsWorking
+          ? "assistants"
+          : runtimeGoal
+            ? "working"
+            : "idle";
+        const assistantsCount = delegationSummary.running + delegationSummary.queued + (runtimeTodoSummary?.delegated ?? 0);
+        const assistantsState = assistantsCount > 0
+          ? `${assistantsCount} active`
+          : "none";
+        const zpeerRoomSummaries = state.zobLive.peerCard ? buildZpeerPeerRoomSummaries(ctx.cwd, state.zobLive.peerCard) : [];
+        const zpeerLast = state.zobLive.lastEvent
+          ? `${state.zobLive.lastEvent.kind} ${state.zobLive.lastEvent.fromAlias ? `@${state.zobLive.lastEvent.fromAlias}` : "?"}→${state.zobLive.lastEvent.toAlias ? `@${state.zobLive.lastEvent.toAlias}` : "?"} ${state.zobLive.lastEvent.status}`
+          : "none";
+        const zpeerPending = state.zobLive.pendingReplies.snapshot().filter((item) => item.status === "pending").length;
+        const zpeerHeartbeatAge = state.zobLive.lastHeartbeatMs ? formatDuration(nowMs - state.zobLive.lastHeartbeatMs) : "—";
+        const zpeerRoomCap = 4;
+        const zpeerRoomLines = zpeerRoomSummaries.slice(0, zpeerRoomCap).map((summary) => {
+          const marker = summary.active ? "*" : " ";
+          const selfAlias = `@${summary.selfAlias ?? "?"}`;
+          const peerState = `${summary.online}/${summary.peerCount}${summary.stale > 0 ? ` s${summary.stale}` : ""}${summary.offline > 0 ? ` off${summary.offline}` : ""}`;
+          const peerAliases = summary.aliases.filter((alias) => alias !== summary.selfAlias).slice(0, 2).map((alias) => `@${alias}`);
+          const aliasOverflow = Math.max(0, summary.aliases.length - (summary.selfAlias && summary.aliases.includes(summary.selfAlias) ? 1 : 0) - peerAliases.length);
+          const aliasText = peerAliases.length > 0 ? `${peerAliases.join(" ")}${aliasOverflow > 0 ? ` +${aliasOverflow}` : ""}` : "no peers";
+          return theme.fg("muted", truncateToWidth(`${marker} ${summary.roomId} ${selfAlias} ${peerState} ${aliasText}`, 52, "…"));
+        });
+        if (zpeerRoomSummaries.length > zpeerRoomCap) zpeerRoomLines.push(theme.fg("dim", `+${zpeerRoomSummaries.length - zpeerRoomCap} rooms`));
+        const zpeerLines = state.zobLive.peerCard
+          ? [
+            `${theme.fg("accent", "ZPeer")} ${theme.fg("muted", `${zpeerRoomSummaries.length} room${zpeerRoomSummaries.length === 1 ? "" : "s"}`)}`,
+            ...zpeerRoomLines,
+            `${theme.fg("dim", "Last")} ${theme.fg(state.zobLive.lastEvent ? "muted" : "dim", zpeerLast)}`,
+            `${theme.fg("dim", "Wait")} ${theme.fg(zpeerPending > 0 ? "warning" : "muted", `${zpeerPending} pending · hb ${zpeerHeartbeatAge}`)}`,
+            `${theme.fg("dim", "Status")} ${theme.fg("success", "connected")}`,
+          ]
+          : [
+            `${theme.fg("accent", "ZPeer")}`,
+            `${theme.fg("dim", "Last")} ${theme.fg(state.zobLive.lastEvent ? "muted" : "dim", zpeerLast)}`,
+            `${theme.fg("dim", "Status")} ${theme.fg("dim", "not connected")}`,
+          ];
+
+        const leftLines = [
+          `${theme.fg("accent", "Mission")} ${theme.fg(runtimeGoal ? "muted" : "dim", mission)}`,
+          `${theme.fg("accent", "Progress")} ${theme.fg(totalTodos > 0 ? "muted" : "dim", progress)}`,
+          `${theme.fg("accent", "Next")} ${theme.fg(mainState === "Ready" ? "dim" : "muted", nextAction)}`,
+          `${theme.fg(uniqueAlerts.length > 0 ? "warning" : "success", "Need")} ${theme.fg(uniqueAlerts.length > 0 ? "warning" : "muted", needLine)}`,
+          `${theme.fg("dim", "Daemon")} ${theme.fg("muted", daemonLine)}`,
+          `${theme.fg("dim", "Context")} ${theme.fg(zcompactColor, zcompactLine)}`,
+          `${theme.fg("dim", "Open")} ${theme.fg("muted", "/zcompact · /zpeer · /zstatus · /todos overlay · /delegates")}`,
+        ];
+        const rightLines = [
+          `${theme.fg("accent", "Focus")} ${theme.fg("muted", state.activeMode)}`,
+          `${theme.fg("accent", "Activity")} ${theme.fg(assistantsWorking ? "muted" : "dim", activityState)}`,
+          `${theme.fg(reviewState === "clear" ? "success" : "warning", "Review")} ${theme.fg(reviewState === "clear" ? "muted" : "warning", reviewState)}`,
+          `${theme.fg(qualityState === "check OK" ? "success" : "warning", "Quality")} ${theme.fg(qualityState === "check OK" ? "muted" : "warning", qualityState)}`,
+          `${theme.fg("accent", "Assistants")} ${theme.fg(assistantsCount > 0 ? "muted" : "dim", assistantsState)}`,
+        ];
+        const wideRows = Math.max(leftLines.length, zpeerLines.length, rightLines.length);
+
+        if (panelWidth < 72) return leftLines.slice(0, 4).map((line) => truncateToWidth(line, panelWidth, "…"));
+        if (panelWidth < 112) {
+          const contextLine = `${theme.fg("dim", "Context")} ${theme.fg(zcompactColor, zcompactLine)}`;
+          return [
+            border("top", panelWidth, `${theme.fg("accent", "◆ ZOB")} ${theme.fg("muted", "live")}`),
+            ...leftLines.map((line) => row(panelWidth, line)),
+            row(panelWidth, ""),
+            ...zpeerLines.map((line) => row(panelWidth, line)),
+            row(panelWidth, contextLine),
+            border("bottom", panelWidth),
+          ];
+        }
+
+        const availableColumnWidth = Math.max(1, panelWidth - 10);
+        const zpeerWidth = Math.min(52, Math.max(34, Math.floor(availableColumnWidth * 0.36)));
+        const rightWidth = Math.min(32, Math.max(28, Math.floor(availableColumnWidth * 0.26)));
+        const leftWidth = Math.max(24, availableColumnWidth - zpeerWidth - rightWidth);
+        return [
+          border("top", panelWidth, `${theme.fg("accent", "◆ ZOB")} ${theme.fg("muted", "live")}`),
+          ...Array.from({ length: wideRows }, (_, index) => threeColumnRow(leftWidth, zpeerWidth, rightWidth, leftLines[index] ?? "", zpeerLines[index] ?? "", rightLines[index] ?? "")),
+          border("bottom", panelWidth),
+        ];
+      },
+    };
+  });
+}
+
+export function applyMode(pi: ExtensionAPI, state: HarnessRuntimeState, ctx: ExtensionContext, mode: ModeName, persist = true): void {
+  state.activeMode = mode;
+  const available = new Set(pi.getAllTools().map((tool) => tool.name));
+  pi.setActiveTools(MODE_TOOLS[mode].filter((tool) => available.has(tool)));
+  if (persist) pi.appendEntry("zob-mode-state", { mode, timestamp: new Date().toISOString() });
+  ctx.ui.setStatus("zob-mode", ctx.ui.theme.fg("accent", `zob:${mode}`));
+  renderHarnessWidget(pi, state, ctx);
+  ctx.ui.notify(`ZOB mode: ${mode}`, "info");
+}

package/.pi/extensions/zob-harness/src/runtime/zobHarness.ts

@@ -0,0 +1,60 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+import { registerHarnessCommands } from "./commands.js";
+import { registerHarnessEvents } from "./events.js";
+import { createHarnessRuntimeState } from "./state.js";
+import { registerAutonomousTools } from "./tools-autonomous.js";
+import { registerComsTools } from "./tools-coms.js";
+import { registerComputeTools } from "./tools-compute.js";
+import { registerContextTools } from "./tools-context.js";
+import { registerDelegationTools } from "./tools-delegation.js";
+import { registerMissionControlTools } from "./tools-mission-control.js";
+import { registerFactoryTools } from "./tools-factory.js";
+import { registerProjectDnaTools } from "./tools-project-dna.js";
+import { registerOrchestrationTools } from "./tools-orchestration.js";
+import { registerGoalRuntimeEvents, registerGoalRuntimeTools } from "../goal-runtime.js";
+import { registerGoalRoomTools } from "./tools-goal-room.js";
+import { registerGovernedRequestTools } from "./tools-governed-requests.js";
+import { registerWorkspaceClaimTools } from "./tools-workspace-claims.js";
+import { registerWorkerPoolTools } from "./tools-worker-pool.js";
+import { registerMergeQueueTools } from "./tools-merge-queue.js";
+import { registerZcommitTools } from "./tools-zcommit.js";
+import { renderHarnessWidget } from "./widget.js";
+
+export default function zobHarness(pi: ExtensionAPI): void {
+  const state = createHarnessRuntimeState();
+
+  registerHarnessCommands(pi, state);
+
+  registerGoalRuntimeTools(pi, state);
+
+  registerDelegationTools(pi, state);
+
+  registerOrchestrationTools(pi, state);
+
+  registerComsTools(pi, state);
+
+  registerGoalRoomTools(pi);
+  registerGovernedRequestTools(pi);
+  registerWorkspaceClaimTools(pi);
+  registerWorkerPoolTools(pi);
+  registerMergeQueueTools(pi);
+
+  registerZcommitTools(pi, state);
+
+  registerMissionControlTools(pi);
+
+  registerContextTools(pi);
+
+  registerComputeTools(pi);
+
+  registerProjectDnaTools(pi);
+
+  registerAutonomousTools(pi);
+
+  registerFactoryTools(pi, state);
+
+  registerGoalRuntimeEvents(pi, state, (ctx) => renderHarnessWidget(pi, state, ctx));
+
+  registerHarnessEvents(pi, state);
+}