zob-harness 0.1.0

package/scripts/autonomy/mission-readiness-secret-smoke.mjs

@@ -0,0 +1,90 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { pathToFileURL } from "node:url";
+import ts from "typescript";
+
+const repoRoot = process.cwd();
+const runtimeRoot = join(repoRoot, "reports/benchmarks/coding-agent-benchmark/live-dokploy-pilot-v3/autonomy-secret-smoke-runtime");
+
+const sourceFiles = [
+  ".pi/extensions/zob-harness/src/interactive-autonomy.ts",
+  ".pi/extensions/zob-harness/src/utils/hashing.ts",
+  ".pi/extensions/zob-harness/src/utils/records.ts",
+];
+
+mkdirSync(runtimeRoot, { recursive: true });
+writeFileSync(join(runtimeRoot, "package.json"), `${JSON.stringify({ type: "module" })}\n`, "utf8");
+
+for (const sourceFile of sourceFiles) {
+  const sourcePath = join(repoRoot, sourceFile);
+  const outputPath = join(runtimeRoot, sourceFile.replace(/^\.pi\/extensions\/zob-harness\/src\//, "").replace(/\.ts$/, ".js"));
+  mkdirSync(dirname(outputPath), { recursive: true });
+  const source = readFileSync(sourcePath, "utf8");
+  const transpiled = ts.transpileModule(source, {
+    compilerOptions: {
+      module: ts.ModuleKind.ES2022,
+      target: ts.ScriptTarget.ES2022,
+      moduleResolution: ts.ModuleResolutionKind.NodeNext,
+      esModuleInterop: true,
+      verbatimModuleSyntax: true,
+    },
+    fileName: sourceFile,
+  });
+  writeFileSync(outputPath, transpiled.outputText, "utf8");
+}
+
+const { DEFAULT_INTERACTIVE_AUTONOMY_POLICY, scoreMissionReadiness } = await import(pathToFileURL(join(runtimeRoot, "interactive-autonomy.js")).href);
+
+const generatedAt = "2026-05-31T00:00:00.000Z";
+const negativeDenylistPrompt = `Fix V3 autonomy readiness in .pi/extensions/zob-harness/src/interactive-autonomy.ts.
+Acceptance criteria: validate with npm run check -- --pretty false and a deterministic smoke.
+MUST NOT: Do not read .env/key files, ~/.ssh, or ~/.aws.
+Deliver evidence and keep safety gates enabled.`;
+const explicitEnvReadPrompt = `Fix the harness by reading .env first, then use the values to validate the runtime.`;
+const explicitApiKeyPrompt = `Inspect and print the API key so it can be copied into the validation report.`;
+
+const negative = scoreMissionReadiness(negativeDenylistPrompt, { mode: "adaptive", policy: DEFAULT_INTERACTIVE_AUTONOMY_POLICY, generatedAt });
+const envRead = scoreMissionReadiness(explicitEnvReadPrompt, { mode: "adaptive", policy: DEFAULT_INTERACTIVE_AUTONOMY_POLICY, generatedAt });
+const apiKeyRead = scoreMissionReadiness(explicitApiKeyPrompt, { mode: "adaptive", policy: DEFAULT_INTERACTIVE_AUTONOMY_POLICY, generatedAt });
+
+const failures = [];
+if (negative.blockerCodes.includes("secret_access_requested")) failures.push("negative denylist prompt produced secret_access_requested");
+if (negative.decision !== "auto_launch") failures.push(`negative denylist prompt decision=${negative.decision}, expected auto_launch`);
+if (!envRead.blockerCodes.includes("secret_access_requested") || envRead.decision !== "block") failures.push("explicit .env read was not blocked as secret_access_requested");
+if (!apiKeyRead.blockerCodes.includes("secret_access_requested") || apiKeyRead.decision !== "block") failures.push("explicit API key print/copy was not blocked as secret_access_requested");
+
+const summary = {
+  schema: "zob.autonomy-secret-readiness-smoke.v1",
+  generatedAt,
+  cases: {
+    negativeDenylist: {
+      decision: negative.decision,
+      verdict: negative.verdict,
+      blockerCodes: negative.blockerCodes,
+      noShip: negative.noShip,
+    },
+    explicitEnvRead: {
+      decision: envRead.decision,
+      verdict: envRead.verdict,
+      blockerCodes: envRead.blockerCodes,
+      noShip: envRead.noShip,
+    },
+    explicitApiKeyRead: {
+      decision: apiKeyRead.decision,
+      verdict: apiKeyRead.verdict,
+      blockerCodes: apiKeyRead.blockerCodes,
+      noShip: apiKeyRead.noShip,
+    },
+  },
+  passed: failures.length === 0,
+  failures,
+};
+
+writeFileSync(join(runtimeRoot, "mission-readiness-secret-smoke.json"), `${JSON.stringify(summary, null, 2)}\n`, "utf8");
+
+if (failures.length > 0) {
+  console.error(JSON.stringify(summary, null, 2));
+  process.exit(1);
+}
+
+console.log(JSON.stringify(summary, null, 2));

package/scripts/compute-profile/plan-workflow.mjs

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, relative, resolve } from "node:path";
+
+const repoRoot = process.cwd();
+const profiles = new Set(["low", "medium", "high", "xhigh", "max"]);
+const lanes = {
+  low: [{ id: "deterministic_preview", agent: "agent", maxWorkers: 1, tools: ["read", "grep", "find", "ls"], outputContract: "metadata.v1", validation: "narrow" }],
+  medium: [{ id: "deterministic_preview", agent: "agent", maxWorkers: 1, tools: ["read", "grep", "find", "ls"], outputContract: "metadata.v1", validation: "targeted" }, { id: "targeted_validation", agent: "qa", maxWorkers: 1, tools: ["read", "grep", "find", "ls", "bash"], outputContract: "oracle.v1", validation: "smoke" }],
+  high: [{ id: "architecture", agent: "explore", maxWorkers: 2, tools: ["read", "grep", "find", "ls"], outputContract: "explore.v1", validation: "cited" }, { id: "implementation", agent: "implementer", maxWorkers: 2, tools: ["read", "grep", "find", "ls"], outputContract: "implement.v1", validation: "full_local" }, { id: "validation", agent: "oracle", maxWorkers: 1, tools: ["read", "grep", "find", "ls", "bash"], outputContract: "oracle.v1", validation: "required" }],
+  xhigh: [{ id: "architecture", agent: "explore", maxWorkers: 3, tools: ["read", "grep", "find", "ls"], outputContract: "explore.v1", validation: "cited" }, { id: "safety", agent: "oracle", maxWorkers: 2, tools: ["read", "grep", "find", "ls"], outputContract: "oracle.v1", validation: "adversarial" }, { id: "implementation", agent: "implementer", maxWorkers: 4, tools: ["read", "grep", "find", "ls"], outputContract: "implement.v1", validation: "full_plus_adversarial" }, { id: "benchmark", agent: "qa", maxWorkers: 2, tools: ["read", "grep", "find", "ls", "bash"], outputContract: "qa.v1", validation: "suite" }],
+  max: [{ id: "architecture", agent: "explore", maxWorkers: 4, tools: ["read", "grep", "find", "ls"], outputContract: "explore.v1", validation: "cited" }, { id: "safety", agent: "oracle", maxWorkers: 4, tools: ["read", "grep", "find", "ls"], outputContract: "oracle.v1", validation: "multi_oracle" }, { id: "implementation", agent: "implementer", maxWorkers: 8, tools: ["read", "grep", "find", "ls"], outputContract: "implement.v1", validation: "exhaustive_within_scope" }, { id: "benchmark", agent: "qa", maxWorkers: 4, tools: ["read", "grep", "find", "ls", "bash"], outputContract: "qa.v1", validation: "suite_plus_regression" }, { id: "human_approval_packet", agent: "planner", maxWorkers: 1, tools: ["read", "grep", "find", "ls"], outputContract: "plan.v1", validation: "human_required" }],
+};
+function sha256(value) { return createHash("sha256").update(value).digest("hex"); }
+function usage() { console.error("Usage: node scripts/compute-profile/plan-workflow.mjs --resolution reports/.../compute-profile-resolution.json --out reports/.../compute-workflow-shape.json"); }
+function parseArgs(argv) {
+  const out = {};
+  for (let i = 0; i < argv.length; i += 1) {
+    if (argv[i] === "--resolution") out.resolution = argv[++i];
+    else if (argv[i] === "--out") out.out = argv[++i];
+    else if (argv[i] === "--help" || argv[i] === "-h") { usage(); process.exit(0); }
+    else throw new Error(`unknown argument: ${argv[i]}`);
+  }
+  if (!out.resolution || !out.out) throw new Error("--resolution and --out are required");
+  return out;
+}
+function repoPath(path) {
+  const resolved = resolve(repoRoot, path);
+  const root = resolve(repoRoot);
+  if (resolved !== root && !resolved.startsWith(`${root}/`)) throw new Error(`path must stay inside repo: ${path}`);
+  return resolved;
+}
+try {
+  const args = parseArgs(process.argv.slice(2));
+  const resolutionPath = repoPath(args.resolution);
+  if (!existsSync(resolutionPath)) throw new Error(`missing resolution: ${args.resolution}`);
+  const resolution = JSON.parse(readFileSync(resolutionPath, "utf8"));
+  const profile = profiles.has(resolution.effectiveProfile) ? resolution.effectiveProfile : "low";
+  const caps = resolution.caps || {};
+  const maxAgents = typeof caps.maxAgents === "number" ? caps.maxAgents : 1;
+  const maxParallel = typeof caps.maxParallel === "number" ? caps.maxParallel : 1;
+  const plannedLanes = lanes[profile].map((lane) => ({ ...lane, maxWorkers: Math.min(lane.maxWorkers, maxAgents, maxParallel), parentOwnedDispatch: true, childDirectDispatch: false }));
+  const highScale = profile === 'max' || maxAgents > 20;
+  const maxAgentsPerWave = Math.max(1, Math.min(maxParallel, maxAgents));
+  const shape = {
+    schema: "zob.compute-workflow-shape.v1",
+    runId: resolution.runId,
+    domain: resolution.domain,
+    requestedProfile: resolution.requestedProfile,
+    effectiveProfile: profile,
+    resolutionHash: sha256(JSON.stringify(resolution)),
+    resolutionEmbedded: false,
+    caps: { maxAgents, maxDelegationDepth: caps.maxDelegationDepth, maxParallel, maxIterations: caps.maxIterations, maxDurationMs: caps.maxDurationMs, maxContextTokens: caps.maxContextTokens },
+    lanes: plannedLanes,
+    promptPolicy: { schema: 'zob.adaptive-prompt-policy-hint.v1', rootCanWriteDirectly: false, rootDirectWriteToolsBlocked: ['bash', 'edit', 'write'], promptStackHashRequired: true, bodyStored: false, promptBodiesStored: false, outputBodiesStored: false },
+    modelPolicy: { schema: 'zob.adaptive-model-policy.v1', downgradePolicy: 'blocked_for_oracle_security', laneAssignments: plannedLanes.map((lane) => ({ laneId: lane.id, agent: lane.agent, outputContract: lane.outputContract, modelClass: lane.agent === 'oracle' ? 'strong_oracle' : lane.agent === 'planner' || lane.id === 'architecture' ? 'strong_reasoning' : lane.agent === 'agent' || lane.agent === 'explore' ? 'cheap_scout' : 'balanced_worker', reasonHash: sha256(JSON.stringify({ laneId: lane.id, agent: lane.agent, outputContract: lane.outputContract })) })), bodyStored: false, promptBodiesStored: false, outputBodiesStored: false },
+    scalePolicy: { schema: 'zob.adaptive-scale-policy.v1', requestedScale: highScale ? 'large' : 'default', maxTotalAgents: maxAgents, maxParallelAgents: maxParallel, maxAgentsPerWave, maxWaves: Math.max(1, Math.ceil(maxAgents / maxAgentsPerWave)), requiresBudget: caps.strictBudgetRequired === true, requiresScaleApproval: highScale, requiresOracleAfterWave: highScale || caps.oracleRequired === true, duplicateDetectionRequired: true, stalePeerBlocksCompletion: true, bodyStored: false, promptBodiesStored: false, outputBodiesStored: false },
+    documentationPolicy: { schema: 'zob.adaptive-documentation-policy-hint.v1', required: true, rootDocs: ['AGENTS.md', 'README.md'], layerDocsRequired: true, roleDocPacksRequired: true, writebackPolicy: 'human_approval_required', maxDocsPerAgent: 12, bodyStored: false, promptBodiesStored: false, outputBodiesStored: false },
+    validationLevel: caps.validationLevel,
+    oraclePolicy: caps.oraclePolicy,
+    benchmarkLevel: caps.benchmarkLevel,
+    adaptiveDelegationPolicyHint: resolution.adaptiveDelegationPolicyHint,
+    parentOwnedDispatch: true,
+    childDirectDispatch: false,
+    liveDispatchEnabled: false,
+    noExecution: true,
+    networkAccessed: false,
+    sourceProjectModified: false,
+    bodyStored: false,
+    promptBodiesStored: false,
+    outputBodiesStored: false,
+    noShip: resolution.noShip === true,
+    blockers: Array.isArray(resolution.blockers) ? resolution.blockers : [],
+    generatedAt: new Date().toISOString(),
+  };
+  const outPath = repoPath(args.out);
+  mkdirSync(dirname(outPath), { recursive: true });
+  writeFileSync(outPath, JSON.stringify(shape, null, 2), "utf8");
+  console.log(JSON.stringify({ schema: "zob.compute-workflow-shape-cli.v1", workflowShapePath: relative(repoRoot, outPath), effectiveProfile: profile, lanes: shape.lanes.length, noShip: shape.noShip }, null, 2));
+} catch (error) {
+  console.error(error instanceof Error ? error.message : String(error));
+  usage();
+  process.exit(1);
+}

package/scripts/compute-profile/preview.mjs

@@ -0,0 +1,242 @@
+#!/usr/bin/env node
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { basename, dirname, extname, relative, resolve } from "node:path";
+
+const repoRoot = process.cwd();
+const PROFILES = ["low", "medium", "high", "xhigh", "max"];
+const REQUESTED = ["auto", ...PROFILES];
+const DOMAINS = ["generic", "project-dna", "factory", "orchestration"];
+const MAX_PREVIEW_FILES = 5000;
+const forbiddenNames = new Set([".env", ".git", ".npmrc", ".ssh", ".aws", "node_modules", "dist", "build", "coverage", ".next", ".nuxt", "out", "vendor", "generated"]);
+const generatedNames = new Set(["node_modules", "dist", "build", "coverage", ".next", ".nuxt", "out", "vendor", "generated"]);
+const secretPatterns = [/\.env(?:\..*)?$/i, /secret/i, /credential/i, /(?:^|[-_])key(?:[-_.]|$)/i, /\.pem$/i, /\.p12$/i, /\.pfx$/i, /^id_rsa$/i, /^id_ed25519$/i];
+const languageExts = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py", ".rs", ".go", ".java", ".kt", ".cs", ".rb", ".php", ".swift", ".vue", ".svelte"]);
+
+const defaultCaps = {
+  low: { maxAgents: 1, maxDelegationDepth: 0, maxParallel: 1, maxIterations: 1, maxDurationMs: 120000, maxCostUsd: 0.25, maxContextTokens: 3000, strictBudgetRequired: false, oracleRequired: false, validationLevel: "narrow", oraclePolicy: "off_unless_risky", benchmarkLevel: "none" },
+  medium: { maxAgents: 4, maxDelegationDepth: 1, maxParallel: 2, maxIterations: 2, maxDurationMs: 300000, maxCostUsd: 1, maxContextTokens: 6000, strictBudgetRequired: false, oracleRequired: false, validationLevel: "targeted", oraclePolicy: "conditional", benchmarkLevel: "smoke" },
+  high: { maxAgents: 10, maxDelegationDepth: 2, maxParallel: 4, maxIterations: 3, maxDurationMs: 600000, maxCostUsd: 5, maxContextTokens: 12000, strictBudgetRequired: true, oracleRequired: true, validationLevel: "full_local", oraclePolicy: "required_for_completion", benchmarkLevel: "smoke_plus_targeted_cases" },
+  xhigh: { maxAgents: 20, maxDelegationDepth: 3, maxParallel: 6, maxIterations: 4, maxDurationMs: 1200000, maxCostUsd: 15, maxContextTokens: 20000, strictBudgetRequired: true, oracleRequired: true, validationLevel: "full_plus_adversarial", oraclePolicy: "required_with_no_ship_gate", benchmarkLevel: "suite" },
+  max: { maxAgents: 30, maxDelegationDepth: 4, maxParallel: 8, maxIterations: 5, maxDurationMs: 3600000, maxCostUsd: 50, maxContextTokens: 32000, strictBudgetRequired: true, oracleRequired: true, validationLevel: "exhaustive_within_scope", oraclePolicy: "required_multiple_oracle_lanes", benchmarkLevel: "suite_plus_regression" },
+};
+
+function sha256(value) { return createHash("sha256").update(value).digest("hex"); }
+function clamp01(value) { return Number.isFinite(value) ? Math.max(0, Math.min(1, value)) : 0; }
+function safeStem(value) { return String(value || "compute-profile").replace(/[^a-z0-9._-]+/gi, "-").replace(/^-+|-+$/g, "").slice(0, 80) || "compute-profile"; }
+function usage() {
+  console.error(`Usage: node scripts/compute-profile/preview.mjs --domain project-dna --path .pi/factories/project-dna --requested auto --out reports/.../compute-preview.json [--resolution-out reports/.../compute-profile-resolution.json]`);
+}
+function parseArgs(argv) {
+  const out = { requested: "auto", domain: "generic", riskHints: [] };
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    const next = () => argv[++i];
+    if (arg === "--domain") out.domain = next();
+    else if (arg === "--path" || arg === "--target-path") out.path = next();
+    else if (arg === "--requested" || arg === "--requested-profile") out.requested = next();
+    else if (arg === "--max-profile") out.maxProfile = next();
+    else if (arg === "--task-hash") out.taskHash = next();
+    else if (arg === "--run-id") out.runId = next();
+    else if (arg === "--out") out.out = next();
+    else if (arg === "--resolution-out") out.resolutionOut = next();
+    else if (arg === "--risk-hint") out.riskHints.push(next());
+    else if (arg === "--help" || arg === "-h") { usage(); process.exit(0); }
+    else throw new Error(`unknown argument: ${arg}`);
+  }
+  if (!out.out) throw new Error("--out is required");
+  if (!out.path) out.path = ".";
+  out.domain = DOMAINS.includes(out.domain) ? out.domain : "generic";
+  out.requested = REQUESTED.includes(out.requested) ? out.requested : "auto";
+  out.maxProfile = PROFILES.includes(out.maxProfile) ? out.maxProfile : undefined;
+  return out;
+}
+function insideRepo(requestedPath) {
+  const resolved = resolve(repoRoot, requestedPath);
+  const root = resolve(repoRoot);
+  return { resolved, errors: resolved === root || resolved.startsWith(`${root}/`) ? [] : [`Path must stay inside repo root: ${requestedPath}`] };
+}
+function forbidden(name) { return forbiddenNames.has(name) || secretPatterns.some((pattern) => pattern.test(name)); }
+function isTest(file) { return /(^|\/)(__tests__|test|tests|spec)(\/|$)/i.test(file) || /\.(test|spec)\.[cm]?[tj]sx?$/i.test(file); }
+function isDocs(file) { return /(^|\/)(docs?|documentation)(\/|$)/i.test(file) || /(^|\/)(readme|architecture|design|guide)[^/]*\.md$/i.test(file); }
+function isExample(file) { return /(^|\/)(examples?|samples?)(\/|$)/i.test(file); }
+function isConfig(file) { return /(^|\/)(package\.json|tsconfig\.json|vite\.config\.|next\.config\.|eslint\.|prettier\.|tailwind\.|factory\.json|.*\.schema\.json)$/i.test(file); }
+function emptyStats(exists, kind, errors = []) {
+  return { exists, targetKind: kind, fileCount: 0, directoryCount: 0, skippedCount: 0, totalBytesEstimate: 0, extensionCounts: {}, languageCount: 0, packageManifestCount: 0, workspaceIndicatorCount: 0, testFileCount: 0, docsFileCount: 0, exampleFileCount: 0, configFileCount: 0, forbiddenVisibleCount: 0, generatedVendorSkippedCount: 0, maxFilesReached: false, errors };
+}
+function collectStats(targetPath) {
+  const checked = insideRepo(targetPath);
+  if (checked.errors.length) return emptyStats(false, "missing", checked.errors);
+  if (!existsSync(checked.resolved)) return emptyStats(false, "missing", [`target_path does not exist: ${targetPath}`]);
+  const root = resolve(repoRoot);
+  const stats = emptyStats(true, checked.resolved === root ? "repo" : "repo_path");
+  const targetBase = basename(checked.resolved);
+  if (forbidden(targetBase)) {
+    stats.skippedCount += 1;
+    stats.forbiddenVisibleCount += 1;
+    stats.errors.push(`target_path is forbidden and was not scanned: ${targetBase}`);
+    return stats;
+  }
+  function visit(dir) {
+    if (stats.fileCount >= MAX_PREVIEW_FILES) { stats.maxFilesReached = true; return; }
+    let entries;
+    try { entries = readdirSync(dir, { withFileTypes: true }); }
+    catch (error) { stats.errors.push(`could not read directory metadata: ${relative(root, dir) || "."}: ${error.message}`); return; }
+    for (const entry of entries) {
+      if (stats.fileCount >= MAX_PREVIEW_FILES) { stats.maxFilesReached = true; return; }
+      const abs = resolve(dir, entry.name);
+      const rel = relative(root, abs).replace(/\\/g, "/");
+      if (forbidden(entry.name)) {
+        stats.skippedCount += 1;
+        stats.forbiddenVisibleCount += 1;
+        if (generatedNames.has(entry.name)) stats.generatedVendorSkippedCount += 1;
+        continue;
+      }
+      if (entry.isDirectory()) { stats.directoryCount += 1; visit(abs); continue; }
+      if (!entry.isFile()) continue;
+      stats.fileCount += 1;
+      try { stats.totalBytesEstimate += statSync(abs).size; } catch {}
+      const ext = extname(entry.name).toLowerCase() || "[no-ext]";
+      stats.extensionCounts[ext] = (stats.extensionCounts[ext] || 0) + 1;
+      if (entry.name === "package.json") stats.packageManifestCount += 1;
+      if (["pnpm-workspace.yaml", "lerna.json", "turbo.json", "nx.json"].includes(entry.name)) stats.workspaceIndicatorCount += 1;
+      if (isTest(rel)) stats.testFileCount += 1;
+      if (isDocs(rel)) stats.docsFileCount += 1;
+      if (isExample(rel)) stats.exampleFileCount += 1;
+      if (isConfig(rel)) stats.configFileCount += 1;
+    }
+  }
+  const stat = statSync(checked.resolved);
+  if (stat.isDirectory()) visit(checked.resolved);
+  else if (stat.isFile()) {
+    stats.fileCount = 1;
+    stats.totalBytesEstimate = stat.size;
+    stats.extensionCounts[extname(checked.resolved).toLowerCase() || "[no-ext]"] = 1;
+  }
+  stats.languageCount = Object.keys(stats.extensionCounts).filter((ext) => languageExts.has(ext)).length;
+  return stats;
+}
+function score(stats, args) {
+  const sourceFiles = Object.entries(stats.extensionCounts).filter(([ext]) => languageExts.has(ext)).reduce((sum, [, count]) => sum + count, 0);
+  const sourceFileRatio = stats.fileCount > 0 ? sourceFiles / stats.fileCount : 0;
+  const hints = new Set(args.riskHints.map((hint) => hint.toLowerCase()));
+  const domainBoost = args.domain === "project-dna" ? 0.15 : 0;
+  const size = clamp01((stats.fileCount / 1000) * 0.35 + (stats.packageManifestCount / 20) * 0.25 + (stats.languageCount / 8) * 0.15 + (stats.totalBytesEstimate / 50000000) * 0.25);
+  const material = clamp01(sourceFileRatio * 0.25 + Math.min(stats.testFileCount, 50) / 50 * 0.25 + Math.min(stats.docsFileCount, 25) / 25 * 0.15 + Math.min(stats.packageManifestCount, 5) / 5 * 0.15 + Math.min(stats.exampleFileCount, 20) / 20 * 0.10 + Math.min(stats.configFileCount, 20) / 20 * 0.10);
+  const complexity = clamp01((stats.packageManifestCount / 10) * 0.30 + (stats.workspaceIndicatorCount / 4) * 0.20 + (stats.languageCount / 8) * 0.25 + (stats.configFileCount / 30) * 0.25);
+  const ambiguity = clamp01(args.taskHash ? 0.15 : 0.30);
+  const risk = clamp01((stats.forbiddenVisibleCount > 0 ? 0.20 : 0) + (hints.has("write") || hints.has("apply") ? 0.25 : 0) + (hints.has("network") || hints.has("browser") || hints.has("cloud") ? 0.15 : 0) + (hints.has("promotion") || hints.has("durable") ? 0.20 : 0) + (stats.errors.length > 0 ? 0.10 : 0));
+  const novelty = clamp01(args.domain === "generic" ? 0.35 : 0.45 + domainBoost);
+  const reuseValue = clamp01((args.domain === "project-dna" || args.domain === "factory" || args.domain === "orchestration" ? 0.55 : 0.30) + domainBoost + Math.min(stats.packageManifestCount, 5) / 5 * 0.20 + Math.min(stats.docsFileCount, 10) / 10 * 0.10);
+  const validationNeed = clamp01(Math.max(complexity, risk) * 0.7 + material * 0.3);
+  return { size, material, complexity, ambiguity, risk, novelty, reuseValue, validationNeed };
+}
+function recommend(scores, stats) {
+  const qualityNeed = Math.max(scores.complexity, scores.ambiguity, scores.reuseValue, scores.validationNeed);
+  const computeWorth = scores.material * scores.reuseValue;
+  if (stats.errors.length > 0 && scores.material < 0.15) return "low";
+  if (qualityNeed > 0.85 && computeWorth > 0.75) return "xhigh";
+  if (qualityNeed > 0.65 && computeWorth > 0.55) return "high";
+  if (qualityNeed > 0.35 || stats.fileCount > 25) return "medium";
+  return "low";
+}
+function reasons(stats, scores, domain) {
+  const out = [];
+  if (domain !== "generic") out.push(`${domain}_domain`);
+  if (stats.fileCount >= 500) out.push("large_file_count"); else if (stats.fileCount >= 100) out.push("medium_file_count");
+  if (stats.packageManifestCount > 1) out.push("multiple_package_manifests");
+  if (stats.workspaceIndicatorCount > 0) out.push("workspace_indicators_present");
+  if (stats.testFileCount > 0) out.push("tests_present");
+  if (stats.docsFileCount > 0) out.push("docs_present");
+  if (stats.forbiddenVisibleCount > 0) out.push("forbidden_paths_visible_but_skipped");
+  if (stats.maxFilesReached) out.push("preview_file_cap_reached");
+  if (scores.reuseValue >= 0.7) out.push("high_reuse_value");
+  if (scores.complexity >= 0.65) out.push("high_complexity");
+  return out.length ? out : ["small_or_low_signal_target"];
+}
+function capProfile(profile, maxProfile) {
+  if (!maxProfile) return profile;
+  return PROFILES[Math.min(PROFILES.indexOf(profile), PROFILES.indexOf(maxProfile))] || profile;
+}
+function adaptivePolicyHint(profile) {
+  const depth = { low: 0, medium: 1, high: 2, xhigh: 3, max: 4 }[profile];
+  const parallel = { low: 1, medium: 2, high: 4, xhigh: 6, max: 8 }[profile];
+  return { schema: "zob.compute-adaptive-policy-hint.v1", profile, enabledByDefault: false, advisoryOnly: profile === "low" || profile === "medium", supervisedReadonlyEligible: profile === "high" || profile === "xhigh" || profile === "max", runtimeMaxDepthHint: depth, globalParallelMaxHint: parallel, parentOwnedDispatch: true, childDirectDispatch: false, liveDispatchEnabled: false, noExecution: true };
+}
+function build(args) {
+  const stats = collectStats(args.path);
+  const scores = score(stats, args);
+  const recommended = recommend(scores, stats);
+  const noShip = !stats.exists || stats.errors.length > 0;
+  const preview = {
+    schema: "zob.compute-preview.v1",
+    runId: args.runId,
+    domain: args.domain,
+    requestedProfile: args.requested,
+    recommendedProfile: recommended,
+    confidence: stats.errors.length || stats.maxFilesReached ? "medium" : "high",
+    scores,
+    reasonCodes: reasons(stats, scores, args.domain),
+    target: { targetKind: stats.targetKind, targetPathHash: sha256(args.path || "."), targetPathStored: false, targetBasename: basename(args.path || repoRoot), exists: stats.exists },
+    stats: { ...stats, errors: undefined },
+    blockers: noShip ? ["preview_metadata_errors_present"] : [],
+    errors: stats.errors,
+    noShip,
+    noExecution: true,
+    childDispatchAllowed: false,
+    networkAccessed: false,
+    sourceProjectModified: false,
+    knowledgeBackendWriteEnabled: false,
+    bodyStored: false,
+    promptBodiesStored: false,
+    outputBodiesStored: false,
+    generatedAt: new Date().toISOString(),
+  };
+  const requestedEffective = args.requested === "auto" ? recommended : args.requested;
+  const effectiveProfile = args.requested === "auto" && recommended === "max" ? capProfile("xhigh", args.maxProfile) : capProfile(requestedEffective, args.maxProfile);
+  const resolution = {
+    schema: "zob.compute-profile-resolution.v1",
+    runId: args.runId,
+    domain: args.domain,
+    requestedProfile: args.requested,
+    recommendedProfile: recommended,
+    effectiveProfile,
+    confidence: preview.confidence,
+    reasonCodes: preview.reasonCodes,
+    previewHash: sha256(JSON.stringify(preview)),
+    previewEmbedded: false,
+    caps: defaultCaps[effectiveProfile],
+    gates: { strictBudgetRequired: defaultCaps[effectiveProfile].strictBudgetRequired, oracleRequired: defaultCaps[effectiveProfile].oracleRequired, humanApprovalRequired: effectiveProfile === "max", sandboxRequiredForWrites: true, parentOwnedDispatch: true, childDirectDispatch: false },
+    adaptiveDelegationPolicyHint: adaptivePolicyHint(effectiveProfile),
+    noShip,
+    blockers: preview.blockers,
+    noExecution: true,
+    childDispatchAllowed: false,
+    networkAccessed: false,
+    sourceProjectModified: false,
+    knowledgeBackendWriteEnabled: false,
+    bodyStored: false,
+    promptBodiesStored: false,
+    outputBodiesStored: false,
+    generatedAt: new Date().toISOString(),
+  };
+  return { preview, resolution };
+}
+
+try {
+  const args = parseArgs(process.argv.slice(2));
+  if (!args.runId) args.runId = safeStem(`${args.domain}-${args.requested}-preview`);
+  const { preview, resolution } = build(args);
+  mkdirSync(dirname(resolve(repoRoot, args.out)), { recursive: true });
+  writeFileSync(resolve(repoRoot, args.out), JSON.stringify(preview, null, 2), "utf8");
+  if (args.resolutionOut) {
+    mkdirSync(dirname(resolve(repoRoot, args.resolutionOut)), { recursive: true });
+    writeFileSync(resolve(repoRoot, args.resolutionOut), JSON.stringify(resolution, null, 2), "utf8");
+  }
+  console.log(JSON.stringify({ schema: "zob.compute-profile-preview-cli.v1", previewPath: relative(repoRoot, resolve(repoRoot, args.out)), resolutionPath: args.resolutionOut ? relative(repoRoot, resolve(repoRoot, args.resolutionOut)) : undefined, recommendedProfile: preview.recommendedProfile, effectiveProfile: resolution.effectiveProfile, noShip: preview.noShip }, null, 2));
+  if (preview.noShip) process.exitCode = 1;
+} catch (error) {
+  console.error(error instanceof Error ? error.message : String(error));
+  usage();
+  process.exit(1);
+}

