zob-harness 0.1.0

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

@@ -0,0 +1,403 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { TUI } from "@earendil-works/pi-tui";
+
+import { DEFAULT_RULES, MODE_PROMPTS } from "../constants.js";
+import type { ChildResult, DamageRules, DelegationFailureKind, GoalState, ModeName, QueueTickResult, RuleResolution } from "../types.js";
+import { validateGoalState, validateStrictGoalSpecAnchor, type StrictGoalSpecAnchor } from "../goal.js";
+import { DEFAULT_GOAL_ACTIVATION_MODE, restoreGoalActivationModeFromBranch, restoreRuntimeGoalFromBranch, type GoalActivationMode, type RuntimeGoal } from "../goal-runtime.js";
+import { createGoalTodoState, restoreGoalTodosFromBranch, type GoalTodoState } from "../goal-todos.js";
+import { isRecord } from "../utils/records.js";
+import type { ZobLiveEnvelope } from "../coms-v2/envelope.js";
+import type { ZobLocalTransportServer } from "../coms-v2/local-transport.js";
+import { ZobPendingReplies } from "../coms-v2/pending-replies.js";
+import type { ZobLivePeerCard } from "../coms-v2/types.js";
+import { createDelegationMonitorState, trimDelegationRuns, type DelegationMonitorState, type DelegationRunMode, type DelegationRunSource, type DelegationRunStatus, type DelegationRunView } from "./delegation-monitor.js";
+import { DEFAULT_DAEMON_RUNTIME_POLICY, type DaemonLoopSnapshot, type DaemonRuntimePolicy, type DaemonRuntimeState, type DaemonTickPlan } from "../daemon-runtime.js";
+import { createInteractiveAutonomyRuntimeState, restoreInteractiveAutonomyState, type InteractiveAutonomyRuntimeState } from "../interactive-autonomy.js";
+import type { ZobModeIntent } from "./mode-intent.js";
+import { createZcompactRuntimeState, restoreZcompactStateFromBranch, type ZcompactRuntimeState } from "./auto-compaction.js";
+import { createZcommitRuntimeState, recordZcommitOwnedPath, type ZcommitLastCommitRecord, type ZcommitOwnershipSource, type ZcommitRuntimeState, type ZcommitToggleState } from "../git-ops.js";
+
+export interface DelegationMouseRuntimeState {
+  tui?: TUI;
+  enabled: boolean;
+  unsubscribe?: () => void;
+  opening: boolean;
+  overlaySelect?: (runId: string) => boolean;
+  overlayClose?: () => boolean;
+  overlayScroll?: (direction: "up" | "down", x?: number, y?: number) => boolean;
+  mouseReenableTimer?: ReturnType<typeof setTimeout>;
+  releasedUntilMs?: number;
+  suppressOpenUntilMs?: number;
+  mouseReleaseEpoch: number;
+  widgetOwner?: symbol;
+}
+
+export interface ZobLiveLastEvent {
+  kind: "status" | "attempt" | "delivered" | "waiting" | "reply" | "sent" | "completed" | "blocked" | "error" | "timeout" | "expired" | "inbound" | "response_sent" | "heartbeat";
+  roomId?: string;
+  fromAlias?: string;
+  toAlias?: string;
+  status: string;
+  reason?: string;
+  msgId?: string;
+  taskHash?: string;
+  outputHash?: string;
+  at: string;
+  localOnly: true;
+  networkEnabled: false;
+  bodyStored: false;
+}
+
+export interface ZobLiveRuntimeState {
+  pendingReplies: ZobPendingReplies;
+  server?: ZobLocalTransportServer;
+  peerCard?: ZobLivePeerCard;
+  inbound?: { envelope: ZobLiveEnvelope; receivedAt: string; responseSent: boolean; repoRoot: string };
+  lastEvent?: ZobLiveLastEvent;
+  zpeerAskGuard?: { windowStartedMs: number; count: number; lastRoomId?: string; lastTargetAlias?: string; lastMessageHash?: string };
+  heartbeatTimer?: ReturnType<typeof setTimeout>;
+  lastHeartbeatMs?: number;
+}
+
+export interface DaemonHarnessRuntimeState {
+  policy: DaemonRuntimePolicy;
+  lastStatus?: DaemonRuntimeState;
+  lastPlan?: DaemonTickPlan;
+  loop: DaemonLoopSnapshot;
+  loopTimer?: ReturnType<typeof setTimeout>;
+  lastQueueTick?: QueueTickResult;
+  updatedAt?: string;
+}
+
+export interface BackgroundDelegationRuntimeRun {
+  runId: string;
+  startedAtMs: number;
+  promise: Promise<ChildResult>;
+  abortController: AbortController;
+  result?: ChildResult;
+  error?: string;
+}
+
+export interface HarnessRuntimeState {
+  activeMode: ModeName;
+  currentRules: DamageRules;
+  activeGoal?: GoalState;
+  goalRequired: boolean;
+  goalActivationMode?: GoalActivationMode;
+  runtimeGoal?: RuntimeGoal;
+  goalTodos: GoalTodoState;
+  runtimeGoalContinuationQueuedFor?: string;
+  runtimeGoalContinuationScheduledFor?: string;
+  runtimeGoalContinuationCompactionFor?: string;
+  runtimeGoalContinuationTimer?: ReturnType<typeof setTimeout>;
+  runtimeGoalContinuationTurnFor?: string;
+  runtimeGoalLastAccountedAtMs?: number;
+  activeRuleResolution?: RuleResolution;
+  lastUserInputText?: string;
+  lastModeIntent?: ZobModeIntent & { at: number; accepted: boolean; validationReason: string };
+  delegations: DelegationMonitorState;
+  delegationMouse: DelegationMouseRuntimeState;
+  zobLive: ZobLiveRuntimeState;
+  autonomy: InteractiveAutonomyRuntimeState;
+  daemon: DaemonHarnessRuntimeState;
+  zcompact: ZcompactRuntimeState;
+  zcommit: ZcommitRuntimeState;
+  backgroundDelegations: Map<string, BackgroundDelegationRuntimeRun>;
+}
+
+export function createHarnessRuntimeState(): HarnessRuntimeState {
+  return {
+    activeMode: "explore",
+    currentRules: DEFAULT_RULES,
+    activeGoal: undefined,
+    goalRequired: false,
+    goalActivationMode: DEFAULT_GOAL_ACTIVATION_MODE,
+    runtimeGoal: undefined,
+    goalTodos: createGoalTodoState(),
+    runtimeGoalContinuationQueuedFor: undefined,
+    runtimeGoalContinuationScheduledFor: undefined,
+    runtimeGoalContinuationCompactionFor: undefined,
+    runtimeGoalContinuationTimer: undefined,
+    runtimeGoalLastAccountedAtMs: undefined,
+    activeRuleResolution: undefined,
+    lastUserInputText: undefined,
+    lastModeIntent: undefined,
+    delegations: createDelegationMonitorState(),
+    delegationMouse: { enabled: false, opening: false, mouseReleaseEpoch: 0 },
+    zobLive: { pendingReplies: new ZobPendingReplies() },
+    autonomy: createInteractiveAutonomyRuntimeState(),
+    daemon: {
+      policy: { ...DEFAULT_DAEMON_RUNTIME_POLICY, enabled: false },
+      loop: {
+        schema: "zob.daemon-loop-snapshot.v1",
+        status: "stopped",
+        tickCount: 0,
+        supervised: true,
+        bounded: true,
+        sessionLocal: true,
+        autoStartDaemon: false,
+        continuousLoop: false,
+        cronEnabled: false,
+      },
+    },
+    zcompact: createZcompactRuntimeState(),
+    zcommit: createZcommitRuntimeState(),
+    backgroundDelegations: new Map(),
+  };
+}
+
+export function strictGoalErrors(state: HarnessRuntimeState): string[] {
+  return state.goalRequired ? validateGoalState(state.activeGoal) : [];
+}
+
+export function strictGoalSpecErrors(state: HarnessRuntimeState, anchor: Omit<StrictGoalSpecAnchor, "activeGoal">): string[] {
+  return validateStrictGoalSpecAnchor({ ...anchor, activeGoal: state.activeGoal });
+}
+
+export function asGoalState(value: unknown): GoalState | undefined {
+  if (!isRecord(value)) return undefined;
+  const goal = {
+    originalUserAsk: typeof value.originalUserAsk === "string" ? value.originalUserAsk : "",
+    activeGoal: typeof value.activeGoal === "string" ? value.activeGoal : "",
+    constraints: typeof value.constraints === "string" ? value.constraints : "",
+    expectedOutput: typeof value.expectedOutput === "string" ? value.expectedOutput : "",
+    validationEvidence: typeof value.validationEvidence === "string" ? value.validationEvidence : "",
+    setAt: typeof value.setAt === "string" ? value.setAt : new Date().toISOString(),
+  };
+  return validateGoalState(goal).length === 0 ? goal : undefined;
+}
+
+function stringField(record: Record<string, unknown>, key: string): string | undefined {
+  const value = record[key];
+  return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+}
+
+function numberField(record: Record<string, unknown>, key: string): number | undefined {
+  const value = record[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+
+function parseTimeMs(value: string | undefined, fallback: number): number {
+  if (!value) return fallback;
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+
+function asDelegationMode(value: string | undefined): DelegationRunMode {
+  return value === "parallel" || value === "chain" || value === "single" ? value : "single";
+}
+
+function asDelegationSource(value: string | undefined): DelegationRunSource {
+  return value === "delegate_task" ? "delegate_task" : "delegate_agent";
+}
+
+function asDelegationFailureKind(value: string | undefined): DelegationFailureKind | undefined {
+  return value === "preflight" || value === "config" || value === "output_gate" || value === "child_runtime" || value === "aborted" ? value : undefined;
+}
+
+function stringArrayField(record: Record<string, unknown>, key: string): string[] | undefined {
+  const value = record[key];
+  return Array.isArray(value) ? value.map(String) : undefined;
+}
+
+function asZcommitToggle(value: unknown): ZcommitToggleState | undefined {
+  return value === "on" || value === "off" ? value : undefined;
+}
+
+function asZcommitOwnershipSource(value: unknown): ZcommitOwnershipSource | undefined {
+  return value === "local_tool_call" || value === "parent_accepted_child_claim" || value === "compaction_continuity" ? value : undefined;
+}
+
+function normalizeZcommitChildChangedPathRefs(value: unknown): DelegationRunView["childChangedPaths"] {
+  if (!Array.isArray(value)) return undefined;
+  return value.flatMap((item) => {
+    if (!isRecord(item) || typeof item.path !== "string" || typeof item.pathHash !== "string" || typeof item.status !== "string") return [];
+    return [{ path: item.path, pathHash: item.pathHash, status: item.status, contentHash: typeof item.contentHash === "string" ? item.contentHash : undefined }];
+  }).slice(0, 100);
+}
+
+function asZcommitLastCommitRecord(value: unknown): ZcommitLastCommitRecord | undefined {
+  if (!isRecord(value) || typeof value.hash !== "string" || typeof value.shortHash !== "string" || typeof value.subject !== "string" || !Array.isArray(value.files) || typeof value.createdAt !== "string") return undefined;
+  return {
+    hash: value.hash,
+    shortHash: value.shortHash,
+    subject: value.subject,
+    files: value.files.map(String),
+    remote: typeof value.remote === "string" ? value.remote : undefined,
+    branch: typeof value.branch === "string" ? value.branch : undefined,
+    createdAt: value.createdAt,
+    pushedAt: typeof value.pushedAt === "string" ? value.pushedAt : undefined,
+  };
+}
+
+function restoreZcommitOwnedPathRefsFromData(state: HarnessRuntimeState, repoRoot: string, data: Record<string, unknown>, fallbackSource: ZcommitOwnershipSource, fallbackAt: string): void {
+  const refs = Array.isArray(data.ownedPathRefs) ? data.ownedPathRefs : [];
+  for (const value of refs) {
+    if (!isRecord(value) || typeof value.path !== "string") continue;
+    recordZcommitOwnedPath(state.zcommit, repoRoot, value.path, asZcommitOwnershipSource(value.source) ?? fallbackSource, typeof value.lastOwnedAt === "string" ? value.lastOwnedAt : fallbackAt);
+  }
+}
+
+function restoreZcommitMetadataFromEntries(state: HarnessRuntimeState, repoRoot: string, entries: unknown[]): void {
+  for (const entry of entries) {
+    if (!isRecord(entry) || entry.customType !== "zob-zcommit" || !isRecord(entry.data)) continue;
+    const data = entry.data as Record<string, unknown>;
+    const entryAt = stringField(data, "generatedAt") ?? stringField(entry, "timestamp") ?? new Date().toISOString();
+    state.zcommit.autocommit = asZcommitToggle(data.autocommit) ?? state.zcommit.autocommit;
+    state.zcommit.autopush = asZcommitToggle(data.autopush) ?? state.zcommit.autopush;
+    const lastCommit = asZcommitLastCommitRecord(data.lastCommit);
+    if (lastCommit) state.zcommit.lastCommit = lastCommit;
+    const lastCommitHash = stringField(data, "lastCommitHash");
+    const lastCommitShortHash = stringField(data, "lastCommitShortHash");
+    if (!lastCommit && lastCommitHash && lastCommitShortHash) {
+      state.zcommit.lastCommit = { hash: lastCommitHash, shortHash: lastCommitShortHash, subject: "restored /zcommit commit", files: [], createdAt: entryAt };
+    }
+    restoreZcommitOwnedPathRefsFromData(state, repoRoot, data, "local_tool_call", entryAt);
+    state.zcommit.updatedAt = entryAt;
+  }
+}
+
+function restoreDaemonMetadataFromEntries(state: HarnessRuntimeState, entries: unknown[]): void {
+  for (const entry of entries) {
+    if (!isRecord(entry) || !isRecord(entry.data)) continue;
+    const customType = typeof entry.customType === "string" ? entry.customType : "";
+    const data = entry.data as Record<string, unknown>;
+    if (customType !== "zob-daemon-runtime" && customType !== "zob-daemon-plan") continue;
+    state.daemon.policy = {
+      ...state.daemon.policy,
+      enabled: false,
+      planOnly: true,
+      scopedToActiveGoal: true,
+      autoStartAllowed: false,
+      continuousLoopAllowed: false,
+      cronAllowed: false,
+      childDispatchAllowed: false,
+      queueClaimsAllowed: false,
+      todoMutationAllowed: false,
+      productionApplyAllowed: false,
+    };
+    state.daemon.updatedAt = stringField(data, "generatedAt") ?? stringField(entry, "timestamp") ?? state.daemon.updatedAt;
+    state.daemon.loop = {
+      ...state.daemon.loop,
+      status: "stopped",
+      stoppedAt: state.daemon.updatedAt,
+      autoStartDaemon: false,
+      continuousLoop: false,
+      cronEnabled: false,
+    };
+  }
+}
+
+function usageField(record: Record<string, unknown>): ChildResult["usage"] | undefined {
+  const usage = isRecord(record.usage) ? record.usage : undefined;
+  if (!usage) return undefined;
+  const numberValue = (key: string): number => {
+    const value = usage[key];
+    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+  };
+  return {
+    turns: numberValue("turns"),
+    input: numberValue("input"),
+    output: numberValue("output"),
+    cacheRead: numberValue("cacheRead"),
+    cacheWrite: numberValue("cacheWrite"),
+    cost: numberValue("cost"),
+    contextTokens: numberValue("contextTokens"),
+  };
+}
+
+function restoredStatusFromLedger(event: string | undefined, status: string | undefined): DelegationRunStatus {
+  if (event === "preflight_failed" || event === "config_failed") return "preflight_failed";
+  if (status === "complete" || status === "completed") return "complete";
+  if (status === "aborted") return "aborted";
+  if (status === "failed" || status === "incomplete_or_failed" || status === "failed_preflight") return "failed";
+  return event === "end" ? "complete" : "running";
+}
+
+function restoreDelegationRunsFromEntries(state: HarnessRuntimeState, entries: unknown[]): void {
+  const restored = new Map<string, DelegationRunView>();
+  for (const entry of entries) {
+    if (!isRecord(entry) || entry.customType !== "zob-delegation" || !isRecord(entry.data)) continue;
+    const data = entry.data as Record<string, unknown>;
+    const runId = stringField(data, "runId");
+    if (!runId) continue;
+    const event = stringField(data, "event");
+    const timestampMs = parseTimeMs(stringField(data, "startedAt") ?? stringField(data, "endedAt") ?? stringField(entry, "timestamp"), Date.now());
+    const existing = restored.get(runId);
+    const source = asDelegationSource(stringField(data, "source") ?? stringField(data, "tool"));
+    const mode = asDelegationMode(stringField(data, "delegationMode") ?? stringField(data, "mode"));
+    const agent = stringField(data, "agent") ?? existing?.agent ?? "delegate";
+    const taskHash = stringField(data, "taskHash");
+    const startedAtMs = existing?.startedAtMs ?? parseTimeMs(stringField(data, "startedAt"), Math.max(0, timestampMs - (numberField(data, "latencyMs") ?? 0)));
+    const status = restoredStatusFromLedger(event, stringField(data, "status"));
+    const restoredRun: DelegationRunView = {
+      id: runId,
+      parentToolCallId: stringField(data, "parentToolCallId") ?? existing?.parentToolCallId ?? runId,
+      source: existing?.source ?? source,
+      mode: existing?.mode ?? mode,
+      index: numberField(data, "index") ?? existing?.index,
+      agent,
+      taskPreview: existing?.taskPreview ?? (taskHash ? `task hash ${taskHash.slice(0, 12)}` : "restored delegation"),
+      status,
+      startedAtMs,
+      endedAtMs: parseTimeMs(stringField(data, "endedAt"), timestampMs),
+      outputPreview: existing?.outputPreview ?? "",
+      stderrPreview: existing?.stderrPreview ?? "",
+      sessionPath: stringField(data, "sessionPath") ?? existing?.sessionPath,
+      exitCode: numberField(data, "exitCode") ?? existing?.exitCode,
+      gatePassed: typeof data.gatePassed === "boolean" ? data.gatePassed : existing?.gatePassed,
+      gateErrors: stringArrayField(data, "gateErrors") ?? stringArrayField(data, "errors") ?? existing?.gateErrors,
+      failureKind: asDelegationFailureKind(stringField(data, "failureKind")) ?? existing?.failureKind,
+      stopReason: stringField(data, "stopReason") ?? existing?.stopReason,
+      stopCondition: stringField(data, "stopCondition") ?? existing?.stopCondition,
+      errorMessage: Array.isArray(data.errors) ? data.errors.map(String).join("; ") : existing?.errorMessage,
+      childChangedPaths: normalizeZcommitChildChangedPathRefs(data.childChangedPathRefs) ?? existing?.childChangedPaths,
+      usage: usageField(data) ?? existing?.usage,
+    };
+    if (event === "start") restoredRun.endedAtMs = existing?.endedAtMs;
+    restored.set(runId, restoredRun);
+  }
+  if (restored.size === 0) return;
+  state.delegations.runs = [...restored.values()].sort((a, b) => b.startedAtMs - a.startedAtMs);
+  trimDelegationRuns(state.delegations);
+}
+
+export function restoreHarnessState(state: HarnessRuntimeState, ctx: ExtensionContext): void {
+  const branch = ctx.sessionManager.getBranch();
+  for (const entry of branch) {
+    if (!isRecord(entry)) continue;
+    const customType = typeof entry.customType === "string" ? entry.customType : "";
+    const data = isRecord(entry.data) ? entry.data : undefined;
+    if (customType === "zob-mode-state" && data && typeof data.mode === "string" && data.mode in MODE_PROMPTS) state.activeMode = data.mode as ModeName;
+    if (customType === "zob-goal") state.activeGoal = asGoalState(data) ?? state.activeGoal;
+    if (customType === "zob-job-intake" && data && isRecord(data.goal)) state.activeGoal = asGoalState(data.goal) ?? state.activeGoal;
+    if (customType === "zob-job-intake") state.goalRequired = true;
+  }
+  state.runtimeGoal = restoreRuntimeGoalFromBranch(branch);
+  state.goalActivationMode = restoreGoalActivationModeFromBranch(branch) ?? state.goalActivationMode;
+  state.goalTodos = restoreGoalTodosFromBranch(branch);
+  state.autonomy = restoreInteractiveAutonomyState(ctx.cwd, branch, state.autonomy);
+  state.zcompact = restoreZcompactStateFromBranch(branch, state.zcompact);
+  restoreDaemonMetadataFromEntries(state, branch);
+  restoreZcommitMetadataFromEntries(state, ctx.cwd, branch);
+  state.daemon.lastStatus = undefined;
+  state.daemon.lastPlan = undefined;
+  restoreDelegationRunsFromEntries(state, branch);
+}
+
+export function inferModeFromUserIntent(text: string): ModeName | undefined {
+  const normalized = text.trim().toLowerCase();
+  if (!normalized || normalized.startsWith("/")) return undefined;
+  const asksForOrchestration = /\b(orchestrator|orchestrat(?:e|ion|or)|orchestrer|multi[- ]?agent|lead(?:s)?|worker(?:s)?|chief vision|coordonn(?:e|er|ation)|d[eé]l[eè]gu(?:e|er|ation)|delegat(?:e|ion)|sub[- ]?agents?|subtasks?|work graph|todo graph|graphe de travail|graphe todo)\b/i.test(normalized);
+  if (asksForOrchestration) return "orchestrator";
+  const asksForMutation = /\b(update|udpate|modify|modifier|modifie|change|changer|corrige|correction|fix|patch|implement|impl[eé]mente|edit|write|[eé]cris|ajoute|add|create|cr[eé]e|supprime|delete|remove|refactor|refactorise|remplace|am[eé]lior(?:e|er)|appliqu(?:e|er)|mets?|mettre|rends?|rendre|fais\s+en\s+sorte|mets? .*jour|mise .*jour|faire .*update|continue .*update)\b/i.test(normalized);
+  if (!asksForMutation) return undefined;
+  const factoryIntent = /\b(factory|factory_run|pilot|batch|sentinel|manifest|quarantine|software factory)\b/i.test(normalized);
+  return factoryIntent ? "factory" : "implement";
+}
+
+
+export function bashLooksLikeFileMutation(command: string): boolean {
+  return /(^|[^2])>\s*[^&]|>>|\btee\b|\bsed\s+-i\b|\bperl\s+-pi\b|writeFileSync|writeFile\(|write_text\(|open\([^)]*["']w|\bpython3?\b[\s\S]*write|\bnode\b[\s\S]*writeFile/i.test(command);
+}

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

@@ -0,0 +1,117 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+import { AutonomousDryRunParams, AutonomousReadOnlySmokeParams, AutonomousValidateRunParams, AutonomousValidateSmokeParams } from "../schemas.js";
+import { validateAutonomousReadOnlySmokeRunArtifacts, validateAutonomousRuntimeDryRunArtifacts, writeAutonomousReadOnlySmokeRunReport, writeAutonomousRuntimeDryRunReport } from "../autonomous-runtime.js";
+
+export function registerAutonomousTools(pi: ExtensionAPI): void {
+  pi.registerTool({
+    name: "zob_autonomous_dry_run",
+    label: "ZOB Autonomous Runtime Dry-Run",
+    description: "Build a metadata-only P0 autonomous runtime dry-run: spec gate, context_scope, model routing plan, factory selection, proof plan, and final report plan. No child dispatch, no daemon, no production writes, no live/global routing, no global autonomy claim.",
+    parameters: AutonomousDryRunParams,
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      try {
+        const report = writeAutonomousRuntimeDryRunReport(ctx.cwd, {
+          userNeed: params.user_need,
+          refinedSpec: params.refined_spec,
+          runId: params.run_id,
+          constraints: params.constraints,
+          acceptanceCriteria: params.acceptance_criteria,
+          expectedArtifacts: params.expected_artifacts,
+          allowedPaths: params.allowed_paths,
+          forbiddenPaths: params.forbidden_paths,
+          allowedSources: params.allowed_sources,
+          maxContextTokens: params.max_context_tokens,
+          applyPolicy: params.apply_policy,
+          budgetProfile: params.budget_profile,
+          risk: params.risk,
+          authorizedAutonomyLevel: params.authorized_autonomy_level,
+          userLaunchConfirmed: params.user_launch_confirmed,
+          launchConfirmedAt: params.launch_confirmed_at,
+          allowedActions: params.allowed_actions,
+        });
+        const status = typeof report.status === "string" ? report.status : "unknown";
+        const runId = typeof report.runId === "string" ? report.runId : "unknown";
+        const reportPath = typeof report.reportPath === "string" ? report.reportPath : "reports/autonomous-runs";
+        return { content: [{ type: "text", text: `zob_autonomous_dry_run: ${status} ${runId} -> ${reportPath}` }], details: report };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { content: [{ type: "text", text: `zob_autonomous_dry_run blocked: ${message}` }], details: { status: "blocked", errors: [message], noExecution: true, childDispatchAllowed: false } };
+      }
+    },
+  });
+
+  pi.registerTool({
+    name: "zob_autonomous_readonly_smoke",
+    label: "ZOB Autonomous Read-Only Smoke",
+    description: "Run a Phase 4A reports-only deterministic autonomous smoke: spec/context/model-routing/factory-selection gates, deterministic factory_run smoke, structural oracle review, validation, and SMOKE_AUTONOMY_PASSED sentinel. No child dispatch, no daemon, no production writes, no live/global routing, no global autonomy claim.",
+    parameters: AutonomousReadOnlySmokeParams,
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      try {
+        const report = writeAutonomousReadOnlySmokeRunReport(ctx.cwd, {
+          userNeed: params.user_need,
+          refinedSpec: params.refined_spec,
+          runId: params.run_id,
+          factoryRunId: params.factory_run_id,
+          constraints: params.constraints,
+          acceptanceCriteria: params.acceptance_criteria,
+          expectedArtifacts: params.expected_artifacts,
+          allowedPaths: params.allowed_paths,
+          forbiddenPaths: params.forbidden_paths,
+          allowedSources: params.allowed_sources,
+          maxContextTokens: params.max_context_tokens,
+          applyPolicy: params.apply_policy,
+          budgetProfile: params.budget_profile,
+          risk: params.risk,
+          authorizedAutonomyLevel: params.authorized_autonomy_level,
+          userLaunchConfirmed: params.user_launch_confirmed,
+          launchConfirmedAt: params.launch_confirmed_at,
+          allowedActions: params.allowed_actions,
+        });
+        const status = typeof report.status === "string" ? report.status : "unknown";
+        const runId = typeof report.runId === "string" ? report.runId : "unknown";
+        const validationPath = typeof report.validationPath === "string" ? report.validationPath : "reports/autonomous-runs";
+        return { content: [{ type: "text", text: `zob_autonomous_readonly_smoke: ${status} ${runId} -> ${validationPath}` }], details: report };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { content: [{ type: "text", text: `zob_autonomous_readonly_smoke blocked: ${message}` }], details: { status: "blocked", errors: [message], childDispatchAllowed: false, daemonStarted: false, productionWritesPerformed: false, autoApply: false } };
+      }
+    },
+  });
+
+  pi.registerTool({
+    name: "zob_autonomous_validate_run",
+    label: "ZOB Autonomous Dry-Run Artifact Validation",
+    description: "Read-only validation for an existing P0 autonomous dry-run artifact set. Checks required artifacts, metadata/hash-only posture, context citations, runtime gates, run graph, factory proof requirements, and no-execution/no-network/no-global-autonomy flags.",
+    parameters: AutonomousValidateRunParams,
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      try {
+        const validation = validateAutonomousRuntimeDryRunArtifacts(ctx.cwd, params.run_id);
+        const status = validation.valid === true ? "valid" : "invalid";
+        const failedChecks = Array.isArray(validation.failedChecks) ? validation.failedChecks : [];
+        return { content: [{ type: "text", text: failedChecks.length === 0 ? `zob_autonomous_validate_run: ${status} ${params.run_id}` : `zob_autonomous_validate_run: ${status} ${params.run_id}\n- ${failedChecks.join("\n- ")}` }], details: validation };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { content: [{ type: "text", text: `zob_autonomous_validate_run blocked: ${message}` }], details: { status: "blocked", errors: [message], noExecution: true, childDispatchAllowed: false, networkAccessed: false } };
+      }
+    },
+  });
+
+  pi.registerTool({
+    name: "zob_autonomous_validate_smoke",
+    label: "ZOB Autonomous Read-Only Smoke Validation",
+    description: "Read-only validation for an existing Phase 4A autonomous read-only smoke artifact set. Checks factory-run-ref, structural oracle, validation, sentinels, and no global autonomy flags.",
+    parameters: AutonomousValidateSmokeParams,
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      try {
+        const validation = validateAutonomousReadOnlySmokeRunArtifacts(ctx.cwd, params.run_id);
+        const status = validation.valid === true ? "valid" : "invalid";
+        const failedChecks = Array.isArray(validation.failedChecks) ? validation.failedChecks : [];
+        return { content: [{ type: "text", text: failedChecks.length === 0 ? `zob_autonomous_validate_smoke: ${status} ${params.run_id}` : `zob_autonomous_validate_smoke: ${status} ${params.run_id}\n- ${failedChecks.join("\n- ")}` }], details: validation };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { content: [{ type: "text", text: `zob_autonomous_validate_smoke blocked: ${message}` }], details: { status: "blocked", errors: [message], childDispatchAllowed: false, networkAccessed: false } };
+      }
+    },
+  });
+}

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

@@ -0,0 +1,136 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+import { buildComputePreview, resolveComputeProfile, validateComputeProfileArtifacts, writeComputeProfileReports } from "../compute-profile.js";
+import { buildComputeWorkflowShape } from "../compute-workflow-shape.js";
+import { ComputePlanWorkflowParams, ComputePreviewParams, ComputeResolveProfileParams, ComputeValidateProfileParams, ComputeWriteProfileReportsParams } from "../schemas.js";
+
+export function registerComputeTools(pi: ExtensionAPI): void {
+  pi.registerTool({
+    name: "zob_compute_preview",
+    label: "ZOB Compute Profile Preview",
+    description: "Preview task/project complexity and recommend low/medium/high/xhigh/max compute without child dispatch, network access, or source writes.",
+    parameters: ComputePreviewParams,
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      try {
+        const preview = buildComputePreview(ctx.cwd, {
+          runId: params.run_id,
+          domain: params.domain,
+          requestedProfile: params.requested_profile,
+          targetPath: params.target_path,
+          taskHash: params.task_hash,
+          maxProfile: params.max_profile,
+          computeCaps: params.compute_caps,
+          riskHints: params.risk_hints,
+        });
+        const recommended = typeof preview.recommendedProfile === "string" ? preview.recommendedProfile : "unknown";
+        const confidence = typeof preview.confidence === "string" ? preview.confidence : "unknown";
+        return { content: [{ type: "text", text: `zob_compute_preview: recommended=${recommended} confidence=${confidence}` }], details: preview };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { content: [{ type: "text", text: `zob_compute_preview blocked: ${message}` }], details: { status: "blocked", errors: [message], noExecution: true, childDispatchAllowed: false, networkAccessed: false } };
+      }
+    },
+  });
+
+  pi.registerTool({
+    name: "zob_compute_resolve_profile",
+    label: "ZOB Compute Profile Resolve",
+    description: "Resolve requested compute profile into an effective profile, hard caps, and gates. Metadata-only; no child dispatch, network access, or source writes.",
+    parameters: ComputeResolveProfileParams,
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      try {
+        const resolution = resolveComputeProfile(ctx.cwd, {
+          runId: params.run_id,
+          domain: params.domain,
+          requestedProfile: params.requested_profile,
+          targetPath: params.target_path,
+          taskHash: params.task_hash,
+          maxProfile: params.max_profile,
+          computeCaps: params.compute_caps,
+          riskHints: params.risk_hints,
+        });
+        const effective = typeof resolution.effectiveProfile === "string" ? resolution.effectiveProfile : "unknown";
+        const noShip = resolution.noShip === true ? " no_ship=true" : "";
+        return { content: [{ type: "text", text: `zob_compute_resolve_profile: effective=${effective}${noShip}` }], details: resolution };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { content: [{ type: "text", text: `zob_compute_resolve_profile blocked: ${message}` }], details: { status: "blocked", errors: [message], noExecution: true, childDispatchAllowed: false, networkAccessed: false } };
+      }
+    },
+  });
+
+  pi.registerTool({
+    name: "zob_compute_plan_workflow",
+    label: "ZOB Compute Workflow Shape",
+    description: "Build a metadata-only workflow shape from a resolved compute profile. No child dispatch, network access, or source writes.",
+    parameters: ComputePlanWorkflowParams,
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      try {
+        const shape = buildComputeWorkflowShape(ctx.cwd, {
+          runId: params.run_id,
+          domain: params.domain,
+          requestedProfile: params.requested_profile,
+          targetPath: params.target_path,
+          taskHash: params.task_hash,
+          maxProfile: params.max_profile,
+          computeCaps: params.compute_caps,
+          riskHints: params.risk_hints,
+          resolutionPath: params.resolution_path,
+        });
+        const effective = typeof shape.effectiveProfile === "string" ? shape.effectiveProfile : "unknown";
+        const laneCount = Array.isArray(shape.lanes) ? shape.lanes.length : 0;
+        return { content: [{ type: "text", text: `zob_compute_plan_workflow: effective=${effective} lanes=${laneCount}` }], details: shape };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { content: [{ type: "text", text: `zob_compute_plan_workflow blocked: ${message}` }], details: { status: "blocked", errors: [message], noExecution: true, childDispatchAllowed: false, networkAccessed: false } };
+      }
+    },
+  });
+
+  pi.registerTool({
+    name: "zob_compute_validate_profile",
+    label: "ZOB Compute Profile Artifact Validation",
+    description: "Validate existing compute-preview/profile-resolution artifacts. Read-only; no execution, network access, or child dispatch.",
+    parameters: ComputeValidateProfileParams,
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      try {
+        const validation = validateComputeProfileArtifacts(ctx.cwd, {
+          previewPath: params.preview_path,
+          resolutionPath: params.resolution_path,
+        });
+        const status = validation.valid === true ? "valid" : "invalid";
+        const errors = Array.isArray(validation.errors) ? validation.errors : [];
+        return { content: [{ type: "text", text: errors.length === 0 ? `zob_compute_validate_profile: ${status}` : `zob_compute_validate_profile: ${status}\n- ${errors.join("\n- ")}` }], details: validation };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { content: [{ type: "text", text: `zob_compute_validate_profile blocked: ${message}` }], details: { status: "blocked", errors: [message], noExecution: true, childDispatchAllowed: false, networkAccessed: false } };
+      }
+    },
+  });
+
+  pi.registerTool({
+    name: "zob_compute_write_profile_reports",
+    label: "ZOB Compute Profile Report Writer",
+    description: "Write local metadata-only compute preview/profile-resolution reports under .pi/logs/compute-profile. No child dispatch, network access, or source writes.",
+    parameters: ComputeWriteProfileReportsParams,
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      try {
+        const report = writeComputeProfileReports(ctx.cwd, {
+          runId: params.run_id,
+          domain: params.domain,
+          requestedProfile: params.requested_profile,
+          targetPath: params.target_path,
+          taskHash: params.task_hash,
+          maxProfile: params.max_profile,
+          computeCaps: params.compute_caps,
+          riskHints: params.risk_hints,
+        });
+        const previewPath = typeof report.previewPath === "string" ? report.previewPath : ".pi/logs/compute-profile";
+        return { content: [{ type: "text", text: `zob_compute_write_profile_reports: written -> ${previewPath}` }], details: report };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { content: [{ type: "text", text: `zob_compute_write_profile_reports blocked: ${message}` }], details: { status: "blocked", errors: [message], noExecution: true, childDispatchAllowed: false, networkAccessed: false } };
+      }
+    },
+  });
+}