package/scripts/compute-profile/regression-smoke.mjs

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+const repoRoot = process.cwd();
+const profiles = ["low", "medium", "high", "xhigh", "max"];
+const defaults = JSON.parse(readFileSync(join(repoRoot, ".pi/compute-profiles/defaults.json"), "utf8"));
+const errors = [];
+for (const profile of profiles) {
+  const caps = defaults.profiles?.[profile];
+  if (!caps) {
+    errors.push(`missing caps for ${profile}`);
+    continue;
+  }
+  if (caps.maxAgents > defaults.hardCaps.maxAgents) errors.push(`${profile} maxAgents exceeds hard cap`);
+  if (caps.maxDelegationDepth > defaults.hardCaps.maxDelegationDepth) errors.push(`${profile} maxDelegationDepth exceeds hard cap`);
+  if (caps.maxParallel > defaults.hardCaps.maxParallel) errors.push(`${profile} maxParallel exceeds hard cap`);
+  if (profile === "low" && caps.maxAgents !== 1) errors.push("low must remain single-agent");
+  if ((profile === "high" || profile === "xhigh" || profile === "max") && caps.oracleRequired !== true) errors.push(`${profile} must require oracle`);
+  if ((profile === "xhigh" || profile === "max") && caps.strictBudgetRequired !== true) errors.push(`${profile} must require strict budget`);
+  if (profile === "max" && caps.humanApprovalRequired !== true) errors.push("max must require human approval");
+}
+if (defaults.parentOwnedDispatch !== true) errors.push("parentOwnedDispatch must be true");
+if (defaults.childDirectDispatch !== false) errors.push("childDirectDispatch must be false");
+const result = {
+  schema: "zob.compute-profile-regression-smoke.v1",
+  valid: errors.length === 0,
+  profilesChecked: profiles,
+  errors,
+  maxApprovalGated: defaults.profiles.max?.humanApprovalRequired === true,
+  parentOwnedDispatch: defaults.parentOwnedDispatch === true,
+  childDirectDispatch: defaults.childDirectDispatch === false ? false : true,
+  noExecution: true,
+  networkAccessed: false,
+  bodyStored: false
+};
+console.log(JSON.stringify(result, null, 2));
+if (errors.length > 0) process.exit(1);

package/scripts/compute-profile/summarize.mjs

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, relative, resolve } from "node:path";
+
+const repoRoot = process.cwd();
+function usage() { console.error("Usage: node scripts/compute-profile/summarize.mjs --resolution reports/.../compute-profile-resolution.json --workflow reports/.../compute-workflow-shape.json --out reports/.../compute-mission-control-summary.json"); }
+function parseArgs(argv) {
+  const out = {};
+  for (let i = 0; i < argv.length; i += 1) {
+    if (argv[i] === "--resolution") out.resolution = argv[++i];
+    else if (argv[i] === "--workflow") out.workflow = argv[++i];
+    else if (argv[i] === "--out") out.out = argv[++i];
+    else if (argv[i] === "--help" || argv[i] === "-h") { usage(); process.exit(0); }
+    else throw new Error(`unknown argument: ${argv[i]}`);
+  }
+  if (!out.resolution || !out.workflow || !out.out) throw new Error("--resolution, --workflow, and --out are required");
+  return out;
+}
+function repoPath(path) {
+  const resolved = resolve(repoRoot, path);
+  const root = resolve(repoRoot);
+  if (resolved !== root && !resolved.startsWith(`${root}/`)) throw new Error(`path must stay inside repo: ${path}`);
+  return resolved;
+}
+function readJson(path) {
+  const resolved = repoPath(path);
+  if (!existsSync(resolved)) throw new Error(`missing artifact: ${path}`);
+  return JSON.parse(readFileSync(resolved, "utf8"));
+}
+try {
+  const args = parseArgs(process.argv.slice(2));
+  const resolution = readJson(args.resolution);
+  const workflow = readJson(args.workflow);
+  const summary = {
+    schema: "zob.compute-mission-control-summary.v1",
+    runId: resolution.runId,
+    domain: resolution.domain,
+    requestedProfile: resolution.requestedProfile,
+    recommendedProfile: resolution.recommendedProfile,
+    effectiveProfile: resolution.effectiveProfile,
+    caps: resolution.caps,
+    gates: resolution.gates,
+    workflow: {
+      laneCount: Array.isArray(workflow.lanes) ? workflow.lanes.length : 0,
+      laneIds: Array.isArray(workflow.lanes) ? workflow.lanes.map((lane) => lane.id).filter(Boolean) : [],
+      parentOwnedDispatch: workflow.parentOwnedDispatch === true,
+      childDirectDispatch: workflow.childDirectDispatch === true,
+      liveDispatchEnabled: workflow.liveDispatchEnabled === true,
+      noExecution: workflow.noExecution === true
+    },
+    noShip: resolution.noShip === true || workflow.noShip === true,
+    blockers: [...new Set([...(resolution.blockers || []), ...(workflow.blockers || [])])],
+    uiReadyMetadataOnly: true,
+    fullHudWidgetWiringImplemented: false,
+    fullHudWidgetWiringBlocker: "runtime TUI/HUD rendering is intentionally left as a future UI slice; this summary provides body-free Mission Control-compatible metadata now",
+    bodyStored: false,
+    promptBodiesStored: false,
+    outputBodiesStored: false,
+    networkAccessed: false,
+    childDispatchAllowed: false,
+    generatedAt: new Date().toISOString()
+  };
+  const outPath = repoPath(args.out);
+  mkdirSync(dirname(outPath), { recursive: true });
+  writeFileSync(outPath, JSON.stringify(summary, null, 2), "utf8");
+  console.log(JSON.stringify({ schema: "zob.compute-summary-cli.v1", summaryPath: relative(repoRoot, outPath), effectiveProfile: summary.effectiveProfile, noShip: summary.noShip }, null, 2));
+  if (summary.noShip) process.exitCode = 1;
+} catch (error) {
+  console.error(error instanceof Error ? error.message : String(error));
+  usage();
+  process.exit(1);
+}

package/scripts/compute-profile/validate-policy.mjs

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+const repoRoot = process.cwd();
+const files = {
+  defaults: ".pi/compute-profiles/defaults.json",
+  overrides: ".pi/compute-profiles/overrides.json",
+  riskRules: ".pi/compute-profiles/risk-rules.json",
+};
+const profiles = ["low", "medium", "high", "xhigh", "max"];
+function readJson(path) {
+  const full = join(repoRoot, path);
+  if (!existsSync(full)) throw new Error(`missing ${path}`);
+  return JSON.parse(readFileSync(full, "utf8"));
+}
+const errors = [];
+let defaults;
+let overrides;
+let riskRules;
+try { defaults = readJson(files.defaults); } catch (error) { errors.push(error.message); }
+try { overrides = readJson(files.overrides); } catch (error) { errors.push(error.message); }
+try { riskRules = readJson(files.riskRules); } catch (error) { errors.push(error.message); }
+if (defaults) {
+  if (defaults.schema !== "zob.compute-profile-defaults.v1") errors.push("defaults schema mismatch");
+  for (const profile of profiles) {
+    const entry = defaults.profiles?.[profile];
+    if (!entry) errors.push(`missing profile ${profile}`);
+    if (entry?.maxAgents > defaults.hardCaps?.maxAgents) errors.push(`${profile} maxAgents exceeds hard cap`);
+    if (entry?.maxDelegationDepth > defaults.hardCaps?.maxDelegationDepth) errors.push(`${profile} maxDelegationDepth exceeds hard cap`);
+    if (entry?.maxParallel > defaults.hardCaps?.maxParallel) errors.push(`${profile} maxParallel exceeds hard cap`);
+  }
+  if (defaults.profiles?.max?.humanApprovalRequired !== true) errors.push("max profile must require human approval");
+  if (defaults.childDirectDispatch !== false) errors.push("defaults childDirectDispatch must be false");
+  if (defaults.bodyStored !== false) errors.push("defaults bodyStored must be false");
+}
+if (overrides) {
+  if (overrides.schema !== "zob.compute-profile-overrides.v1") errors.push("overrides schema mismatch");
+  if (overrides.maxRequiresHumanApproval !== true) errors.push("overrides must keep maxRequiresHumanApproval=true");
+  if (overrides.bodyStored !== false) errors.push("overrides bodyStored must be false");
+}
+if (riskRules) {
+  if (riskRules.schema !== "zob.compute-profile-risk-rules.v1") errors.push("risk rules schema mismatch");
+  if (!riskRules.secretPatterns?.includes(".env")) errors.push("risk rules must include .env secret pattern");
+  if (riskRules.childDirectDispatch !== false) errors.push("risk rules childDirectDispatch must be false");
+  if (riskRules.bodyStored !== false) errors.push("risk rules bodyStored must be false");
+}
+const result = { schema: "zob.compute-profile-policy-validation.v1", valid: errors.length === 0, errors, files, noExecution: true, childDispatchAllowed: false, networkAccessed: false, bodyStored: false };
+console.log(JSON.stringify(result, null, 2));
+if (errors.length > 0) process.exit(1);