0sec-cli 0.24.1 → 0.26.0

package/chunks/{commands-FRPOFIO4.js → commands-C2WRSCNB.js}

@@ -1,100 +1,90 @@
 #!/usr/bin/env node
 import { createRequire as __0CreateRequire } from "node:module";
 const require = __0CreateRequire(import.meta.url);
+import {
+  registerDeepReviewCommand
+} from "./chunk-3VQ5EZKG.js";
 import {
   registerOrchestrateCommand
-} from "./chunk-SZDD77KX.js";
+} from "./chunk-NNMOTHKC.js";
 import {
   registerDbCommand
-} from "./chunk-RURJYCWY.js";
+} from "./chunk-WNWDQ2TO.js";
 import {
   discoverSshHosts,
   hashTeamPassword,
   registerDashboardCommand,
   registerWorkbenchCommand
-} from "./chunk-F2P25DJY.js";
-import {
-  registerVerifyCommand
-} from "./chunk-GZA7RGK7.js";
-import "./chunk-RVJVM5L4.js";
-import "./chunk-CJRZSWII.js";
-import {
-  registerLensSynthCommand
-} from "./chunk-VU7V2SDW.js";
-import "./chunk-W624J7NF.js";
+} from "./chunk-MOGWEHSC.js";
 import {
   buildFindingChatPrompt,
   buildFindingConsoleCommand,
   createLocalConsoleSession,
   loadFindingFocus,
+  localZeroverseRuntime,
+  registerVerifyCommand,
   resolveFindingChatIntent,
   runUnified
-} from "./chunk-2XGBEH53.js";
+} from "./chunk-UQS7XCBV.js";
+import "./chunk-Z2VLJEQJ.js";
+import "./chunk-K3PTYN43.js";
 import {
   TIMELINE_FORMATS,
   formatTimeline,
-  getRuntimeAvailability,
   isTimelineFormat,
   renderReplay
-} from "./chunk-I43YYHDU.js";
-import "./chunk-JWSOUKFF.js";
+} from "./chunk-FBZBJYZS.js";
+import {
+  registerRoutingCommand
+} from "./chunk-JGDA6EIJ.js";
 import {
   executeManagedOperation
-} from "./chunk-R2XBH476.js";
+} from "./chunk-MOEVVXML.js";
+import "./chunk-YJGPPPUB.js";
+import "./chunk-ZPVSDB63.js";
 import {
-  registerDeepReviewCommand
-} from "./chunk-GV5WXDHY.js";
-import "./chunk-2NBZZFRG.js";
+  getRuntimeAvailability
+} from "./chunk-MNK373HF.js";
+import "./chunk-KCABBZHN.js";
 import {
+  BackendConnectionError,
+  BackendConnectionRegistry,
+  backendBearerFromEnv,
   deployWorker,
+  loadBackendConnectionConfig,
+  repairWorker,
   stopWorker,
   validateWorkerOptions
-} from "./chunk-Q7JKIKKF.js";
-import {
-  performAutoUpdate
-} from "./chunk-7UHAXEOV.js";
-import {
-  Command,
-  InvalidArgumentError,
-  Option
-} from "./chunk-WUPN3D37.js";
+} from "./chunk-UGCTPKJG.js";
 import {
   consolePresentationOutput,
+  performAutoUpdate,
   processPresentationOutput,
   writePresentationLine
-} from "./chunk-OOMBOLAF.js";
-import "./chunk-56UTQKXO.js";
+} from "./chunk-D4M5WURF.js";
 import {
-  configureSettingsStore,
-  updateSetting
-} from "./chunk-LMP2T4G2.js";
+  Command,
+  InvalidArgumentError,
+  Option
+} from "./chunk-S4DFH2FJ.js";
+import "./chunk-A7G6S5RA.js";
+import "./chunk-OILVEROI.js";
 import {
   source_default
 } from "./chunk-HLFS6WV2.js";
 import {
-  DEFAULT_THEME_NAME,
+  DEFAULT_SETTINGS,
   SETTING_DEFS,
-  THEMES,
-  THEME_NAMES,
-  installedThemeEntries,
-  installedThemesDir,
-  isKnownTheme,
-  isSafeThemeId,
   loadGlobalSettings,
   loadLayeredSettings,
-  loadSettings,
   normalizeSettings,
   projectSettingsFilePath,
   readProjectOverrides,
-  reloadInstalledThemes,
-  removeInstalledTheme,
   sanitizeOverrides,
   saveProjectOverrides,
   saveSettings,
-  settingsFilePath,
-  validateTheme,
-  writeInstalledTheme
-} from "./chunk-X2IPO5JO.js";
+  settingsFilePath
+} from "./chunk-V2KJQVYE.js";
 import {
   CraftMemoryStore,
   DEFAULT_MAX_TOOL_ITERATIONS,
@@ -107,91 +97,48 @@ import {
   H1NetworkError,
   H1RateLimitError,
   McpServer,
-  ObjectiveOracle,
   ReadBuffer,
-  agentActionConfigurationChanges,
-  agentActionManifestSha256,
-  agenticScan,
-  appendLedgerEntry,
-  approveObservation,
   atlasTechniquesForEvent,
   automationVerdict,
-  captureObservation,
-  compareScorecards,
   consolidateMemory,
-  corpusV1Path,
-  createAgenticScanAdapter,
-  createBenchIntegrationRegistry,
   createConsoleRuntime,
-  createCoreBenchIntegration,
-  createVariantExecutionFactory,
   defaultCraftCandidateReviewer,
-  digestBenchManifest,
   enumerateTargetModelFromKext,
-  evaluateRegression,
-  formatTournamentSummary,
   generateInputsForSelector,
   generateSyzChoiceWeights,
   getProgram,
   getStructuredScopes,
-  httpActionOracle,
-  lastGreen,
-  listObservations,
+  inspectLensRegistry,
   listPrograms,
   listProjectReviewChecks,
   loadH1Credentials,
-  loadLedger,
-  loadManifest,
   makeRng,
-  mcpAgentTarget,
-  objectiveOracleEvaluatorAttestation,
-  objectiveOracleEvaluatorCodeBytes,
-  objectiveOracleEvaluatorConfigJson,
-  pairwiseDeltas,
-  parseApprovedObservationShape,
-  parseEnsembleModels,
-  parseManifest,
-  parseObservationInput,
-  pickChampion,
   planSingleShardRun,
   preseedMemory,
-  projectResearchExecutionEvidence,
-  projectResearchImprovementResult,
   radarCandidatesToSeedFindings,
-  releaseClaim,
-  renderScoreboard,
-  researchExecutionEvidenceRef,
-  runAgentActionAssurance,
-  runEnsembleCraft,
+  retireArchetype,
+  runLensSynthesisLoop,
   runSecureProject,
-  runTournament,
-  saveLedger,
   scan,
   scanRepoCommitsWithJev,
   selectorModelToLine,
   serializeMessage,
-  snapshotBenchVariant,
-  subsetManifest,
   summariseScopes,
   syzChoiceWeightsFromPlan,
   techniquesForEvent,
   toScopeFile,
-  updateProjectReviewChecks,
-  withVariantFeatureFlags,
-  writeAgentActionEvidenceBundle
-} from "./chunk-ZM6ANQZJ.js";
+  updateProjectReviewChecks
+} from "./chunk-3MWQNNJU.js";
 import {
   formatSarif
-} from "./chunk-H5QURBBK.js";
+} from "./chunk-YP2DHYNI.js";
 import {
   adaptAndVerify
-} from "./chunk-5NFIY2SJ.js";
+} from "./chunk-XJ2TBEV7.js";
 import {
-  RateLimiter,
-  enumerateJsChunkUrls,
-  parseRateLimitFlag
-} from "./chunk-BOBIAHKA.js";
-import "./chunk-ILRMLA6J.js";
+  enumerateJsChunkUrls
+} from "./chunk-STPHTPSD.js";
+import "./chunk-VWE36MUN.js";
 import {
   createLiveHttpSender
 } from "./chunk-GVD6SJGH.js";
@@ -203,8 +150,7 @@ import {
 import {
   getEvalCategories,
   runEval
-} from "./chunk-S2GITRD5.js";
-import "./chunk-IIBNQTOK.js";
+} from "./chunk-NABVDAAO.js";
 import {
   runNpmDynamicDiscovery
 } from "./chunk-2WNCI664.js";
@@ -216,74 +162,122 @@ import {
   DETECTOR_REGISTRY,
   resolveDetectors
 } from "./chunk-DQTNI3KY.js";
-import "./chunk-3WUPCZGF.js";
-import "./chunk-UJE4WOQS.js";
+import "./chunk-NA3FKCI2.js";
 import {
   prepare
-} from "./chunk-PJU24AKR.js";
-import "./chunk-6XMFCVJS.js";
-import "./chunk-AZ7L3HFD.js";
-import "./chunk-TVS6WVSK.js";
-import "./chunk-YSQWZ67M.js";
+} from "./chunk-HUZ2EC2R.js";
+import "./chunk-N7YCONYR.js";
+import "./chunk-BM6EYP2D.js";
 import {
+  ObjectiveOracle,
   ToolExecutor,
+  agentActionConfigurationChanges,
+  agentActionManifestSha256,
+  agenticScan,
   aggregateScorecard,
+  appendLedgerEntry,
   approveEvolutionCandidate,
+  approveObservation,
   bucketInScope,
+  captureObservation,
   classifyTakeover,
+  compareScorecards,
+  corpusV1Path,
+  createAgenticScanAdapter,
+  createBenchIntegrationRegistry,
+  createCoreBenchIntegration,
+  createVariantExecutionFactory,
   describeEngagementPosture,
+  digestBenchManifest,
+  evaluateRegression,
   executeEvolutionVersion,
   extractAttributionFromScopeJson,
   extractEngagementFromScopeJson,
   fetchScoped,
+  formatTournamentSummary,
   getToolsForRole,
+  harvestMissesFromLedgerEntry,
+  httpActionOracle,
+  lastGreen,
+  listObservations,
   loadEvolutionCampaign,
   loadEvolutionRegistry,
+  loadLedger,
+  loadManifest,
+  makeFinderLensProbe,
+  mcpAgentTarget,
+  mergeHarvestedMisses,
   networkScopeRequiredRefusal,
+  objectiveOracleEvaluatorAttestation,
+  objectiveOracleEvaluatorCodeBytes,
+  objectiveOracleEvaluatorConfigJson,
+  pairwiseDeltas,
+  parseApprovedObservationShape,
+  parseEnsembleModels,
+  parseManifest,
+  parseObservationInput,
+  pickChampion,
   probeS3Bucket,
+  projectResearchExecutionEvidence,
+  projectResearchImprovementResult,
   reconcileCampaignDispatch,
+  releaseClaim,
+  renderScoreboard,
+  researchExecutionEvidenceRef,
   resolveAttribution,
   resolveEngagementProfile,
   rollbackEvolutionVersion,
+  runAgentActionAssurance,
+  runEnsembleCraft,
   runEvolution,
   runJsRecon,
   runRecon,
   runSmolvmPocSteps,
+  runTournament,
+  saveLedger,
+  snapshotBenchVariant,
+  subsetManifest,
   targetRequiresScope,
   validateAwsCredentials,
-  workflowPolicyRuntime
-} from "./chunk-5WAHHZBF.js";
-import "./chunk-3LPBJMHB.js";
+  withVariantFeatureFlags,
+  workflowPolicyRuntime,
+  writeAgentActionEvidenceBundle
+} from "./chunk-SIR7XW2S.js";
+import "./chunk-LRD5N2TQ.js";
 import "./chunk-K2PWUPUI.js";
 import {
+  RateLimiter,
   buildIntelDossier,
   lookupCve,
+  parseRateLimitFlag,
   searchAdvisories,
   searchSimilar,
   searchTargetHistory
-} from "./chunk-X2ZMSRTP.js";
-import "./chunk-YERUDEXT.js";
+} from "./chunk-6SNOKNCS.js";
+import "./chunk-PAE7ZAV6.js";
 import "./chunk-UEX7PFSE.js";
-import "./chunk-4ROZFLSR.js";
+import "./chunk-6GV5G6U3.js";
+import "./chunk-R7VWEY45.js";
 import {
   budgetNativeRuntime
-} from "./chunk-BD7WULFS.js";
-import "./chunk-XA2IBHPB.js";
+} from "./chunk-SSPP64FF.js";
+import "./chunk-AZ7L3HFD.js";
+import "./chunk-B7XL6RON.js";
 import {
   runSourceFix
-} from "./chunk-5ETI27Q3.js";
+} from "./chunk-AFJ2UMPR.js";
 import {
   appendImprovementLedgerEntry,
   evaluateImprovementPromotion,
   loadEvolutionConfigFile,
   verifyImprovementLedger
-} from "./chunk-YKWARO3T.js";
+} from "./chunk-YGYJ2FTH.js";
 import {
   runHttpConformanceCheck
-} from "./chunk-SQCBHFWN.js";
+} from "./chunk-LWMEJYCP.js";
 import {
   createRuntime
-} from "./chunk-K74DRDC5.js";
+} from "./chunk-EHNVP6QB.js";
 import "./chunk-O6KPVYOI.js";
 import {
   buildAdGraph,
@@ -303,7 +297,7 @@ import {
   resolveOsecDbPath,
   resolveOsecRunStorage,
   writeOsecRunReport
-} from "./chunk-BMDG6T7D.js";
+} from "./chunk-72PU46MS.js";
 import {
   DISCLOSURE_STATUSES,
   IncompleteEvidenceError,
@@ -322,46 +316,48 @@ import {
   renderReproducibilityManifest,
   renderVendorNotificationMarkdown,
   transition
-} from "./chunk-GTED3FSZ.js";
+} from "./chunk-WPJMA5AK.js";
 import {
   executePocSteps
-} from "./chunk-IXT64DV5.js";
+} from "./chunk-XPDJE537.js";
 import {
   findCveArtifacts,
   normaliseCveId
-} from "./chunk-SU4IHQQI.js";
-import "./chunk-NJLKFC66.js";
-import "./chunk-NBV4I237.js";
+} from "./chunk-IUUNIJPM.js";
+import "./chunk-ABKUI3QB.js";
+import "./chunk-PAMJEXE2.js";
 import {
   LlmApiRuntime,
   features
-} from "./chunk-IJ6UPW3H.js";
+} from "./chunk-HS2NQ7K6.js";
 import {
   isAdmittedSmolvmWorkbench
-} from "./chunk-PVJUPIQG.js";
+} from "./chunk-XOVYV7TT.js";
 import {
   eventBus
-} from "./chunk-5PFRE522.js";
+} from "./chunk-ULRLUXSS.js";
 import "./chunk-RS4MAN3Q.js";
 import {
   EmptyPocError,
   detectVersionRange,
   renderAdvisoryMarkdown,
   verifyAgainstRef
-} from "./chunk-CGBDEST2.js";
+} from "./chunk-VJBEB2K6.js";
 import {
   ScopePolicy,
   getScopeEnforcementState,
   isScopeEnforcementEnabled,
   loadScope
-} from "./chunk-QNRYOJEB.js";
+} from "./chunk-RZZ6VPRY.js";
 import "./chunk-5IBCBQEH.js";
 import {
   AgentActionScenarioSchema,
+  BACKEND_PROTOCOL_VERSION,
   DEFAULT_AUTONOMY_MODE,
   DEFAULT_SEVERITY_FLOOR,
   SecurityWorkflowBindingsSchema,
   VERSION,
+  backendCapabilitiesForApiPath,
   compareFindingsByBusinessPriority,
   createJevEvaluator,
   findingSchema,
@@ -371,15 +367,131 @@ import {
   meetsSeverityFloor,
   parseAgentActionEvidenceManifest,
   pocStepArraySchema,
-  reportSummarySchema
-} from "./chunk-GXXX7AGH.js";
+  reportSummarySchema,
+  validateScanPlan
+} from "./chunk-GYEYTNHK.js";
 import {
   external_exports
-} from "./chunk-VIT5ALXF.js";
+} from "./chunk-5XOYTAOK.js";
+import "./chunk-36J5ZLFE.js";
 import "./chunk-VCSFCHAJ.js";
 
 // packages/cli/src/commands/scan.ts
 import { readFileSync, existsSync } from "node:fs";
+
+// packages/cli/src/guided-scan.ts
+import { createInterface } from "node:readline/promises";
+
+// packages/cli/src/tui/scan-plan.ts
+function recommendedScanGoal(kind) {
+  if (kind === "package") return "known-vulnerabilities";
+  if (kind === "web") return "misconfigurations";
+  return "unknown-vulnerabilities";
+}
+function recommendedScanDepth(goal) {
+  return goal === "unknown-vulnerabilities" ? "deep" : "default";
+}
+function recommendedTimeCapMs(kind, depth) {
+  if (kind === "web") {
+    return depth === "deep" ? 3e5 : depth === "default" ? 6e4 : 3e4;
+  }
+  return depth === "deep" ? 18e5 : depth === "default" ? 6e5 : 3e5;
+}
+function formatTimeCap(ms) {
+  if (ms < 6e4) return `${Math.round(ms / 1e3)}s`;
+  const minutes = ms / 6e4;
+  return Number.isInteger(minutes) ? `${minutes}m` : `${minutes.toFixed(1)}m`;
+}
+function formatGoal(goal) {
+  return goal === "known-vulnerabilities" ? "known vulnerabilities" : goal === "unknown-vulnerabilities" ? "unknown vulnerabilities" : "misconfigurations";
+}
+function scanDepthExplanation(goal) {
+  return goal === "unknown-vulnerabilities" ? "Deep is suggested for broader investigation and reproduction; it takes more effort. Your selected limits still apply." : "Default is suggested for focused checks and reproduction without the effort of a deep investigation.";
+}
+var SCAN_RUNS_HELP = "Start with 1 run. Extra runs repeat the selected scope; each run can already use subagents. All runs share the same limits.";
+var SCAN_MODE_HELP = "Sequential is suggested for lower concurrency. Parallel overlaps runs and may finish sooner, but can consume the shared budget sooner.";
+var SCAN_COST_HELP = "Estimated USD limit shared by every run and subagent. In-flight requests can exceed it before usage is reported. Unknown cost is not zero; this is not a guaranteed provider charge ceiling.";
+
+// packages/cli/src/guided-scan.ts
+var SCAN_MODEL_ROLES = ["discovery", "attack", "verify", "report"];
+function parseScanModelAssignments(values) {
+  const assignments = {};
+  for (const value of values) {
+    const separator = value.indexOf("=");
+    const role = value.slice(0, separator);
+    const model = value.slice(separator + 1).trim();
+    if (separator < 1 || !SCAN_MODEL_ROLES.includes(role) || !model || model === "auto" || /[\r\n\0]/.test(model)) {
+      throw new Error("--task-model requires discovery|attack|verify|report=MODEL (an explicit model ID).");
+    }
+    if (Object.hasOwn(assignments, role)) throw new Error(`Duplicate task model for ${role}.`);
+    assignments[role] = model;
+  }
+  return assignments;
+}
+function scanRoutingSummary(model, assignments = {}, singleModel = false) {
+  const fallback = model ?? "configured session model";
+  return SCAN_MODEL_ROLES.map((role) => `${role}: ${singleModel ? fallback : assignments[role] ?? fallback}`).join(" \xB7 ");
+}
+async function collectGuidedScanPlan(options, io) {
+  const choose = async (label, choices, recommended) => {
+    while (true) {
+      const answer = (await io.question(`${label} (${choices.join(" / ")}) [${recommended}]: `)).trim();
+      if (!answer) return recommended;
+      if (choices.includes(answer)) return answer;
+      io.write("Choose one of the listed values.\n");
+    }
+  };
+  const positive2 = async (label, fallback, integer = false, max = Infinity) => {
+    while (true) {
+      const raw = (await io.question(`${label} [${fallback}]: `)).trim();
+      const value = raw ? Number(raw) : fallback;
+      if (Number.isFinite(value) && value > 0 && value <= max && (!integer || Number.isSafeInteger(value))) return value;
+      io.write(`Enter a positive ${integer ? "integer" : "number"}${max < Infinity ? ` no greater than ${max}` : ""}.
+`);
+    }
+  };
+  io.write(`Scope: ${options.target}
+Recommendations keep this scope unchanged.
+`);
+  const goal = await choose("Goal", ["known-vulnerabilities", "unknown-vulnerabilities", "misconfigurations"], recommendedScanGoal("web"));
+  io.write(`${scanDepthExplanation(goal)} Unknown vulnerabilities are an objective, not a promised result.
+`);
+  const depth = await choose("Depth", ["quick", "default", "deep"], options.depth ?? recommendedScanDepth(goal));
+  io.write(`${SCAN_RUNS_HELP}
+`);
+  const runCount = await positive2("Separate runs", 1, true, 16);
+  io.write(`${SCAN_MODE_HELP}
+`);
+  const executionMode = await choose("Execution", ["sequential", "parallel"], "sequential");
+  io.write("This planner supports up to 24 hours and $1,000 estimated for the whole plan.\n");
+  const timeCapMs = await positive2("Total wall-clock cap (minutes)", recommendedTimeCapMs("web", depth) / 6e4, false, 1440) * 6e4;
+  io.write(`${SCAN_COST_HELP}
+`);
+  const costCapUsd = await positive2("Total estimated cost cap (USD)", Math.min(options.costCapUsd ?? 5, 1e3), false, 1e3);
+  const plan = { goal, depth, runCount, executionMode, timeCapMs, costCapUsd };
+  validateScanPlan(plan);
+  io.write(`
+${options.target} \xB7 ${formatGoal(goal)} \xB7 ${depth} \xB7 ${runCount} separate run(s) \xB7 ${executionMode} \xB7 ${formatTimeCap(timeCapMs)} total \xB7 $${costCapUsd} total estimated
+`);
+  const routing = options.singleModel ? void 0 : options.recommendRouting?.(plan);
+  if (routing) for (const role of SCAN_MODEL_ROLES) io.write(`${role}: ${routing.reasons[role]}
+`);
+  io.write(`${scanRoutingSummary(options.model, routing?.assignments ?? options.agentModels, options.singleModel)}
+Configured models are operator choices; no task-specific superiority is assumed. Override with --task-model ROLE=MODEL or --single-model.
+`);
+  const confirmed = (await io.question("Start this plan? [y/N]: ")).trim().toLowerCase();
+  return confirmed === "y" || confirmed === "yes" ? plan : void 0;
+}
+async function guidedScanPlan(options) {
+  const readline = createInterface({ input: process.stdin, output: process.stderr });
+  try {
+    return await collectGuidedScanPlan(options, { question: (prompt) => readline.question(prompt), write: (text2) => process.stderr.write(text2) });
+  } finally {
+    readline.close();
+  }
+}
+
+// packages/cli/src/commands/scan.ts
 function parseAuthFlag(value) {
   let raw;
   if (!value.trimStart().startsWith("{") && existsSync(value)) {
@@ -431,16 +543,27 @@ function parseIdentitiesFile(path) {
   }
 }
 var fixtureSchema = external_exports.array(external_exports.object({
-  url: external_exports.string().url().refine((url) => /^https?:/.test(url)),
+  url: external_exports.string().url().max(8192).refine((url) => {
+    const parsed = new URL(url);
+    return /^https?:/.test(url) && !parsed.username && !parsed.password;
+  }),
   ownerIdentity: external_exports.string().min(1),
   comparisonIdentities: external_exports.array(external_exports.string().min(1)).min(1).max(16),
-  ownershipMarker: external_exports.string().min(16).max(500)
-}).strict()).min(1).max(100);
+  ownershipMarker: external_exports.string().min(16).max(500),
+  stateChange: external_exports.object({
+    disposable: external_exports.literal(true),
+    jsonPointer: external_exports.string().regex(/^(?:\/(?:[^~]|~[01])*)?$/),
+    stepUrls: external_exports.array(external_exports.string().url().max(8192).refine((url) => /^https?:/.test(url))).min(1).max(10)
+  }).strict().optional()
+}).strict().refine((fixture) => !fixture.stateChange || fixture.stateChange.stepUrls.every((url) => {
+  const step = new URL(url), observation = new URL(fixture.url);
+  return step.origin === observation.origin && !step.username && !step.password;
+}))).min(1).max(100);
 function parseAccessControlFixturesFile(path) {
   try {
     return fixtureSchema.parse(JSON.parse(readFileSync(path, "utf8")));
   } catch {
-    throw new Error("Invalid --access-control-fixtures file: expected read-only ownership fixtures with URLs, owner/comparison labels and private markers");
+    throw new Error("Invalid --access-control-fixtures file: expected ownership fixtures with URLs, owner/comparison labels, private markers and valid optional disposable-state contracts");
   }
 }
 function parseStringArrayEnv(name, raw) {
@@ -505,14 +628,14 @@ var PRESET_TOKENS = /* @__PURE__ */ new Set([
   "moat"
 ]);
 function registerScanCommand(program) {
-  program.command("scan").description("Run autonomous pentest against a URL, web app, or MCP server").requiredOption("--target <target>", "Target URL or mcp:// endpoint").option("--depth <depth>", "Scan depth: quick, default, deep", "default").option("--format <format>", "Output format: terminal, json, md, html, sarif, pdf", "terminal").option("--runtime <runtime>", "Model provider: auto, api, claude, codex, gemini", "auto").option("--mode <mode>", "Scan mode: probe, deep, mcp, web, http_audit (http_audit reads ZERO_TARGET_* env config)").option("--timeout <ms>", "Request timeout in milliseconds", "30000").option("--db-path <path>", "Path to SQLite database").option("--api-key <key>", "API key for LLM provider").option("-m, --model <model>", "LLM model to use").option("--repo <path>", "Source code path for white-box scanning").option("--access-control-fixtures <file>", "JSON file of known private resource ownership fixtures for IDOR verification").option("--identities <file>", "Restricted JSON file with named test identities for access-control replay").option("--auth <json>", "Auth credentials: JSON string or path (bearer, cookie, basic, header)").option("--scope <path>", "Path to a JSON scope policy (enable with `0 plugin enable scope`)").option("--allow-scanners", "Expose generic scanner tools in scope-enforced scans", false).option("--require-scope", "Refuse unscoped scans while the scope plugin is enabled", false).option(
+  program.command("scan").description("Run autonomous pentest against a URL, web app, or MCP server").requiredOption("--target <target>", "Target URL or mcp:// endpoint").option("--depth <depth>", "Scan depth: quick, default, deep", "default").option("--format <format>", "Output format: terminal, json, md, html, sarif, pdf", "terminal").option("--runtime <runtime>", "Model provider: auto, api, claude, codex, gemini", "auto").option("--mode <mode>", "Scan mode: probe, deep, mcp, web, http_audit (http_audit reads ZERO_TARGET_* env config)").option("--timeout <ms>", "Request timeout in milliseconds", "30000").option("--db-path <path>", "Path to SQLite database").option("--api-key <key>", "API key for LLM provider").option("-m, --model <model>", "LLM model to use").option("--task-model <role=model>", "Explicit task model: discovery, attack, verify, report (repeatable)", (value, previous = []) => [...previous, value]).option("--routing-report <file>", "Reviewed model-api task qualification report; opt-in recommendations only").option("--routing-model <model>", "Approve a model candidate for the reviewed routing plan (repeatable)", (value, previous = []) => [...previous, value]).option("--routing-review-ref <ref>", "Review reference confirming provider/workflow authorization and model evidence limitations").option("--goal <goal>", "Noninteractive routing goal: known-vulnerabilities, unknown-vulnerabilities, misconfigurations").option("--plan-time-cap <ms>", "Overall wall-clock cap required for a noninteractive routing plan").option("--single-model", "Use the selected model for every task, ignoring task assignments").option("--no-guided", "Skip interactive scan planning and use explicit command options").option("--repo <path>", "Source code path for white-box scanning").option("--access-control-fixtures <file>", "JSON file of known private resource ownership fixtures for IDOR verification").option("--identities <file>", "Restricted JSON file with named test identities for access-control replay").option("--auth <json>", "Auth credentials: JSON string or path (bearer, cookie, basic, header)").option("--scope <path>", "Path to a JSON scope policy (enable with `0 plugin enable scope`)").option("--allow-scanners", "Expose generic scanner tools in scope-enforced scans", false).option("--require-scope", "Refuse unscoped scans while the scope plugin is enabled", false).option(
     "--attribution-header <name=value>",
     "Header to attach to in-scope requests (repeatable); never sent out-of-scope",
     (value, prev = []) => [...prev, value]
   ).option(
     "--attribution-ua <token>",
     "Engagement token to embed in the User-Agent on in-scope traffic"
-  ).option("--api-spec <path>", "Path to an OpenAPI/Swagger spec for endpoint knowledge").option("--export <target>", "Export findings to issue tracker (e.g. github:owner/repo)").addOption(new Option("--race", "Best-of-N strategy racing (benchmark/CTF only)").default(false).hideHelp()).addOption(new Option("--egats", "Evidence-gated attack tree search").default(false).hideHelp()).option("--cost-ceiling <usd>", "Hard per-scan USD cost ceiling; aborts with partial findings if exceeded").option(
+  ).option("--api-spec <path>", "Path to an OpenAPI/Swagger spec for endpoint knowledge").option("--export <target>", "Export findings to issue tracker (e.g. github:owner/repo)").addOption(new Option("--race", "Best-of-N strategy racing (benchmark/CTF only)").default(false).hideHelp()).addOption(new Option("--egats", "Evidence-gated attack tree search").default(false).hideHelp()).option("--cost-ceiling <usd>", "Estimated USD stopping threshold; in-flight usage may overshoot, partial findings retained").option(
     "--rate-limit <spec>",
     "Per-host requests/sec cap, e.g. '5' or 'host=5,*=3' (default 5)"
   ).option(
@@ -521,16 +644,16 @@ function registerScanCommand(program) {
   ).option(
     "--no-waf-evasion",
     "Disable adaptive WAF-evasion retries"
-  ).option("--tui", "Open the terminal UI after the scan completes", false).option(
+  ).option(
     "--features <list>",
     "Comma-separated feature flags to enable, e.g. 'fp-moat'"
   ).addOption(new Option("--no-decoy-detection", "Disable the anti-honeypot flag validator").hideHelp()).addOption(new Option("--dispatch <mode>", "Tool-call protocol: json, xml, auto (legacy loop only)").default("auto").hideHelp()).option(
     "--emit <target>",
     "Emit mode: 'pr' opens a GitHub PR per reproduced finding"
-  ).option("--base <branch>", "Base branch for `--emit pr` (default: main)").option("--dry-run", "With `--emit pr`: print git/gh commands instead of running them", false).option("--emit-out-dir <path>", "Directory for `--emit pr` rollup files (default: system temp)").option("--resume <run-id>", "Resume a previous run from its on-disk journal").addOption(new Option("--branch-from <entry-index>", "Branch the journal at an entry index before resuming (with --resume)").hideHelp()).option("--verbose", "Show detailed output", false).addOption(new Option("--replay", "Replay the last scan's results").default(false).hideHelp()).action(async (opts) => {
+  ).option("--base <branch>", "Base branch for `--emit pr` (default: main)").option("--dry-run", "With `--emit pr`: print git/gh commands instead of running them", false).option("--emit-out-dir <path>", "Directory for `--emit pr` rollup files (default: system temp)").option("--resume <run-id>", "Resume a previous run from its on-disk journal").addOption(new Option("--branch-from <entry-index>", "Branch the journal at an entry index before resuming (with --resume)").hideHelp()).option("--verbose", "Show detailed output", false).addOption(new Option("--replay", "Replay the last scan's results").default(false).hideHelp()).action(async (opts, command) => {
     if (opts.replay) {
       try {
-        const { osecDB: osecDB2 } = await import("./dist-RKLQIXDT.js");
+        const { osecDB: osecDB2 } = await import("./dist-QLMPTFT7.js");
         const db = new osecDB2(opts.dbPath);
         const scans = db.listScans(1);
         if (scans.length === 0) {
@@ -682,7 +805,7 @@ function registerScanCommand(program) {
         process.exit(2);
       }
       try {
-        const { loadScope: loadScope2 } = await import("./dist-TQMHMSBZ.js");
+        const { loadScope: loadScope2 } = await import("./dist-ONIRKDH6.js");
         const policy = loadScope2(scopeFile);
         const verdict = scopeEnforcement.enabled ? policy.match(String(opts.target)) : void 0;
         if (verdict && !verdict.allowed) {
@@ -709,7 +832,7 @@ function registerScanCommand(program) {
         loadScope: loadScope2,
         resolveAttribution: resolveAttribution2,
         extractAttributionFromScopeJson: extractAttributionFromScopeJson2
-      } = await import("./dist-TQMHMSBZ.js");
+      } = await import("./dist-ONIRKDH6.js");
       const policy = scopeFile ? loadScope2(scopeFile) : void 0;
       resolveAttribution2({
         scopeFileBlock: policy ? extractAttributionFromScopeJson2(policy.raw) : void 0,
@@ -727,7 +850,7 @@ function registerScanCommand(program) {
         loadScope: loadScope2,
         resolveEngagementProfile: resolveEngagementProfile2,
         extractEngagementFromScopeJson: extractEngagementFromScopeJson2
-      } = await import("./dist-TQMHMSBZ.js");
+      } = await import("./dist-ONIRKDH6.js");
       const policy = scopeFile ? loadScope2(scopeFile) : void 0;
       resolveEngagementProfile2({
         scopeFileBlock: policy ? extractEngagementFromScopeJson2(policy.raw) : void 0,
@@ -756,13 +879,41 @@ function registerScanCommand(program) {
     const rateLimit = opts.rateLimit;
     if (rateLimit !== void 0 && rateLimit !== "") {
       try {
-        const { parseRateLimitFlag: parseRateLimitFlag2 } = await import("./dist-TQMHMSBZ.js");
+        const { parseRateLimitFlag: parseRateLimitFlag2 } = await import("./dist-ONIRKDH6.js");
         parseRateLimitFlag2(rateLimit);
       } catch (err) {
         console.error(source_default.red(err instanceof Error ? err.message : String(err)));
         process.exit(2);
       }
     }
+    const manualModels = parseScanModelAssignments(opts.taskModel ?? []);
+    let agentModels = manualModels;
+    let recommendRouting;
+    if (opts.routingReport && !opts.singleModel) {
+      if (opts.runtime !== "api") throw new Error("Reviewed routing requires --runtime api; no unsupported runtime or provider substitution.");
+      if (!opts.routingReviewRef || !opts.routingModel?.length) throw new Error("--routing-report requires --routing-model approvals and --routing-review-ref confirming the workflow/provider review.");
+      const { readRoutingJson } = await import("./routing-WCQLO5SP.js");
+      const { recommendQualifiedRouting, LlmApiRuntime: LlmApiRuntime2 } = await import("./dist-ONIRKDH6.js");
+      const raw = readRoutingJson(String(opts.routingReport));
+      const current = new LlmApiRuntime2({ type: "api", timeout: parseInt(opts.timeout, 10), model: opts.model });
+      recommendRouting = (selectedPlan) => {
+        const result = recommendQualifiedRouting(raw, { approvedModels: opts.routingModel, provider: current.resolvedProvider(), reviewRef: String(opts.routingReviewRef), workflow: { targetKind: "web", goal: selectedPlan.goal, depth: selectedPlan.depth }, minimumRepeats: 2 });
+        agentModels = { ...result.assignments, ...manualModels };
+        return { assignments: agentModels, reasons: Object.fromEntries(Object.entries(result.reasons).map(([role, reason]) => [role, manualModels[role] ? `Operator override: ${manualModels[role]}.` : reason])) };
+      };
+    }
+    const interactivePlanning = opts.guided !== false && opts.format === "terminal" && process.stdin.isTTY && process.stdout.isTTY && !opts.resume;
+    let plan = interactivePlanning ? await guidedScanPlan({ target: opts.target, depth: command.getOptionValueSource("depth") === "cli" ? opts.depth : void 0, costCapUsd: costCeilingUsd, model: opts.model, agentModels, singleModel: opts.singleModel, ...recommendRouting ? { recommendRouting } : {} }) : void 0;
+    if (interactivePlanning && !plan) return;
+    if (!interactivePlanning && recommendRouting) {
+      if (!opts.goal || !opts.planTimeCap || costCeilingUsd === void 0) throw new Error("Noninteractive reviewed routing requires --goal, --plan-time-cap and --cost-ceiling.");
+      plan = { goal: opts.goal, depth: opts.depth, runCount: 1, executionMode: "sequential", timeCapMs: Number(opts.planTimeCap), costCapUsd: costCeilingUsd };
+      const { validateScanPlan: validateScanPlan2 } = await import("./dist-QXJKD743.js");
+      validateScanPlan2(plan);
+      const routing = recommendRouting(plan);
+      for (const [role, model] of Object.entries(routing.assignments)) console.error(`${role}: ${model} \u2014 ${routing.reasons[role]}`);
+    }
+    const hasAssignments = Object.keys(agentModels).length > 0;
     const branchFrom = opts.branchFrom;
     await runUnified({
       target: opts.target,
@@ -770,7 +921,10 @@ function registerScanCommand(program) {
       resumeScanId: opts.resume,
       branchFromEntry: branchFrom !== void 0 ? parseInt(branchFrom, 10) : void 0,
       mode,
-      depth: opts.depth,
+      depth: plan?.depth ?? opts.depth,
+      plan,
+      ...hasAssignments ? { agentModels } : {},
+      ...opts.singleModel !== void 0 ? { singleModel: opts.singleModel } : {},
       format: opts.format === "md" ? "markdown" : opts.format,
       runtime: opts.runtime ?? "auto",
       timeout: parseInt(opts.timeout, 10),
@@ -786,9 +940,8 @@ function registerScanCommand(program) {
       exportTarget: opts.export,
       race: opts.race,
       egats: opts.egats,
-      costCeilingUsd,
+      costCeilingUsd: plan?.costCapUsd ?? costCeilingUsd,
       rateLimit,
-      tui: opts.tui,
       scopeFile,
       allowScanners: opts.allowScanners,
       attributionHeaders: opts.attributionHeader,
@@ -927,7 +1080,7 @@ function registerResumeCommand(program) {
 
 // packages/cli/src/commands/replay.ts
 async function replayScan(opts) {
-  const { osecDB: osecDB2 } = await import("./dist-RKLQIXDT.js");
+  const { osecDB: osecDB2 } = await import("./dist-QLMPTFT7.js");
   const db = new osecDB2(opts.dbPath);
   const requestedScan = opts.scan;
   let scanRecord;
@@ -992,14 +1145,8 @@ async function replayScan(opts) {
   });
 }
 function registerReplayCommand(program) {
-  program.command("replay").description("Replay the last scan's attack chain as an animated terminal sequence").option("--db-path <path>", "Path to SQLite database").option("--scan <scanId>", "Replay a specific scan by ID (default: last scan)").action(async (opts) => {
+  program.command("replay").description("Print a replay of the last scan's attack chain").option("--db-path <path>", "Path to SQLite database").option("--scan <scanId>", "Replay a specific scan by ID (default: last scan)").action(async (opts) => {
     try {
-      const { isBunRuntime, canUseOpenTui } = await import("./runtime-AUBLQUOH.js");
-      if (isBunRuntime() && canUseOpenTui()) {
-        const { showOpenTuiReplay } = await import("./run-MU3MFL2Z.js");
-        await showOpenTuiReplay({ dbPath: opts.dbPath, scanId: opts.scan });
-        return;
-      }
       await replayScan(opts);
     } catch (err) {
       console.error(
@@ -1013,14 +1160,14 @@ function registerReplayCommand(program) {
 // packages/cli/src/commands/history.ts
 import { existsSync as existsSync2 } from "node:fs";
 function registerHistoryCommand(program) {
-  program.command("history").description("Show past scan history from run-local SQLite databases").option("--db-path <path>", "Path to one SQLite database").option("--limit <n>", "Number of scans to show", "10").action(async (opts) => {
-    const limit2 = Number.parseInt(opts.limit ?? "10", 10);
-    const { isBunRuntime, canUseOpenTui } = await import("./runtime-AUBLQUOH.js");
-    if (opts.dbPath && isBunRuntime() && canUseOpenTui()) {
-      const { showOpenTuiHistory } = await import("./run-MU3MFL2Z.js");
-      await showOpenTuiHistory({ dbPath: opts.dbPath, limit: limit2 });
-      return;
-    }
+  program.command("history").description("Show past scan history from run-local SQLite databases").option("--db-path <path>", "Path to one SQLite database").option("--limit <n>", "Number of scans to show", (value) => {
+    const limit2 = Number(value);
+    if (!/^\d+$/.test(value) || !Number.isSafeInteger(limit2) || limit2 < 1) {
+      throw new InvalidArgumentError("must be a positive integer");
+    }
+    return limit2;
+  }, 10).action(async (opts) => {
+    const limit2 = opts.limit ?? 10;
     const dbPaths = opts.dbPath ? [opts.dbPath] : listOsecRunDatabasePaths();
     const legacyDbPath = resolveOsecDbPath();
     if (!opts.dbPath && existsSync2(legacyDbPath) && !dbPaths.includes(legacyDbPath)) {
@@ -1223,46 +1370,12 @@ function registerFindingsCommand(program) {
     { defaultLimit: "50" }
   ).option("--all", "Show raw finding rows instead of grouped fingerprints", false).action(async (opts, command) => {
     const resolved = resolveFindingsOptions(opts, command);
-    const limit2 = Number.parseInt(resolved.limit ?? "50", 10);
-    const selectedDbPath = resolveDbPath(resolved);
-    const { isBunRuntime, canUseOpenTui } = await import("./runtime-AUBLQUOH.js");
-    if (selectedDbPath && isBunRuntime() && canUseOpenTui()) {
-      const { showOpenTuiFindings } = await import("./run-MU3MFL2Z.js");
-      await showOpenTuiFindings({
-        dbPath: selectedDbPath,
-        scan: resolved.scan,
-        severity: resolved.severity,
-        category: resolved.category,
-        status: resolved.status,
-        triage: resolved.triage,
-        limit: limit2,
-        all: resolved.all
-      });
-      return;
-    }
     await renderFindingsList(resolved);
   });
   withFindingsListOptions(
     findingsCmd.command("list").description("List findings from the database")
   ).action(async (opts, command) => {
     const resolved = resolveFindingsOptions(opts, command);
-    const limit2 = Number.parseInt(resolved.limit ?? "50", 10);
-    const selectedDbPath = resolveDbPath(resolved);
-    const { isBunRuntime, canUseOpenTui } = await import("./runtime-AUBLQUOH.js");
-    if (selectedDbPath && isBunRuntime() && canUseOpenTui()) {
-      const { showOpenTuiFindings } = await import("./run-MU3MFL2Z.js");
-      await showOpenTuiFindings({
-        dbPath: selectedDbPath,
-        scan: resolved.scan,
-        severity: resolved.severity,
-        category: resolved.category,
-        status: resolved.status,
-        triage: resolved.triage,
-        limit: limit2,
-        all: resolved.all
-      });
-      return;
-    }
     await renderFindingsList(resolved);
   });
   findingsCmd.command("show").description("Show detailed information about a finding").argument("<id>", "Finding ID (full or prefix)").option("--db-path <path>", "Path to SQLite database").action(async (id, opts, command) => {
@@ -1308,7 +1421,7 @@ function registerFindingsCommand(program) {
         console.log(`  ${source_default.dim(finding.evidenceAnalysis)}`);
       }
       {
-        const { summarizeTriageProvenance, formatTriageProvenance } = await import("./dist-TQMHMSBZ.js");
+        const { summarizeTriageProvenance, formatTriageProvenance } = await import("./dist-ONIRKDH6.js");
         const provenance = summarizeTriageProvenance({
           ...finding,
           layerVerdicts: parseLayerVerdicts(finding.layerVerdicts)
@@ -1371,7 +1484,7 @@ function positiveAmount(value) {
   return parsed;
 }
 function registerSecureCommand(program) {
-  program.command("secure").description("Find, reproduce, fix, and verify vulnerabilities in a repo; optionally open repair PRs").argument("<repo>", "Local Git repository or HTTPS Git URL; execution occurs in the current worker, not a newly provisioned sandbox").requiredOption("--test-command <command>", "Operator-approved regression command; must pass before and after repair").option("--setup-command <command>", "Operator-approved setup/build command run in each disposable checkout").option("--state-dir <path>", "Persistent run directory; defaults to a stable per-repository path so learnings accumulate").option("--runtime <runtime>", "Native repair runtime: auto or api", "api").option("-m, --model <model>", "Model for investigation and repair; inherits configured provider when omitted").option("--timeout <ms>", "Whole workflow deadline in milliseconds", positiveInteger, 36e5).option("--cost-ceiling <usd>", "Whole workflow model cost ceiling in USD", positiveAmount).option("--max-findings <n>", "Maximum findings to repair; remaining findings keep the run blocked", positiveInteger, 10).option("--max-attempts <n>", "Maximum repair candidates per finding", positiveInteger, 3).option("--max-turns <n>", "Maximum model turns per repair phase", positiveInteger, 30).option("--resume", "Resume the compatible persisted run for this repository; never blindly replays publication", false).option("--publish", "Publish verified patches as PRs using authorized repository credentials; never merge or deploy", false).option("--rules <text>", 'Plain-English team repair standards (e.g. "minimal diffs, no new dependencies")').option("--format <format>", "Output format: json", "json").action(async (repo, options) => {
+  program.command("secure").description("Find, reproduce, fix, and verify vulnerabilities in a repo; optionally open repair PRs").argument("<repo>", "Local Git repository or HTTPS Git URL; execution occurs in the current worker, not a newly provisioned sandbox").requiredOption("--test-command <command>", "Operator-approved regression command; must pass before and after repair").option("--source-path <path>", "Repository-relative folder to investigate and repair; setup and tests run at the repository root").option("--setup-command <command>", "Operator-approved setup/build command run in each disposable checkout").option("--state-dir <path>", "Persistent run directory; defaults to a stable per-repository path so learnings accumulate").option("--runtime <runtime>", "Native repair runtime: auto or api", "api").option("-m, --model <model>", "Model for investigation and repair; inherits configured provider when omitted").option("--timeout <ms>", "Whole workflow deadline in milliseconds", positiveInteger, 36e5).option("--cost-ceiling <usd>", "Whole workflow model cost ceiling in USD", positiveAmount).option("--max-findings <n>", "Maximum findings to repair; remaining findings keep the run blocked", positiveInteger, 10).option("--max-attempts <n>", "Maximum repair candidates per finding", positiveInteger, 3).option("--max-turns <n>", "Maximum model turns per repair phase", positiveInteger, 30).option("--resume", "Resume the compatible persisted run for this repository; never blindly replays publication", false).option("--publish", "Publish verified patches as PRs using authorized repository credentials; never merge or deploy", false).option("--rules <text>", 'Plain-English team repair standards (e.g. "minimal diffs, no new dependencies")').option("--format <format>", "Output format: json", "json").action(async (repo, options) => {
     if (options.format !== "json") throw new InvalidArgumentError("--format must be json.");
     if (!["api", "auto"].includes(options.runtime)) throw new InvalidArgumentError("--runtime must be api or auto.");
     if (!options.testCommand.trim()) throw new InvalidArgumentError("--test-command cannot be blank.");
@@ -1392,6 +1505,7 @@ function registerSecureCommand(program) {
     try {
       const result = await runSecureProject({
         repoRoot: repo,
+        sourcePath: options.sourcePath,
         stateDir,
         testCommand: options.testCommand,
         setupCommand: options.setupCommand,
@@ -1428,7 +1542,7 @@ import { existsSync as existsSync3 } from "node:fs";
 var VALID_BUILD_SYSTEMS = /* @__PURE__ */ new Set(["autotools", "cmake", "meson", "auto"]);
 var VALID_SANITIZERS = /* @__PURE__ */ new Set(["asan", "ubsan", "msan"]);
 async function runHarnessTier2(args2) {
-  const { buildTier2Harness, extractCorpus } = await import("./dist-TQMHMSBZ.js");
+  const { buildTier2Harness, extractCorpus } = await import("./dist-ONIRKDH6.js");
   const repoAbs = resolve2(args2.repo);
   if (!existsSync3(repoAbs)) {
     throw new Error(`Tier-2: repo path '${repoAbs}' does not exist.`);
@@ -1524,7 +1638,7 @@ async function runHarnessTier3(args2) {
     buildTier2Harness,
     extractCorpus,
     runTier3Validation
-  } = await import("./dist-TQMHMSBZ.js");
+  } = await import("./dist-ONIRKDH6.js");
   const repoAbs = resolve3(args2.repo);
   if (!existsSync4(repoAbs)) {
     throw new Error(`Tier-3: repo path '${repoAbs}' does not exist.`);
@@ -1642,7 +1756,7 @@ function normalizeReviewProfile(value, flag) {
   );
 }
 function registerReviewCommand(program) {
-  program.command("review").description("Deep source code security review of a repository").argument("<repo>", "Local path or git URL to review").option("--depth <depth>", "Review depth: quick, default, deep", "default").option("--format <format>", "Output format: terminal, json, md, html, sarif, pdf", "terminal").option("--runtime <runtime>", "Runtime: auto, claude, codex, gemini, api, ollama", "auto").option("--db-path <path>", "Path to SQLite database").option("--api-key <key>", "API key for LLM provider").option("-m, --model <model>", "LLM model to use").option("--cost-ceiling <usd>", "Hard per-review USD cost ceiling. Aborts cleanly with partial findings if exceeded.").option("--tui", "Open the local terminal UI after the review completes", false).option("--diff-base <ref>", "Git base ref to review against (for diff-aware review)").option("--changed-only", "Restrict static scanner leads + prioritization to changed files", false).option(
+  program.command("review").description("Deep source code security review of a repository").argument("<repo>", "Local path or git URL to review").option("--depth <depth>", "Review depth: quick, default, deep", "default").option("--format <format>", "Output format: terminal, json, md, html, sarif, pdf", "terminal").option("--runtime <runtime>", "Runtime: auto, claude, codex, gemini, api, ollama", "auto").option("--db-path <path>", "Path to SQLite database").option("--api-key <key>", "API key for LLM provider").option("-m, --model <model>", "LLM model to use").option("--cost-ceiling <usd>", "Hard per-review USD cost ceiling. Aborts cleanly with partial findings if exceeded.").option("--diff-base <ref>", "Git base ref to review against (for diff-aware review)").option("--changed-only", "Restrict static scanner leads + prioritization to changed files", false).option(
     "--profile <profile>",
     "Review profile: default (web/JS/TS/Python), c-library (C/C++ memory safety, tier-1/2/3 harness), linux-kernel (kernel-aware static review), cardano-onchain (Aiken/Plutus validator logic), solana-onchain (Anchor/native Rust account-model authorization), evm-onchain (Solidity/Foundry/Hardhat DeFi/bridge \u2014 reentrancy, oracle manipulation, cross-chain replay), cairo-onchain (Cairo/Starknet DeFi \u2014 caller-auth gaps, share-rounding, L1\u2194L2 messages), move-onchain (Sui/Aptos Move \u2014 object/capability binding, shared-math overflow, reward-index accounting), cardano-haskell (first-party Cardano Haskell node stack \u2014 ledger/plutus/ouroboros/cardano-base), xnu-kernel (Apple XNU macOS/iOS source review), or xnu-re (decompiled Apple kext pseudo-C)",
     "default"
@@ -1744,7 +1858,7 @@ function registerReviewCommand(program) {
     let seedFindings;
     const seedPath = opts.seedFindings;
     if (seedPath) {
-      const { readSeedFindings } = await import("./dist-TQMHMSBZ.js");
+      const { readSeedFindings } = await import("./dist-ONIRKDH6.js");
       seedFindings = readSeedFindings(seedPath);
       console.log(
         source_default.cyan(
@@ -1760,7 +1874,7 @@ function registerReviewCommand(program) {
       );
     }
     if (fixCommit) {
-      const { huntAppFixVariants, appFixVariantsToSeedFindings } = await import("./dist-TQMHMSBZ.js");
+      const { huntAppFixVariants, appFixVariantsToSeedFindings } = await import("./dist-ONIRKDH6.js");
       const result = huntAppFixVariants({
         repoPath: repo,
         fixCommit
@@ -1874,7 +1988,6 @@ function registerReviewCommand(program) {
       conversation: opts.conversation,
       priorFindings,
       npmDynamicDiscovery: opts.npmDynamic,
-      tui: opts.tui,
       seedFindings,
       seedOnly: opts.seedOnly,
       emit,
@@ -2035,7 +2148,7 @@ function registerAuditCommand(program) {
   program.command("audit").description("Run a package security workflow (compatibility shortcut)").argument("<package>", "package name (e.g. lodash, express, requests)").option("--ecosystem <ecosystem>", "Package ecosystem: npm, pypi, cargo, oci", "npm").option(
     "--package-version <version>",
     "Specific package version to audit (default: latest)"
-  ).option("--pkg-version <version>", "Alias for --package-version").option("--ver <version>", "Alias for --package-version").option("--depth <depth>", "Audit depth: quick, default, deep", "default").option("--format <format>", "Output format: terminal, json, md, html, sarif, pdf", "terminal").option("--runtime <runtime>", "Runtime: auto, claude, codex, gemini, api", "auto").option("--db-path <path>", "Path to SQLite database").option("--api-key <key>", "API key for LLM provider").option("-m, --model <model>", "LLM model to use").option("--cost-ceiling <usd>", "Hard per-audit USD cost ceiling. Aborts cleanly with partial findings if exceeded.").option("--tui", "Open the local terminal UI after the audit completes", false).option("--resume <run-id>", "Resume a previous run from its journal on disk (0#374)").option("--branch-from <entry-index>", "Branch the journal at the given entry index before resuming (requires --resume).").option("--verbose", "Show detailed output", false).option("--timeout <ms>", "AI agent timeout in milliseconds", "600000").action(async (packageName, opts) => {
+  ).option("--pkg-version <version>", "Alias for --package-version").option("--ver <version>", "Alias for --package-version").option("--depth <depth>", "Audit depth: quick, default, deep", "default").option("--format <format>", "Output format: terminal, json, md, html, sarif, pdf", "terminal").option("--runtime <runtime>", "Runtime: auto, claude, codex, gemini, api", "auto").option("--db-path <path>", "Path to SQLite database").option("--api-key <key>", "API key for LLM provider").option("-m, --model <model>", "LLM model to use").option("--cost-ceiling <usd>", "Hard per-audit USD cost ceiling. Aborts cleanly with partial findings if exceeded.").option("--resume <run-id>", "Resume a previous run from its journal on disk (0#374)").option("--branch-from <entry-index>", "Branch the journal at the given entry index before resuming (requires --resume).").option("--verbose", "Show detailed output", false).option("--timeout <ms>", "AI agent timeout in milliseconds", "600000").action(async (packageName, opts) => {
     const ecosystem = (opts.ecosystem ?? "npm").trim().toLowerCase();
     if (!SUPPORTED_AUDIT_ECOSYSTEMS.has(ecosystem)) {
       throw new Error(`Unsupported ecosystem '${ecosystem}'. Valid: npm, pypi, cargo, oci.`);
@@ -2064,8 +2177,7 @@ function registerAuditCommand(program) {
       model: opts.model,
       // Read in priority: --package-version, --pkg-version, --ver.
       packageVersion: opts.packageVersion ?? opts.pkgVersion ?? opts.ver,
-      costCeilingUsd,
-      tui: opts.tui
+      costCeilingUsd
     });
   });
 }
@@ -2073,12 +2185,7 @@ function registerAuditCommand(program) {
 // packages/cli/src/commands/doctor.ts
 function registerDoctorCommand(program) {
   program.command("doctor").description("Check local runtime prerequisites and suggest the next command").action(async () => {
-    const { isBunRuntime, canUseOpenTui, getRuntimeMetadata } = await import("./runtime-AUBLQUOH.js");
-    if (isBunRuntime() && canUseOpenTui()) {
-      const { showOpenTuiDoctor } = await import("./run-MU3MFL2Z.js");
-      await showOpenTuiDoctor();
-      return;
-    }
+    const { getRuntimeMetadata } = await import("./runtime-6ZIXFTW5.js");
     const { hasApiKey, availableRuntimes, apiRuntime } = await getRuntimeAvailability();
     const runtime = getRuntimeMetadata();
     const nodeMajor = Number.parseInt(process.versions.node.split(".")[0] ?? "0", 10);
@@ -2114,8 +2221,9 @@ function registerDoctorCommand(program) {
 
 // packages/cli/src/commands/tui.ts
 function registerTuiCommand(program) {
-  program.command("tui").alias("watch").description("Retired terminal UI; use 0 web for interactive work").action(() => {
-    console.log("The interactive terminal UI has been retired. Run 0 web to open the browser console. Headless commands and 0 chat --prompt remain available.");
+  program.command("tui", { hidden: true }).alias("watch").description("Retired terminal UI; use 0 web for interactive work").action(() => {
+    console.error("The terminal UI has been removed. Run 0 web to open the browser console at http://127.0.0.1:48123, or use 0 chat --prompt for scripts.");
+    process.exitCode = 2;
   });
 }
 
@@ -2123,7 +2231,7 @@ function registerTuiCommand(program) {
 import { randomUUID } from "node:crypto";
 import { isAbsolute } from "node:path";
 
-// node_modules/.pnpm/@modelcontextprotocol+sdk@1.32.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
+// node_modules/.pnpm/@modelcontextprotocol+sdk@1.32.1_zod@4.6.6/node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
 import process2 from "node:process";
 var StdioServerTransport = class {
   constructor(_stdin = process2.stdin, _stdout = process2.stdout, options) {
@@ -2180,12 +2288,12 @@ var StdioServerTransport = class {
     this.onclose?.();
   }
   send(message) {
-    return new Promise((resolve28) => {
+    return new Promise((resolve29) => {
       const json = serializeMessage(message);
       if (this._stdout.write(json)) {
-        resolve28();
+        resolve29();
       } else {
-        this._stdout.once("drain", resolve28);
+        this._stdout.once("drain", resolve29);
       }
     });
   }
@@ -2293,7 +2401,7 @@ function zodForParam(param) {
   } else if (param.type === "boolean") {
     schema = external_exports.boolean();
   } else if (param.type === "object") {
-    schema = external_exports.record(external_exports.unknown());
+    schema = external_exports.record(external_exports.string(), external_exports.unknown());
   } else {
     schema = external_exports.string();
   }
@@ -2325,9 +2433,9 @@ function toolResultToMcp(result) {
   return toTextResult(text2, { success: true, output: result.output });
 }
 function withToolTimeout(task, timeoutMs) {
-  return new Promise((resolve28) => {
+  return new Promise((resolve29) => {
     const timer = setTimeout(() => {
-      resolve28({
+      resolve29({
         success: false,
         output: null,
         error: `MCP tool timed out after ${timeoutMs}ms`
@@ -2336,11 +2444,11 @@ function withToolTimeout(task, timeoutMs) {
     task.then(
       (result) => {
         clearTimeout(timer);
-        resolve28(result);
+        resolve29(result);
       },
       (error) => {
         clearTimeout(timer);
-        resolve28({
+        resolve29({
           success: false,
           output: null,
           error: error instanceof Error ? error.message : String(error)
@@ -2372,7 +2480,7 @@ function clampRateLimitToPosture(cfg, posture) {
 }
 var workflowInputsSchema = SecurityWorkflowBindingsSchema;
 async function registerWorkflowTools(server, selected, opts) {
-  const runtime = opts.backend || opts.engineUrl ? await (await import("./remote-workflow-runtime-DB52SINR.js")).createRemoteWorkflowRuntime({ backendId: opts.backend, configPath: opts.backendsConfig, sessionId: opts.session, engineUrl: opts.engineUrl, engineTokenEnv: opts.engineTokenEnv }) : await (await import("./workflow-runtime-AR627I26.js")).createCliWorkflowRuntime({
+  const runtime = opts.backend || opts.engineUrl ? await (await import("./remote-workflow-runtime-GOI4TYP5.js")).createRemoteWorkflowRuntime({ backendId: opts.backend, configPath: opts.backendsConfig, sessionId: opts.session, engineUrl: opts.engineUrl, engineTokenEnv: opts.engineTokenEnv }) : await (await import("./workflow-runtime-CQTDASFA.js")).createCliWorkflowRuntime({
     ownerId: `mcp:${randomUUID()}`,
     workspace: opts.workspace,
     target: opts.target,
@@ -2396,13 +2504,13 @@ async function registerWorkflowTools(server, selected, opts) {
     { name: "resume_scan", description: "Resume a retained scan in a selected session; this does not restart a workflow graph.", schema: external_exports.object({ sessionId: id, scanId: id, branchFromEntry: external_exports.number().int().nonnegative().optional(), timeCapMs: external_exports.number().int().positive().max(864e5).optional(), costCapUsd: external_exports.number().positive().max(1e3).optional() }).strict(), run: (args2) => sessionRuntime.resumeScan(args2) },
     { name: "get_session_events", description: "Read session events after an engine event cursor.", schema: external_exports.object({ sessionId: id, after: external_exports.number().int().nonnegative().optional() }).strict(), run: (args2) => sessionRuntime.getSessionEvents(args2.sessionId, args2.after) },
     { name: "list_sessions", description: "List live sessions on the selected engine.", schema: external_exports.object({}).strict(), run: () => sessionRuntime.listSessions() },
-    { name: "create_session", description: "Create a session within the engine's configured admission grants.", schema: external_exports.object({ config: external_exports.record(external_exports.unknown()).optional() }).strict(), run: (args2) => sessionRuntime.createSession(args2.config) },
+    { name: "create_session", description: "Create a session within the engine's configured admission grants.", schema: external_exports.object({ config: external_exports.record(external_exports.string(), external_exports.unknown()).optional() }).strict(), run: (args2) => sessionRuntime.createSession(args2.config) },
     { name: "attach_session", description: "Attach to an existing engine session without recreating it.", schema: external_exports.object({ sessionId: id }).strict(), run: (args2) => sessionRuntime.attachSession(args2.sessionId) },
     { name: "get_session", description: "Read an existing engine session.", schema: external_exports.object({ sessionId: id }).strict(), run: (args2) => sessionRuntime.getSession(args2.sessionId) },
     { name: "send_message", description: "Send a message to an engine session.", schema: external_exports.object({ sessionId: id, text: external_exports.string().min(1).max(65536) }).strict(), run: (args2) => sessionRuntime.sendMessage(args2.sessionId, args2.text) },
     { name: "continue_session", description: "Continue an engine session.", schema: external_exports.object({ sessionId: id, text: external_exports.string().max(65536).optional() }).strict(), run: (args2) => sessionRuntime.continueSession(args2.sessionId, args2.text) },
     { name: "cancel_session", description: "Explicitly cancel an engine session's active work.", schema: external_exports.object({ sessionId: id }).strict(), run: (args2) => sessionRuntime.cancelSession(args2.sessionId) },
-    { name: "resolve_decision", description: "Respond to a pending engine session decision.", schema: external_exports.object({ sessionId: id, decisionId: id, response: external_exports.record(external_exports.unknown()) }).strict(), run: (args2) => sessionRuntime.resolveDecision(args2.sessionId, args2.decisionId, args2.response) },
+    { name: "resolve_decision", description: "Respond to a pending engine session decision.", schema: external_exports.object({ sessionId: id, decisionId: id, response: external_exports.record(external_exports.string(), external_exports.unknown()) }).strict(), run: (args2) => sessionRuntime.resolveDecision(args2.sessionId, args2.decisionId, args2.response) },
     { name: "list_saved_sessions", description: "List retained session snapshots on the engine.", schema: external_exports.object({}).strict(), run: () => sessionRuntime.listSavedSessions() },
     { name: "resume_session", description: "Resume a saved snapshot as a new session; admission grants are revalidated.", schema: external_exports.object({ savedSessionId: id }).strict(), run: (args2) => sessionRuntime.resumeSession(args2.savedSessionId) },
     { name: "list_templates", description: "List workflow templates and supported target types.", schema: external_exports.object({}).strict(), run: () => runtime.listTemplates() },
@@ -2410,7 +2518,7 @@ async function registerWorkflowTools(server, selected, opts) {
     { name: "list_runs", description: "List workflow runs visible to this execution owner on the selected engine.", schema: external_exports.object({}).strict(), run: () => runtime.listRuns() },
     { name: "list_workflows", description: "List saved workflow definitions.", schema: external_exports.object({}).strict(), run: () => runtime.listWorkflows() },
     { name: "get_workflow", description: "Read a saved workflow and its revision.", schema: external_exports.object({ id }).strict(), run: (args2) => runtime.getWorkflow(args2.id) },
-    { name: "save_workflow", description: "Validate and save a workflow definition with optional revision protection.", schema: external_exports.object({ definition: external_exports.record(external_exports.unknown()), expectedRevision: external_exports.number().int().positive().optional() }).strict(), run: (args2) => runtime.saveWorkflow(args2.definition, args2.expectedRevision) },
+    { name: "save_workflow", description: "Validate and save a workflow definition with optional revision protection.", schema: external_exports.object({ definition: external_exports.record(external_exports.string(), external_exports.unknown()), expectedRevision: external_exports.number().int().positive().optional() }).strict(), run: (args2) => runtime.saveWorkflow(args2.definition, args2.expectedRevision) },
     { name: "start_run", description: "Start a template or saved workflow using 0's configured model provider. Returns a run ID promptly. Target must be within the server's authorized workspace or live scope.", schema: external_exports.object({ sessionId: id.optional(), templateId: id.optional(), workflowId: id.optional(), revision: external_exports.number().int().positive().optional(), target: external_exports.string().trim().min(1).max(4096), idempotencyKey: id.optional(), inputs: workflowInputsSchema.optional(), allowApply: external_exports.boolean().optional(), timeCapMs: external_exports.number().int().positive().max(864e5).optional(), costCapUsd: external_exports.number().positive().max(1e3).optional() }).strict(), run: (args2) => {
       if (Boolean(args2.templateId) === Boolean(args2.workflowId)) throw new Error("Select exactly one templateId or workflowId.");
       if (args2.workflowId && !args2.revision) throw new Error("Saved workflow runs require a pinned revision.");
@@ -2670,11 +2778,11 @@ function rowToFinding(row) {
   };
 }
 async function openStore(dbPath) {
-  const { MemoryStore } = await import("./dist-TQMHMSBZ.js");
+  const { MemoryStore } = await import("./dist-ONIRKDH6.js");
   return new MemoryStore(dbPath);
 }
 async function loadFinding2(dbPath, findingId) {
-  const { osecDB: osecDB2 } = await import("./dist-RKLQIXDT.js");
+  const { osecDB: osecDB2 } = await import("./dist-QLMPTFT7.js");
   const db = new osecDB2(dbPath);
   try {
     const rows = db.listFindings({ limit: 5e3 });
@@ -2749,7 +2857,7 @@ async function runMemoryRemove(id, dbPath) {
 async function runMarkFp(findingId, opts) {
   const row = await loadFinding2(opts.dbPath, findingId);
   const finding = rowToFinding(row);
-  const { osecDB: osecDB2 } = await import("./dist-RKLQIXDT.js");
+  const { osecDB: osecDB2 } = await import("./dist-QLMPTFT7.js");
   const db = new osecDB2(opts.dbPath);
   try {
     db.updateFindingTriage(row.id, "suppressed", opts.reason);
@@ -6464,7 +6572,7 @@ function registerIngestCommand(program) {
         reviewKernelCrashSubsystems,
         verifyStandaloneKernelReproducer,
         verifyKernelCrash
-      } = await import("./dist-TQMHMSBZ.js");
+      } = await import("./dist-ONIRKDH6.js");
       let kernelBuild;
       if (opts.kernelTree) {
         kernelBuild = prepareKernelVmArtifacts({
@@ -6887,7 +6995,7 @@ function registerKernelCommand(program) {
         checkAlreadyFixed,
         rankKernelHypothesesWithJev,
         verifyStaticKernelFinding
-      } = await import("./dist-TQMHMSBZ.js");
+      } = await import("./dist-ONIRKDH6.js");
       const noveltyExcluded = opts.upstreamTree ? findings.flatMap((finding) => {
         const path = finding.reviewAnnotation?.path ?? finding.evidence.request.match(/([^\s:]+\.[ch]):\d+/)?.[1];
         if (!path) return [];
@@ -6934,7 +7042,7 @@ function registerKernelCommand(program) {
     try {
       const config = jevConfigFromEnvironment("kernel", process.env);
       if (!config) throw new Error("Jev commit prepass requires ZERO_JEV_FEATURES=kernel and a configured provider");
-      const { rankKernelCommitsWithJev } = await import("./dist-TQMHMSBZ.js");
+      const { rankKernelCommitsWithJev } = await import("./dist-ONIRKDH6.js");
       const result = await rankKernelCommitsWithJev({
         tree: opts.tree,
         evaluator: createJevEvaluator(config),
@@ -6958,7 +7066,7 @@ function registerKernelCommand(program) {
     try {
       const config = jevConfigFromEnvironment("kernel", process.env);
       if (!config) throw new Error("Jev source prepass requires ZERO_JEV_FEATURES=kernel and a configured provider");
-      const { runKernelSourceJevPrepass } = await import("./dist-TQMHMSBZ.js");
+      const { runKernelSourceJevPrepass } = await import("./dist-ONIRKDH6.js");
       const result = await runKernelSourceJevPrepass({
         tree: opts.tree,
         subtree: opts.subtree,
@@ -6992,7 +7100,7 @@ function registerKernelCommand(program) {
       if (crashes.length === 0) throw new Error("Crash input must be a CrashRecord[] or an object with a crashes array");
       const records = crashes.filter((c) => !!c && typeof c === "object" && "id" in c && "summary" in c && typeof c.id === "string" && typeof c.summary === "string");
       if (records.length !== crashes.length) throw new Error("Every crash record requires string id and summary fields");
-      const { rankCrashesWithJev, crashSummaryFromTriage } = await import("./dist-TQMHMSBZ.js");
+      const { rankCrashesWithJev, crashSummaryFromTriage } = await import("./dist-ONIRKDH6.js");
       const result = await rankCrashesWithJev(
         records,
         createJevEvaluator(config)
@@ -7020,7 +7128,7 @@ function registerKernelCommand(program) {
       const details = parsePositiveInt(opts.details, "--details", 100);
       const detailDelayMs = parsePositiveInt(opts.detailDelay, "--detail-delay", 5e3);
       const subsystems = opts.subsystems.split(",").map((value) => value.trim()).filter(Boolean);
-      const { defaultSyzbotFetcher, mineSyzbotQueue, toHuntCandidates } = await import("./dist-TQMHMSBZ.js");
+      const { defaultSyzbotFetcher, mineSyzbotQueue, toHuntCandidates } = await import("./dist-ONIRKDH6.js");
       const result = await mineSyzbotQueue({
         fetch: defaultSyzbotFetcher,
         fetchDetail: defaultSyzbotFetcher,
@@ -7078,7 +7186,7 @@ function registerKernelCommand(program) {
           `Invalid output format '${opts.output}'. Valid: ${VALID_OUTPUT_FORMATS2.join(", ")}`
         );
       }
-      const { runKernelVariantHunt } = await import("./dist-TQMHMSBZ.js");
+      const { runKernelVariantHunt } = await import("./dist-ONIRKDH6.js");
       const report = await runKernelVariantHunt({
         tree: opts.tree,
         advisory: opts.advisory,
@@ -7181,7 +7289,7 @@ function resolveOutputDir(opts, scanId) {
   return join9(homedir2(), "0", "disclosures", `scan-${scanId.slice(0, 8)}`);
 }
 async function disclose(findingId, opts) {
-  const { osecDB: osecDB2 } = await import("./dist-RKLQIXDT.js");
+  const { osecDB: osecDB2 } = await import("./dist-QLMPTFT7.js");
   const db = new osecDB2(opts.dbPath);
   try {
     let routeDroppedFinding2 = function(args2) {
@@ -7633,7 +7741,7 @@ async function runExploit(opts) {
     classifyPrimitiveFromDmesg,
     describeKernelPrimitive,
     runWeaponization
-  } = await import("./dist-TQMHMSBZ.js");
+  } = await import("./dist-ONIRKDH6.js");
   const rawFinding = readJson(opts.findingPath, "finding");
   let finding;
   try {
@@ -7696,7 +7804,7 @@ async function runExploit(opts) {
 }
 async function exploitAction(opts) {
   if (opts.agent) {
-    const { agentFromExploitOpts } = await import("./exploit-agent-Y2P4GFIY.js");
+    const { agentFromExploitOpts } = await import("./exploit-agent-4E4HXKUA.js");
     process.exitCode = await agentFromExploitOpts({
       ...opts.task ? { task: opts.task } : {},
       ...opts.flagPath ? { flagPath: opts.flagPath } : {},
@@ -7711,7 +7819,7 @@ async function exploitAction(opts) {
     return;
   }
   if (opts.autoclimb) {
-    const { autoclimbFromExploitOpts } = await import("./exploit-autoclimb-YRZ3TMS2.js");
+    const { autoclimbFromExploitOpts } = await import("./exploit-autoclimb-5GRXI6VQ.js");
     process.exitCode = await autoclimbFromExploitOpts({
       ...opts.bugSpec ? { bugSpec: opts.bugSpec } : {},
       ...opts.bootScript ? { bootScript: opts.bootScript } : {},
@@ -7725,7 +7833,7 @@ async function exploitAction(opts) {
     throw new Error("missing required flag: --finding <path>");
   }
   if (opts.climb) {
-    const { runClimb } = await import("./exploit-climb-4LEY4SDW.js");
+    const { runClimb } = await import("./exploit-climb-AHQEJ2I2.js");
     let loopBoots = 8;
     if (opts.loopBoots !== void 0) {
       loopBoots = parseInt(opts.loopBoots, 10);
@@ -7898,7 +8006,7 @@ async function runHunt(opts) {
     makeLloreJudge,
     makeHuntProveStage,
     prepare: prepare2
-  } = await import("./dist-TQMHMSBZ.js");
+  } = await import("./dist-ONIRKDH6.js");
   const log = opts.log ?? (() => {
   });
   const runtime = opts.runtime ?? "api";
@@ -8246,7 +8354,7 @@ function parseWitnessMode(raw) {
 }
 async function recencyAction(opts) {
   if (!opts.tree) throw new Error("missing required flag: --tree <kernel source tree>");
-  const { runRecencyHunt, renderRecencyReportMarkdown } = await import("./dist-TQMHMSBZ.js");
+  const { runRecencyHunt, renderRecencyReportMarkdown } = await import("./dist-ONIRKDH6.js");
   const tree = resolve14(opts.tree);
   const runtime = opts.runtime ?? "api";
   const modelDir = opts.modelDir ? resolve14(opts.modelDir) : join10(tree, ".recency-models");
@@ -8323,9 +8431,271 @@ function registerRecencyHuntCommand(program) {
   });
 }
 
+// packages/cli/src/commands/lens-synth.ts
+import { createHash as createHash5 } from "node:crypto";
+import { readFileSync as readFileSync13 } from "node:fs";
+import { resolve as resolve15 } from "node:path";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseFixtures(value, label) {
+  if (value === void 0) return [];
+  if (!Array.isArray(value)) throw new Error(`${label} must be an array`);
+  return value.map((entry, i) => {
+    if (!isRecord(entry)) throw new Error(`${label}[${i}] must be an object`);
+    const id = entry.id;
+    const path = entry.path;
+    if (typeof id !== "string" || id.trim() === "") throw new Error(`${label}[${i}].id must be a non-empty string`);
+    if (typeof path !== "string" || path.trim() === "") throw new Error(`${label}[${i}].path must be a non-empty string`);
+    const fixture = { id, path };
+    if (typeof entry.note === "string") fixture.note = entry.note;
+    if (typeof entry.expectedCwe === "string") fixture.expectedCwe = entry.expectedCwe;
+    if (typeof entry.expectedFile === "string") fixture.expectedFile = entry.expectedFile;
+    if (typeof entry.expectedLine === "number" && Number.isFinite(entry.expectedLine)) {
+      fixture.expectedLine = entry.expectedLine;
+    }
+    if (Array.isArray(entry.expectedRange) && entry.expectedRange.length === 2 && typeof entry.expectedRange[0] === "number" && typeof entry.expectedRange[1] === "number") {
+      fixture.expectedRange = [entry.expectedRange[0], entry.expectedRange[1]];
+    }
+    if (typeof entry.contentDigest === "string") fixture.contentDigest = entry.contentDigest;
+    if (typeof entry.cleanProvenance === "string") fixture.cleanProvenance = entry.cleanProvenance;
+    return fixture;
+  });
+}
+function parseMissInputFile(raw) {
+  if (!isRecord(raw)) throw new Error("miss-input must be a JSON object");
+  const missesRaw = isRecord(raw.misses) ? raw.misses : {};
+  const corpusRaw = isRecord(raw.corpus) ? raw.corpus : {};
+  const misses = {
+    ...Array.isArray(missesRaw.confirmedMisses) ? { confirmedMisses: missesRaw.confirmedMisses } : {},
+    ...Array.isArray(missesRaw.incompleteCoverage) ? { incompleteCoverage: missesRaw.incompleteCoverage } : {},
+    ...Array.isArray(missesRaw.curatedCandidates) ? { curatedCandidates: missesRaw.curatedCandidates } : {}
+  };
+  const heldOutFixtures = parseFixtures(corpusRaw.heldOut, "corpus.heldOut");
+  const corpus = {
+    positives: parseFixtures(corpusRaw.positives, "corpus.positives"),
+    negativeControls: parseFixtures(corpusRaw.negativeControls, "corpus.negativeControls"),
+    ...heldOutFixtures.length > 0 ? { heldOut: heldOutFixtures } : {},
+    ...typeof corpusRaw.baselineDigest === "string" ? { baselineDigest: corpusRaw.baselineDigest } : {}
+  };
+  if (corpus.positives.length === 0) {
+    throw new Error("corpus.positives must contain at least one fixture (the seeded miss) \u2014 the loop is fail-closed without it");
+  }
+  if (corpus.negativeControls.length === 0) {
+    throw new Error("corpus.negativeControls must contain at least one fixture \u2014 the loop cannot measure FP regression without it");
+  }
+  if (!corpus.heldOut || corpus.heldOut.length === 0) {
+    throw new Error("corpus.heldOut must contain at least one fixture \u2014 held-out positives are required to demonstrate generalisation beyond development misses");
+  }
+  return { misses, corpus };
+}
+async function harvestBenchMisses(fromBench, manifestPath) {
+  const ledger = await loadLedger(resolve15(fromBench));
+  const entry = lastGreen(ledger) ?? ledger.entries[ledger.entries.length - 1];
+  if (!entry) throw new Error(`--from-bench: ledger ${fromBench} has no entries to harvest`);
+  const manifest = await loadManifest(resolve15(manifestPath));
+  const result = harvestMissesFromLedgerEntry(entry, manifest);
+  return { misses: result.misses, result };
+}
+function trialCount(value) {
+  const count = value ?? 2;
+  if (!Number.isSafeInteger(count) || count < 2 || count > 10) throw new Error("--trials must be an integer between 2 and 10");
+  return count;
+}
+async function runLensSynthesisInput(input, opts, deps = {}) {
+  const trials = trialCount(opts.trials);
+  const log = deps.log ?? (() => {
+  });
+  const probe = deps.probe ?? makeFinderLensProbe({ log });
+  return runLensSynthesisLoop(input, {
+    ...deps.model ? { model: deps.model } : {},
+    ...opts.model ? { modelId: opts.model } : {},
+    probe,
+    ...opts.registry ? { registryPath: resolve15(opts.registry) } : {},
+    maxRegistrations: opts.maxRegister ?? 1,
+    dryRun: !opts.promote,
+    trials,
+    ...opts.signal ? { signal: opts.signal } : {},
+    log
+  });
+}
+async function runLensSynthCommand(opts, deps = {}) {
+  const raw = JSON.parse(readFileSync13(resolve15(opts.missInput), "utf8"));
+  let input = parseMissInputFile(raw);
+  if (opts.fromBench) {
+    if (!opts.manifest) throw new Error("--from-bench requires --manifest");
+    const { misses } = await harvestBenchMisses(opts.fromBench, opts.manifest);
+    input = { ...input, misses: mergeHarvestedMisses(input.misses, misses) };
+    deps.log?.(`[lens-synth] harvested ${misses.length} bench miss(es) from ${opts.fromBench}`);
+  }
+  return runLensSynthesisInput(input, opts, deps);
+}
+async function watchLensSynthCommand(opts, deps = {}) {
+  const inputPath = resolve15(opts.missInput);
+  const log = deps.log ?? (() => {
+  });
+  const requestedInterval = opts.pollIntervalMs ?? 2e3;
+  const pollIntervalMs = Number.isFinite(requestedInterval) ? Math.max(100, Math.floor(requestedInterval)) : 2e3;
+  const sleep = deps.sleep ?? ((milliseconds) => new Promise((done) => setTimeout(done, milliseconds)));
+  let previousRevision;
+  while (!deps.signal?.aborted) {
+    try {
+      const bytes = readFileSync13(inputPath);
+      const revision2 = createHash5("sha256").update(bytes).digest("hex");
+      if (revision2 !== previousRevision) {
+        previousRevision = revision2;
+        const input = parseMissInputFile(JSON.parse(bytes.toString("utf8")));
+        const result = await runLensSynthesisInput(input, opts, deps);
+        deps.onResult?.(result);
+      }
+    } catch (cause) {
+      const error = cause instanceof Error ? cause : new Error(String(cause));
+      const revision2 = `error:${error.name}:${error.message}`;
+      if (revision2 !== previousRevision) {
+        previousRevision = revision2;
+        if (deps.onError) deps.onError(error);
+        else log(`[lens-synth] input revision rejected: ${error.message}`);
+      }
+    }
+    if (deps.signal?.aborted) return;
+    const signal = deps.signal;
+    if (!signal) {
+      await sleep(pollIntervalMs);
+      continue;
+    }
+    if (signal.aborted) return;
+    await new Promise((resume) => {
+      const onAbort = () => {
+        signal.removeEventListener("abort", onAbort);
+        resume();
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
+      void sleep(pollIntervalMs).then(() => {
+        signal.removeEventListener("abort", onAbort);
+        resume();
+      });
+    });
+  }
+}
+function formatLensSynthResult(result, dryRun2) {
+  const lines = [
+    `captured ${result.candidatesCaptured} miss candidate(s) \u2192 ${result.clusters} cluster(s) \u2192 ${result.synthesized.length} synthesized`
+  ];
+  for (const validation of result.validations) {
+    lines.push(`  validate ${validation.lensId}: ${validation.passed ? "CHAMPION" : "rejected"} \u2014 ${validation.reason}`);
+  }
+  if (dryRun2) {
+    lines.push(`dry-run: ${result.validations.filter((validation) => validation.passed).length} champion(s) would register (nothing written)`);
+  } else {
+    lines.push(
+      result.registered.length > 0 ? `REGISTERED ${result.registered.length} lens(es): ${result.registered.map((registered) => registered.uid).join(", ")}` : "registered 0 lenses"
+    );
+  }
+  for (const rejected of result.rejected) lines.push(`  rejected ${rejected.id}: ${rejected.reason}`);
+  for (const warning of result.warnings) lines.push(`  warning: ${warning}`);
+  return lines.join("\n");
+}
+function formatLensRegistryStatus(status) {
+  const lines = [
+    `registry: ${status.path}`,
+    `state: ${status.valid ? "valid" : "INVALID"}`,
+    `exists: ${status.exists ? "yes" : "no"}`,
+    `active lenses: ${status.activeLensCount}`,
+    `ledger entries: ${status.ledgerEntries}`,
+    `unbound archetypes: ${status.unboundArchetypes}`
+  ];
+  if (status.error) lines.push(`error: ${status.error}`);
+  return lines.join("\n");
+}
+function registerLensSynthCommand(program) {
+  program.command("lens-synth").description("Improve appsec detection coverage from curated missed findings").option("--miss-input <path>", "curated miss-input JSON ({ misses, corpus })").option("--registry <path>", "durable overlay path (default: ~/.0/lenses/appsec-archetypes.json)").option("--max-register <n>", "cap promoted champions per input revision", (value) => Number.parseInt(value, 10)).option("-m, --model <id>", "synthesis model override").option("--promote", "persist a validated champion to the durable overlay", false).option("--trials <n>", "repeated validation trials (2\u201310; default 2)", Number).option("--from-bench <ledger>", "harvest the champion's false-negatives from a benchmark ledger into the curated misses (requires --manifest)").option("--manifest <path>", "bench manifest path (ground-truth vuln class + sink); required with --from-bench").option("--watch", "poll the miss-input and process each new content revision", false).option("--poll-interval <ms>", "watch polling interval (minimum 100ms)", "2000").option("--status", "show the active durable overlay and promotion ledger", false).option("--rollback <lens-id>", "retire one previously promoted overlay lens").option("--json", "print machine-readable output", false).action(async (opts) => {
+    try {
+      const registry = opts.registry ? resolve15(opts.registry) : void 0;
+      if (opts.status && opts.rollback) throw new Error("--status and --rollback cannot be combined");
+      if (opts.status) {
+        const status = inspectLensRegistry(registry);
+        process.stdout.write(opts.json ? `${JSON.stringify(status, null, 2)}
+` : `${formatLensRegistryStatus(status)}
+`);
+        if (!status.valid) process.exitCode = 3;
+        return;
+      }
+      if (opts.rollback) {
+        const outcome = retireArchetype(String(opts.rollback), { ...registry ? { registryPath: registry } : {} });
+        process.stdout.write(
+          opts.json ? `${JSON.stringify(outcome, null, 2)}
+` : outcome.retired ? `RETIRED ${outcome.id} from ${outcome.registryPath}
+` : `not retired ${outcome.id}: ${outcome.reason ?? "unknown reason"}
+`
+        );
+        if (!outcome.retired) process.exitCode = 3;
+        return;
+      }
+      if (!opts.missInput) throw new Error("--miss-input is required unless --status or --rollback is used");
+      if (opts.maxRegister !== void 0 && (!Number.isInteger(opts.maxRegister) || opts.maxRegister < 0)) {
+        throw new Error("--max-register must be a non-negative integer");
+      }
+      if (opts.fromBench && !opts.manifest) throw new Error("--from-bench requires --manifest");
+      if (opts.fromBench && opts.watch) throw new Error("--from-bench cannot be combined with --watch");
+      const pollIntervalMs = Number.parseInt(opts.pollInterval ?? "2000", 10);
+      if (!Number.isInteger(pollIntervalMs) || pollIntervalMs < 100) {
+        throw new Error("--poll-interval must be an integer of at least 100ms");
+      }
+      const request = {
+        missInput: String(opts.missInput),
+        ...registry ? { registry } : {},
+        ...opts.maxRegister !== void 0 ? { maxRegister: opts.maxRegister } : {},
+        ...opts.model ? { model: String(opts.model) } : {},
+        promote: Boolean(opts.promote),
+        trials: trialCount(opts.trials),
+        ...opts.fromBench ? { fromBench: String(opts.fromBench) } : {},
+        ...opts.manifest ? { manifest: resolve15(String(opts.manifest)) } : {}
+      };
+      const printResult = (result) => {
+        process.stdout.write(
+          opts.json ? `${JSON.stringify(result, null, 2)}
+` : `${formatLensSynthResult(result, !opts.promote)}
+`
+        );
+      };
+      const log = (message) => {
+        process.stderr.write(`${message}
+`);
+      };
+      if (!opts.watch) {
+        printResult(await runLensSynthCommand(request, { log }));
+        return;
+      }
+      const controller = new AbortController();
+      const stop = () => controller.abort();
+      process.once("SIGINT", stop);
+      process.once("SIGTERM", stop);
+      try {
+        await watchLensSynthCommand(
+          { ...request, pollIntervalMs },
+          {
+            log,
+            signal: controller.signal,
+            onResult: printResult,
+            onError: (error) => process.stderr.write(`lens-synth watch: ${error.message}
+`)
+          }
+        );
+      } finally {
+        process.off("SIGINT", stop);
+        process.off("SIGTERM", stop);
+      }
+    } catch (error) {
+      process.stderr.write(`lens-synth: ${error instanceof Error ? error.message : String(error)}
+`);
+      process.exitCode = 3;
+    }
+  });
+}
+
 // packages/cli/src/commands/memsafety.ts
 import { existsSync as existsSync12, mkdirSync as mkdirSync8, realpathSync, writeFileSync as writeFileSync10 } from "node:fs";
-import { resolve as resolve15, join as join11, sep } from "node:path";
+import { resolve as resolve16, join as join11, sep } from "node:path";
 var VALID_LANGUAGES = /* @__PURE__ */ new Set(["c", "cpp", "rust"]);
 var VALID_BUILD_SYSTEMS3 = /* @__PURE__ */ new Set([
   "cargo",
@@ -8350,7 +8720,7 @@ function detectMemSafetyBuild(sourceRoot, exists2 = existsSync12) {
 function resolveArtifactDir(value, sourceRoot) {
   const raw = value?.trim();
   if (!raw) return void 0;
-  const artifactDir = resolve15(raw);
+  const artifactDir = resolve16(raw);
   const preparedRoot = realpathSync(sourceRoot);
   mkdirSync8(artifactDir, { recursive: true, mode: 448 });
   const canonicalArtifactDir = realpathSync(artifactDir);
@@ -8362,7 +8732,7 @@ function resolveArtifactDir(value, sourceRoot) {
   return canonicalArtifactDir;
 }
 async function runMemSafety(opts) {
-  const { prepare: prepare2, runMemSafetyScan } = await import("./dist-TQMHMSBZ.js");
+  const { prepare: prepare2, runMemSafetyScan } = await import("./dist-ONIRKDH6.js");
   const log = opts.log ?? (() => {
   });
   const prepared = await prepare2(
@@ -8373,11 +8743,11 @@ async function runMemSafety(opts) {
       if (e.message) log(`[memsafety:source] ${e.message}`);
     }
   );
-  const sourceRoot = resolve15(prepared.resolvedTarget);
+  const sourceRoot = resolve16(prepared.resolvedTarget);
   try {
     let scopeRoot = sourceRoot;
     if (opts.subsystem && opts.subsystem.trim() !== "") {
-      const scoped = resolve15(join11(sourceRoot, opts.subsystem));
+      const scoped = resolve16(join11(sourceRoot, opts.subsystem));
       if (scoped !== sourceRoot && !scoped.startsWith(sourceRoot + sep)) {
         throw new Error(`--subsystem '${opts.subsystem}' escapes the source tree`);
       }
@@ -8502,7 +8872,7 @@ function parseArtifactOptions(opts) {
     throw new Error("--artifact-max-bytes must be at least 65536");
   }
   return {
-    artifactDir: resolve15(artifactDir),
+    artifactDir: resolve16(artifactDir),
     artifactMaxBytes: maxBytes
   };
 }
@@ -8526,7 +8896,7 @@ async function memsafetyAction(target, opts) {
     log: (m) => process.stderr.write(m + "\n")
   });
   const json = JSON.stringify(outcome.result, null, 2);
-  if (opts.output) writeFileSync10(resolve15(opts.output), json + "\n", "utf8");
+  if (opts.output) writeFileSync10(resolve16(opts.output), json + "\n", "utf8");
   else process.stdout.write(json + "\n");
   process.exitCode = outcome.exitCode;
 }
@@ -8546,9 +8916,9 @@ function registerMemsafetyCommand(program) {
       const reason = err instanceof Error ? err.message : String(err);
       const json = JSON.stringify({ mode: "memsafety", error: reason }, null, 2);
       if (opts.output) {
-        const { writeFileSync: writeFileSync19 } = await import("node:fs");
+        const { writeFileSync: writeFileSync18 } = await import("node:fs");
         try {
-          writeFileSync19(resolve15(opts.output), json + "\n", "utf8");
+          writeFileSync18(resolve16(opts.output), json + "\n", "utf8");
         } catch {
           process.stderr.write(json + "\n");
         }
@@ -8559,7 +8929,7 @@ function registerMemsafetyCommand(program) {
 }
 
 // packages/cli/src/commands/assumption-hunt.ts
-import { resolve as resolve16 } from "node:path";
+import { resolve as resolve17 } from "node:path";
 function parseWitnessMode2(raw) {
   if (raw === void 0) return void 0;
   const m = raw.trim();
@@ -8569,16 +8939,16 @@ function parseWitnessMode2(raw) {
   return m;
 }
 async function runAssumptionHuntCli(sourceRoot, opts) {
-  const { runAssumptionHunt, makeSkepticVerifier } = await import("./dist-TQMHMSBZ.js");
+  const { runAssumptionHunt, makeSkepticVerifier } = await import("./dist-ONIRKDH6.js");
   const log = (m) => process.stderr.write(m + "\n");
   const runtime = opts.runtime ?? "api";
-  const root = resolve16(sourceRoot);
+  const root = resolve17(sourceRoot);
   const subsystem = opts.subsystem?.trim() || "subsystem";
   const files = (opts.files ?? "").split(",").map((s) => s.trim()).filter(Boolean);
   if (files.length === 0) {
     throw new Error("--files is required: a comma-separated list of subsystem source files (repo-relative to <source-root>)");
   }
-  const modelPath = opts.modelPath ? resolve16(opts.modelPath) : resolve16(root, `.0/assumption-models/${subsystem.replaceAll("/", "_")}.json`);
+  const modelPath = opts.modelPath ? resolve17(opts.modelPath) : resolve17(root, `.0/assumption-models/${subsystem.replaceAll("/", "_")}.json`);
   const models = opts.models ? opts.models.split(",").map((s) => s.trim()).filter(Boolean) : void 0;
   const verify = opts.skipHunt || opts.noVerify ? void 0 : (
     // `finderModels` decorrelates the refute pass from the finder fan-out
@@ -8604,7 +8974,7 @@ async function runAssumptionHuntCli(sourceRoot, opts) {
     ...models ? { finderModels: models } : {},
     ...opts.finderTargeting === false ? { finderTargeting: false } : {},
     ...opts.dualView === false ? { dualView: false } : {},
-    ...opts.excerptDir ? { excerptDir: resolve16(opts.excerptDir) } : {},
+    ...opts.excerptDir ? { excerptDir: resolve17(opts.excerptDir) } : {},
     ...opts.dynamicWitness ? {
       dynamicWitness: {
         runtime,
@@ -8687,8 +9057,8 @@ function registerAssumptionHuntCommand(program) {
       const outcome = await runAssumptionHuntCli(sourceRoot, opts);
       const json = JSON.stringify(outcome.result, null, 2);
       if (opts.output) {
-        const { writeFileSync: writeFileSync19 } = await import("node:fs");
-        writeFileSync19(resolve16(opts.output), json + "\n", "utf8");
+        const { writeFileSync: writeFileSync18 } = await import("node:fs");
+        writeFileSync18(resolve17(opts.output), json + "\n", "utf8");
       } else process.stdout.write(json + "\n");
       process.exitCode = outcome.exitCode;
     } catch (err) {
@@ -8700,8 +9070,8 @@ function registerAssumptionHuntCommand(program) {
 }
 
 // packages/cli/src/commands/specdrift.ts
-import { readFileSync as readFileSync13, writeFileSync as writeFileSync11 } from "node:fs";
-import { basename as basename4, resolve as resolve17 } from "node:path";
+import { readFileSync as readFileSync14, writeFileSync as writeFileSync11 } from "node:fs";
+import { basename as basename4, resolve as resolve18 } from "node:path";
 function parsePositive4(flag, raw, dflt) {
   if (raw === void 0) return dflt;
   const n = parseInt(raw, 10);
@@ -8711,8 +9081,8 @@ function parsePositive4(flag, raw, dflt) {
 async function runSpecdriftExtract(opts) {
   if (!opts.spec) throw new Error("missing required flag: --spec <path>");
   const maxInvariants = parsePositive4("--max-invariants", opts.maxInvariants, 40);
-  const specPath = resolve17(opts.spec);
-  const specText = readFileSync13(specPath, "utf8");
+  const specPath = resolve18(opts.spec);
+  const specText = readFileSync14(specPath, "utf8");
   return extractSpecInvariants({
     specName: opts.specName ?? basename4(specPath),
     specText,
@@ -8733,8 +9103,8 @@ async function runSpecdriftSourceWorkflow(opts, stage) {
   const maxCandidatesPerInvariant = parsePositive4("--max-candidates-per-invariant", opts.maxCandidatesPerInvariant, 5);
   const maxHypotheses = parsePositive4("--max-hypotheses", opts.maxHypotheses, 20);
   const timeout = parsePositive4("--timeout", opts.timeout, 6e5);
-  const specPath = resolve17(opts.spec);
-  const specText = readFileSync13(specPath, "utf8");
+  const specPath = resolve18(opts.spec);
+  const specText = readFileSync14(specPath, "utf8");
   const prepared = await prepare(opts.source, "source-code", { timeout }, (e) => {
     if (e.message) process.stderr.write(`[specdrift:source] ${e.message}
 `);
@@ -8743,7 +9113,7 @@ async function runSpecdriftSourceWorkflow(opts, stage) {
     const input = {
       specName: opts.specName ?? basename4(specPath),
       specText,
-      sourceRoot: resolve17(prepared.resolvedTarget),
+      sourceRoot: resolve18(prepared.resolvedTarget),
       maxInvariants,
       maxFiles,
       maxCandidatesPerInvariant
@@ -8757,14 +9127,14 @@ async function writeJsonResult(fn, output2, stage = "extract") {
   try {
     const result = await fn();
     const json = JSON.stringify(result, null, 2);
-    if (output2) writeFileSync11(resolve17(output2), json + "\n", "utf8");
+    if (output2) writeFileSync11(resolve18(output2), json + "\n", "utf8");
     else process.stdout.write(json + "\n");
   } catch (err) {
     const reason = err instanceof Error ? err.message : String(err);
     const json = JSON.stringify({ mode: "specdrift", stage, error: reason }, null, 2);
     if (output2) {
       try {
-        writeFileSync11(resolve17(output2), json + "\n", "utf8");
+        writeFileSync11(resolve18(output2), json + "\n", "utf8");
       } catch {
         process.stderr.write(json + "\n");
       }
@@ -8786,8 +9156,8 @@ function registerSpecdriftCommand(program) {
 }
 
 // packages/cli/src/commands/protocol-check.ts
-import { readFileSync as readFileSync14 } from "node:fs";
-import { resolve as resolve18 } from "node:path";
+import { readFileSync as readFileSync15 } from "node:fs";
+import { resolve as resolve19 } from "node:path";
 function resolveNativeRuntime(runtimeFlag) {
   const choice = (runtimeFlag ?? "auto").toLowerCase();
   const timeout = 6e4;
@@ -8806,9 +9176,9 @@ function resolveNativeRuntime(runtimeFlag) {
   return rt;
 }
 function readExcerpt(path, label) {
-  const abs = resolve18(path);
+  const abs = resolve19(path);
   try {
-    return readFileSync14(abs, "utf8");
+    return readFileSync15(abs, "utf8");
   } catch (err) {
     throw new Error(
       `failed to read ${label} from ${abs}: ${err instanceof Error ? err.message : String(err)}`
@@ -8932,8 +9302,8 @@ function registerProtocolCheckCommand(program) {
 }
 
 // packages/cli/src/commands/cve.ts
-import { readFileSync as readFileSync15 } from "node:fs";
-import { resolve as resolve19 } from "node:path";
+import { readFileSync as readFileSync16 } from "node:fs";
+import { resolve as resolve20 } from "node:path";
 var VALID_FORMATS2 = ["json", "table"];
 var EXIT_OK = 0;
 var EXIT_USER_ERROR = 1;
@@ -8965,10 +9335,10 @@ function parseAttempts(input, fallback = 5) {
   return parsed;
 }
 function loadArtifactsFile(path) {
-  const abs = resolve19(path);
+  const abs = resolve20(path);
   let raw;
   try {
-    raw = readFileSync15(abs, "utf-8");
+    raw = readFileSync16(abs, "utf-8");
   } catch (err) {
     throw new Error(`failed to read --artifacts ${abs}: ${err instanceof Error ? err.message : String(err)}`);
   }
@@ -9944,7 +10314,7 @@ function resolveConsoleAutonomyMode(opts) {
 function registerConsoleCommand(program) {
   program.command("console").alias("chat").description(
     "Run a headless chat prompt; interactive conversations use 0 web"
-  ).option("--target <url>", "Engagement target the tools operate against (optional; can be named in-chat)").option("--scope <file>", "Initial policy for the optional scope plugin; activate with `0 plugin enable scope`").option("--finding <id>", "Focus the chat on one persisted finding").option("--finding-intent <intent>", "Finding workflow: investigate, verify, or draft_fix").option("--db-path <path>", "Persistent findings database (defaults to ZERO_DB_PATH or the local store)").option("-m, --model <id>", "Override the LLM model id (else provider default)").option("--role <role>", "Tool set to expose: audit|review|discovery|attack|verify (default audit = every tool)").option("--mode <mode>", "Approval mode: standard|recon|copilot|yolo (default yolo)").option("--yolo", "Shortcut for --mode yolo (no per-action prompts; independent credential, private-network and sandbox protections remain).").option("--autonomy <mode>", "Alias of --mode (standard|copilot|yolo|recon); --mode/--yolo take precedence.").option("--max-tool-calls <n>", "Safety cap on tool-call rounds per message", String(DEFAULT_MAX_TOOL_ITERATIONS)).option("--allow-scanners", "Expose generic-scanner tool wrappers (sqlmap/nikto/\u2026); default off").option("--resume [id]", "With a headless prompt, reopen a saved session by id or unique prefix; use browser history for a picker.").option("--continue", "With a headless prompt, continue the most recent saved console session.").option("-p, --print [prompt]", "Non-interactive: run ONE prompt through the engine, print the result, and exit (no TUI). Reads the prompt from the argument or piped stdin. Combine with --continue/--resume to query a saved session. Also reachable as `0 -p <prompt>`.").option("--prompt <text>", "Run one headless prompt (alias for --print)").action(async (opts) => {
+  ).option("--target <url>", "Engagement target the tools operate against (optional; can be named in-chat)").option("--scope <file>", "Initial policy for the optional scope plugin; activate with `0 plugin enable scope`").option("--finding <id>", "Focus the chat on one persisted finding").option("--finding-intent <intent>", "Finding workflow: investigate, verify, or draft_fix").option("--db-path <path>", "Persistent findings database (defaults to ZERO_DB_PATH or the local store)").option("-m, --model <id>", "Override the LLM model id (else provider default)").option("--role <role>", "Tool set to expose: audit|review|discovery|attack|verify (default audit = every tool)").option("--mode <mode>", "Approval mode: standard|recon|copilot|yolo (default yolo)").option("--yolo", "Shortcut for --mode yolo (no per-action prompts; independent credential, private-network and sandbox protections remain).").option("--autonomy <mode>", "Alias of --mode (standard|copilot|yolo|recon); --mode/--yolo take precedence.").option("--max-tool-calls <n>", "Optional tool-call round limit per message (unlimited by default)").option("--allow-scanners", "Expose generic-scanner tool wrappers (sqlmap/nikto/\u2026); default off").option("--resume [id]", "With a headless prompt, reopen a saved session by id or unique prefix; use browser history for a picker.").option("--continue", "With a headless prompt, continue the most recent saved console session.").option("-p, --print [prompt]", "Non-interactive: run ONE prompt through the engine, print the result, and exit. Reads the prompt from the argument or piped stdin. Combine with --continue/--resume to query a saved session. Also reachable as `0 -p <prompt>`.").option("--prompt <text>", "Run one headless prompt (alias for --print)").action(async (opts) => {
     if (opts.prompt !== void 0) opts.print = opts.prompt;
     if (opts.print === void 0) {
       console.log('Interactive conversations are in the browser. Run 0 web (no account required). For automation use 0 chat --prompt "your request" or 0 -p "your request".');
@@ -10022,7 +10392,7 @@ function registerConsoleCommand(program) {
     let resumedModel;
     let resumedTarget;
     if (opts.continue || opts.resume !== void 0) {
-      const { listSessions, loadSession } = await import("./session-store-MKAAP3WL.js");
+      const { listSessions, loadSession } = await import("./session-store-6QR3CVUA.js");
       const idArg = typeof opts.resume === "string" ? opts.resume.trim() : "";
       if (idArg || opts.continue) {
         let stored = idArg ? loadSession(idArg) : null;
@@ -10136,7 +10506,7 @@ async function runTurn(session, text2, output2) {
 engine error: ${outcome.error ?? "unknown"}
 `), "console.turn.error");
     if (/ChatGPT.*model.*not supported/i.test(outcome.error ?? "")) {
-      output2.stderr(source_default.dim("Choose an available account/provider model with --model; the interactive /model picker lists the current account catalog. Alternatively configure a provider that supports the requested model. No replacement model was selected.\n"), "console.turn.model_unavailable");
+      output2.stderr(source_default.dim("Choose an available account/provider model with --model; the browser model picker lists the current account catalog. Alternatively configure a provider that supports the requested model. No replacement model was selected.\n"), "console.turn.model_unavailable");
     }
   }
   return outcome;
@@ -11013,7 +11383,7 @@ function loadScopeOrExit(path) {
 }
 
 // packages/cli/src/commands/xnu-fuzz.ts
-import { readFileSync as readFileSync16, writeFileSync as writeFileSync12 } from "node:fs";
+import { readFileSync as readFileSync17, writeFileSync as writeFileSync12 } from "node:fs";
 function enumerateAction(opts) {
   const bundle = opts.bundle ?? "com.apple.unknown";
   const model = enumerateTargetModelFromKext(opts.kext, { kext: bundle, source: opts.kext });
@@ -11050,7 +11420,7 @@ function pickClient(model, name) {
   return model.userClients[0];
 }
 function genAction(opts) {
-  const model = JSON.parse(readFileSync16(opts.model, "utf8"));
+  const model = JSON.parse(readFileSync17(opts.model, "utf8"));
   const uc = pickClient(model, opts.class);
   if (!uc) {
     process.stderr.write("no user client in model\n");
@@ -11136,10 +11506,10 @@ function registerXnuFuzzCommand(program) {
 }
 
 // packages/cli/src/commands/research.ts
-import { readFileSync as readFileSync17 } from "node:fs";
-import { resolve as resolve20 } from "node:path";
+import { readFileSync as readFileSync18 } from "node:fs";
+import { resolve as resolve21 } from "node:path";
 async function managedResearch(adapter, target, options, engine) {
-  const { executeManagedOperation: executeManagedOperation2 } = await import("./managed-operation-6R2QPPW5.js");
+  const { executeManagedOperation: executeManagedOperation2 } = await import("./managed-operation-ZMLLRCCQ.js");
   const started = Date.now();
   return executeManagedOperation2({
     type: "research",
@@ -11191,7 +11561,7 @@ function print(value) {
 function registerResearchCommand(program) {
   const research = program.command("research").description("Run target-specific research engines");
   research.command("pipeline").description("Run the existing web/AI/source/package pipeline through the shared evidence plane").requiredOption("--target <target>", "URL, local path, repository, package, or image").option("--target-type <type>", "url, web-app, source-code, npm-package, pypi-package, cargo-package, or oci-image").option("--profile <profile>", "Source review profile").option("--depth <depth>", "quick, default, or deep", "default").option("--runtime <runtime>", "auto, api, claude, codex, gemini, or ollama", "auto").option("--artifact-root <path>", "Research artifact root", ".0-research").action(async (opts) => {
-    const { UnifiedPipelineResearchAdapter, runResearch } = await import("./dist-TQMHMSBZ.js");
+    const { UnifiedPipelineResearchAdapter, runResearch } = await import("./dist-ONIRKDH6.js");
     const allowedTypes = /* @__PURE__ */ new Set(["url", "web-app", "source-code", "npm-package", "pypi-package", "cargo-package", "oci-image"]);
     if (opts.targetType && !allowedTypes.has(opts.targetType)) throw new Error(`unsupported --target-type ${opts.targetType}`);
     print(await managedResearch(
@@ -11210,12 +11580,12 @@ function registerResearchCommand(program) {
           }
         }
       },
-      { artifactRoot: resolve20(opts.artifactRoot), log: (message) => process.stderr.write(message + "\n") },
+      { artifactRoot: resolve21(opts.artifactRoot), log: (message) => process.stderr.write(message + "\n") },
       runResearch
     ));
   });
   research.command("counterexample").description("Search a C/C++ source target for sanitizer-confirmed counterexample inputs; optional mitigation replay").requiredOption("--source <dir>", "C/C++ source tree root").requiredOption("--fn <name>", "Suspect function name").requiredOption("--header <path>", "Header declaring the suspect function").requiredOption("--declaration <decl>", "C declaration of the suspect function").option("--input-shape <shape>", "bytesAndLen, bytesPtr, or bytesAndLenOut", "bytesAndLen").option("--build-system <system>", "auto, autotools, cmake, or meson", "auto").option("--timeout <sec>", "Fuzz wall-clock budget in seconds").option("--mitigation-source <files...>", "Reference-mitigation source file(s) for replay").option("--mitigation-include <dirs...>", "Extra include directories for the mitigation build").option("--witness <files...>", "Finding-proposed witness input file(s) to replay through the sanitizer build").option("--artifact-root <path>", "Research artifact root", ".0-research").action(async (opts) => {
-    const { UserspaceCounterexampleResearchAdapter, runResearch } = await import("./dist-TQMHMSBZ.js");
+    const { UserspaceCounterexampleResearchAdapter, runResearch } = await import("./dist-ONIRKDH6.js");
     const SHAPES = { bytesAndLen: true, bytesPtr: true, bytesAndLenOut: true };
     if (!SHAPES[opts.inputShape]) throw new Error(`unsupported --input-shape ${opts.inputShape}`);
     const SYSTEMS = { auto: true, autotools: true, cmake: true, meson: true };
@@ -11225,9 +11595,9 @@ function registerResearchCommand(program) {
       {
         kind: "userspace.counterexample",
         id: `counterexample:${opts.source}:${opts.fn}`,
-        location: resolve20(opts.source),
+        location: resolve21(opts.source),
         config: {
-          sourceRoot: resolve20(opts.source),
+          sourceRoot: resolve21(opts.source),
           buildSystem: opts.buildSystem,
           suspectFunction: {
             header: opts.header,
@@ -11235,43 +11605,43 @@ function registerResearchCommand(program) {
             declaration: opts.declaration,
             inputShape: opts.inputShape
           },
-          ...opts.witness?.length ? { witnessInputs: opts.witness.map((path) => resolve20(path)) } : {},
+          ...opts.witness?.length ? { witnessInputs: opts.witness.map((path) => resolve21(path)) } : {},
           ...opts.timeout ? { timeoutSec: Number.parseInt(opts.timeout, 10) } : {},
           ...opts.mitigationSource?.length ? { mitigation: { sourceFiles: opts.mitigationSource, ...opts.mitigationInclude?.length ? { includeDirs: opts.mitigationInclude } : {} } } : {}
         }
       },
-      { artifactRoot: resolve20(opts.artifactRoot), log: (message) => process.stderr.write(message + "\n") },
+      { artifactRoot: resolve21(opts.artifactRoot), log: (message) => process.stderr.write(message + "\n") },
       runResearch
     ));
   });
   research.command("mobile").description("Run passive mobile intake; indicators remain hypotheses and only scoped adapters may hand off targets").requiredOption("--target <path>", "Extracted APK/IPA directory or metadata file").option("--artifact-root <path>", "Research artifact root", ".0-research").action(async (opts) => {
-    const { MobileStaticResearchAdapter, runResearch } = await import("./dist-TQMHMSBZ.js");
-    const targetPath = resolve20(opts.target);
+    const { MobileStaticResearchAdapter, runResearch } = await import("./dist-ONIRKDH6.js");
+    const targetPath = resolve21(opts.target);
     print(await managedResearch(
       new MobileStaticResearchAdapter(),
       { kind: "mobile.static-intake", id: `mobile:${targetPath}`, location: targetPath, config: {} },
-      { artifactRoot: resolve20(opts.artifactRoot), log: (message) => process.stderr.write(message + "\n") },
+      { artifactRoot: resolve21(opts.artifactRoot), log: (message) => process.stderr.write(message + "\n") },
       runResearch
     ));
   });
   research.command("linux-matrix").description("Import externally executed vulnerable-vs-patched boot logs; 0 validates and hashes them but does not execute boots").requiredOption("--matrix <path>", "Versioned external boot-matrix manifest JSON").requiredOption("--finding <path>", "Existing Finding JSON to bind the proof to").option("--artifact-root <path>", "Research artifact root", ".0-research").action(async (opts) => {
-    const { LinuxBootMatrixImportAdapter, runResearch } = await import("./dist-TQMHMSBZ.js");
-    const matrix = resolve20(opts.matrix);
-    const finding = JSON.parse(readFileSync17(resolve20(opts.finding), "utf8"));
+    const { LinuxBootMatrixImportAdapter, runResearch } = await import("./dist-ONIRKDH6.js");
+    const matrix = resolve21(opts.matrix);
+    const finding = JSON.parse(readFileSync18(resolve21(opts.finding), "utf8"));
     const result = await managedResearch(
       new LinuxBootMatrixImportAdapter(),
       { kind: "linux.kernel-boot-matrix-import", id: `linux-matrix:${finding.id}`, location: matrix, config: { finding } },
-      { artifactRoot: resolve20(opts.artifactRoot), log: (message) => process.stderr.write(message + "\n") },
+      { artifactRoot: resolve21(opts.artifactRoot), log: (message) => process.stderr.write(message + "\n") },
       runResearch
     );
     if (result.candidates.length === 0) throw new Error("external boot-matrix manifest failed validation");
     print(result);
   });
   research.command("linux").description("Run a supplied Linux kernel reproducer through the shared N-boot evidence gate").requiredOption("--kernel-tree <path>", "Linux source tree").requiredOption("--reproducer <path>", "C reproducer or syzkaller .syz program").requiredOption("--finding <path>", "Existing Finding JSON to bind the proof to").requiredOption("--expected-signature <literal>", "Literal crash signature that every counted boot must contain").option("--boots <n>", "Fresh boots", "3").option("--min-hits <n>", "Required reproducing boots", "2").option("--artifact-root <path>", "Research artifact root", ".0-research").action(async (opts) => {
-    const { LinuxKernelResearchAdapter, runResearch } = await import("./dist-TQMHMSBZ.js");
-    const kernelTree = resolve20(opts.kernelTree);
-    const reproducer = resolve20(opts.reproducer);
-    const finding = JSON.parse(readFileSync17(resolve20(opts.finding), "utf8"));
+    const { LinuxKernelResearchAdapter, runResearch } = await import("./dist-ONIRKDH6.js");
+    const kernelTree = resolve21(opts.kernelTree);
+    const reproducer = resolve21(opts.reproducer);
+    const finding = JSON.parse(readFileSync18(resolve21(opts.finding), "utf8"));
     const boots = Number.parseInt(opts.boots, 10);
     const minHits = Number.parseInt(opts.minHits, 10);
     if (!Number.isFinite(boots) || boots < 1 || !Number.isFinite(minHits) || minHits < 1 || minHits > boots) {
@@ -11287,7 +11657,7 @@ function registerResearchCommand(program) {
         location: kernelTree,
         config: { finding, verify }
       },
-      { artifactRoot: resolve20(opts.artifactRoot), log: (message) => process.stderr.write(message + "\n") },
+      { artifactRoot: resolve21(opts.artifactRoot), log: (message) => process.stderr.write(message + "\n") },
       runResearch
     );
     if (result.findings.length === 0) {
@@ -11314,6 +11684,9 @@ function registerWorkerCommand(program) {
     });
     process.stdout.write(JSON.stringify(result, null, 2) + "\n");
   });
+  worker.command("repair <backend-id>").description("Reconnect a managed worker tunnel and start its retained engine when needed").action(async (backendId) => {
+    process.stdout.write(JSON.stringify(await repairWorker(backendId)) + "\n");
+  });
   worker.command("stop <backend-id>").description("Stop a managed worker engine and its owned tunnel; retain remote files and registration").action(async (backendId) => {
     process.stdout.write(JSON.stringify(await stopWorker(backendId)) + "\n");
   });
@@ -11332,7 +11705,7 @@ function registerWorkerCommand(program) {
 // packages/cli/src/commands/radar.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
 import { writeFileSync as writeFileSync13 } from "node:fs";
-import { resolve as resolve21 } from "node:path";
+import { resolve as resolve22 } from "node:path";
 function parsePositive5(flag, raw, dflt) {
   if (raw === void 0) return dflt;
   const n = parseInt(raw, 10);
@@ -11341,7 +11714,7 @@ function parsePositive5(flag, raw, dflt) {
 }
 async function radarAction(opts) {
   if (!opts.repo) throw new Error("missing required flag: --repo <path>");
-  const repo = resolve21(opts.repo);
+  const repo = resolve22(opts.repo);
   try {
     execFileSync2("git", ["-C", repo, "rev-parse", "--is-inside-work-tree"], { stdio: "pipe" });
   } catch {
@@ -11366,14 +11739,14 @@ async function radarAction(opts) {
   });
   const rankedJson = JSON.stringify(result, null, 2);
   if (opts.out) {
-    writeFileSync13(resolve21(opts.out), rankedJson + "\n", "utf8");
+    writeFileSync13(resolve22(opts.out), rankedJson + "\n", "utf8");
   } else {
     process.stdout.write(rankedJson + "\n");
   }
   if (opts.seedsOut) {
-    const repo2 = resolve21(opts.repo);
+    const repo2 = resolve22(opts.repo);
     const seeds = radarCandidatesToSeedFindings(result, repo2);
-    writeFileSync13(resolve21(opts.seedsOut), JSON.stringify(seeds, null, 2) + "\n", "utf8");
+    writeFileSync13(resolve22(opts.seedsOut), JSON.stringify(seeds, null, 2) + "\n", "utf8");
   }
   process.exitCode = 0;
 }
@@ -11430,7 +11803,7 @@ function registerTimelineCommand(program) {
       process.exitCode = 2;
       return;
     }
-    const { osecDB: osecDB2 } = await import("./dist-RKLQIXDT.js");
+    const { osecDB: osecDB2 } = await import("./dist-QLMPTFT7.js");
     const db = new osecDB2(opts.dbPath);
     let scan2;
     let rows;
@@ -11717,12 +12090,12 @@ function strArray(value) {
 }
 
 // packages/cli/src/commands/agent-assure.ts
-import { createHash as createHash5 } from "node:crypto";
-import { readFileSync as readFileSync18 } from "node:fs";
+import { createHash as createHash6 } from "node:crypto";
+import { readFileSync as readFileSync19 } from "node:fs";
 function readScenario(path) {
   let raw;
   try {
-    raw = JSON.parse(readFileSync18(path, "utf8"));
+    raw = JSON.parse(readFileSync19(path, "utf8"));
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     throw new Error(`agent-assure: failed to read scenario ${path}: ${message}`);
@@ -11733,7 +12106,7 @@ function readHeaders(path, field) {
   if (!path) return {};
   let raw;
   try {
-    raw = JSON.parse(readFileSync18(path, "utf8"));
+    raw = JSON.parse(readFileSync19(path, "utf8"));
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     throw new Error(`agent-assure: failed to read ${field} file ${path}: ${message}`);
@@ -11782,7 +12155,7 @@ function assertInScope(scope, endpoint, label) {
   }
 }
 function readBaseline(path) {
-  const raw = readFileSync18(path, "utf8");
+  const raw = readFileSync19(path, "utf8");
   return {
     manifest: parseAgentActionEvidenceManifest(JSON.parse(raw)),
     sha256: agentActionManifestSha256(raw)
@@ -11800,11 +12173,11 @@ function registerAgentAssureCommand(program) {
     assertInScope(scope, opts.mcpEndpoint, "MCP endpoint");
     assertInScope(scope, opts.oracleEndpoint, "oracle endpoint");
     const baseline = opts.baseline ? readBaseline(opts.baseline) : void 0;
-    const scenarioPayloadSha256 = createHash5("sha256").update(scenario.payload).digest("hex");
+    const scenarioPayloadSha256 = createHash6("sha256").update(scenario.payload).digest("hex");
     if (baseline && (baseline.manifest.scenario.id !== scenario.id || baseline.manifest.scenario.payload_sha256 !== scenarioPayloadSha256)) {
       throw new Error("agent-assure: --baseline must describe the same scenario id and payload");
     }
-    const scopeRaw = opts.scope ? readFileSync18(opts.scope, "utf8") : "";
+    const scopeRaw = opts.scope ? readFileSync19(opts.scope, "utf8") : "";
     const timeoutMs = parsePositiveMilliseconds(opts.timeout, "--timeout");
     const oracleTimeoutMs = parsePositiveMilliseconds(opts.oracleTimeout, "--oracle-timeout");
     const run2 = await runAgentActionAssurance({
@@ -11824,7 +12197,7 @@ function registerAgentAssureCommand(program) {
       }),
       scenario,
       targetConfig: {
-        scopeSha256: createHash5("sha256").update(scopeRaw).digest("hex"),
+        scopeSha256: createHash6("sha256").update(scopeRaw).digest("hex"),
         environment: opts.environment,
         agentEndpoint: opts.agentEndpoint,
         mcpEndpoint: opts.mcpEndpoint,
@@ -11868,7 +12241,7 @@ function registerAgentAssureCommand(program) {
 // packages/cli/src/commands/binary.ts
 import { spawn, spawnSync as spawnSync2 } from "node:child_process";
 import { existsSync as existsSync13 } from "node:fs";
-import { dirname as dirname6, join as join14, resolve as resolve22 } from "node:path";
+import { dirname as dirname6, join as join14, resolve as resolve23 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 var BINARY_MODES = ["triage", "run", "scan"];
 function locateOverseDir(startDir) {
@@ -11950,7 +12323,9 @@ function resolveBinaryRun(target, opts, passthrough, deps = { isUvAvailable, loc
     ok: true,
     exitCode: 0,
     overseDir,
-    argv: buildOverseArgv(mode, target, opts, passthrough)
+    // The subprocess runs from the engine checkout, so anchor the input before
+    // changing cwd. Relative targets belong to the caller's workspace.
+    argv: buildOverseArgv(mode, resolve23(target), opts, passthrough)
   };
 }
 function registerBinaryCommand(program) {
@@ -11966,9 +12341,11 @@ function registerBinaryCommand(program) {
       return;
     }
     const overseDir = resolution.overseDir;
-    const argv = ["run", "--frozen", "0verse", ...resolution.argv ?? []];
-    const child = spawn("uv", argv, {
-      cwd: resolve22(overseDir),
+    const local = localZeroverseRuntime(process.cwd());
+    const argv = local ? ["-m", "zeroverse.cli", ...resolution.argv ?? []] : ["run", "--frozen", "0verse", ...resolution.argv ?? []];
+    const child = spawn(local?.pythonPath ?? "uv", argv, {
+      cwd: local?.cwd ?? resolve23(overseDir),
+      ...local ? { env: { ...process.env, ...local.env } } : {},
       stdio: "inherit",
       shell: false
     });
@@ -11993,9 +12370,9 @@ import { constants as constants3, closeSync as closeSync3, fchmodSync, lstatSync
 import { join as join16 } from "node:path";
 
 // packages/cli/src/commands/hackstore.ts
-import { createHash as createHash6 } from "node:crypto";
-import { constants as constants2, closeSync as closeSync2, existsSync as existsSync14, fstatSync as fstatSync2, lstatSync as lstatSync2, mkdirSync as mkdirSync9, openSync as openSync2, readdirSync as readdirSync2, readFileSync as readFileSync19, rmSync as rmSync4, writeFileSync as writeFileSync14 } from "node:fs";
-import { dirname as dirname7, join as join15, resolve as resolve23 } from "node:path";
+import { createHash as createHash7 } from "node:crypto";
+import { constants as constants2, closeSync as closeSync2, existsSync as existsSync14, fstatSync as fstatSync2, lstatSync as lstatSync2, mkdirSync as mkdirSync9, openSync as openSync2, readdirSync as readdirSync2, readFileSync as readFileSync20, rmSync as rmSync4, writeFileSync as writeFileSync14 } from "node:fs";
+import { dirname as dirname7, join as join15, resolve as resolve24 } from "node:path";
 var HACKSTORE_REGISTRY_REPO = "github.com/0sec-labs/hackstore";
 var HACKSTORE_SCHEMA_ID = "https://raw.githubusercontent.com/0sec-labs/hackstore/main/hackstore-manifest.schema.json";
 var MANIFEST_FILE = "manifest.json";
@@ -12006,7 +12383,7 @@ var MAX_SOURCE_BYTES = 4 * 1024 * 1024;
 var cachedCore;
 async function defaultCorePort() {
   if (cachedCore) return cachedCore;
-  const mod = await import("./dist-TQMHMSBZ.js");
+  const mod = await import("./dist-ONIRKDH6.js");
   cachedCore = {
     validatePluginManifest: mod.validatePluginManifest,
     reservedToolNames: Object.values(mod.TOOL_DEFINITIONS).map((tool) => tool.name),
@@ -12015,7 +12392,7 @@ async function defaultCorePort() {
   return cachedCore;
 }
 function resolveManifestPath2(pathArg) {
-  const target = resolve23(pathArg);
+  const target = resolve24(pathArg);
   try {
     const stat3 = lstatSync2(target);
     if (stat3.isSymbolicLink()) return { ok: false, error: `refusing symbolic link: ${target}` };
@@ -12030,7 +12407,7 @@ function readAuthorFile(file, maxBytes) {
     const stat3 = fstatSync2(fd);
     if (!stat3.isFile()) throw new Error(`${file} is not a regular file`);
     if (stat3.size > maxBytes) throw new Error(`${file} exceeds ${maxBytes} bytes`);
-    return readFileSync19(fd, "utf8");
+    return readFileSync20(fd, "utf8");
   } finally {
     closeSync2(fd);
   }
@@ -12220,7 +12597,7 @@ input.on("line", (line) => {
 `;
 }
 function runInit(name, deps) {
-  const base = deps.dir ? resolve23(deps.dir) : process.cwd();
+  const base = deps.dir ? resolve24(deps.dir) : process.cwd();
   if (!name.trim() || name.length > 2e3 || name === "." || name === ".." || /[/\\\0]/.test(name)) {
     console.error(source_default.red("Extension name must be a single non-empty directory name (at most 2000 characters)."));
     process.exitCode = EXIT_USER_ERROR3;
@@ -12288,7 +12665,7 @@ function runPrepareSubmission(pathArg, deps) {
     process.exitCode = EXIT_USER_ERROR3;
     return;
   }
-  const output2 = resolve23(deps.out ?? `${extension.manifest.id}-submission`);
+  const output2 = resolve24(deps.out ?? `${extension.manifest.id}-submission`);
   let created = false;
   try {
     const readme = readAuthorFile(join15(extension.dir, "README.md"), MAX_MANIFEST_BYTES);
@@ -12312,7 +12689,7 @@ function runPrepareSubmission(pathArg, deps) {
     }
     console.log(source_default.green(`Prepared ${extension.manifest.id}@${extension.manifest.version}: ${target}`));
     for (const [name, content] of Object.entries(files)) {
-      console.log(`  SHA-256 ${name}: ${createHash6("sha256").update(content).digest("hex")}`);
+      console.log(`  SHA-256 ${name}: ${createHash7("sha256").update(content).digest("hex")}`);
     }
     console.log("Not published. No code was executed and nothing was uploaded.");
     console.log(`Fork and clone https://${HACKSTORE_REGISTRY_REPO}, then copy this extensions directory into your fork.`);
@@ -12345,13 +12722,13 @@ function registerHackstoreCommand(program) {
 var cachedCore2;
 async function defaultCorePort2() {
   if (cachedCore2) return cachedCore2;
-  const mod = await import("./dist-TQMHMSBZ.js");
+  const mod = await import("./dist-ONIRKDH6.js");
   cachedCore2 = mod;
   return mod;
 }
 var EXIT_OK4 = 0;
 var EXIT_USER_ERROR4 = 1;
-function resolve24(deps) {
+function resolve25(deps) {
   return {
     core: deps.core,
     fetchImpl: deps.fetchImpl ?? fetch,
@@ -12384,7 +12761,7 @@ function installedViews(d) {
   return out;
 }
 function runList(deps) {
-  const d = resolve24(deps);
+  const d = resolve25(deps);
   const installed = installedViews(d);
   const record2 = d.core.readEnablement(d.projectPath, d.homeDir);
   const reconciled = d.core.reconcile(record2, installed);
@@ -12415,7 +12792,7 @@ function runList(deps) {
   process.exitCode = EXIT_OK4;
 }
 async function runSearch(query, deps) {
-  const d = resolve24(deps);
+  const d = resolve25(deps);
   if (d.registryUrl.trim().length === 0) {
     d.out("The Hackstore is disabled (registry URL is empty), so there is nothing to search.");
     d.out("  The default community Hackstore lives at github.com/0sec-labs/hackstore.");
@@ -12452,7 +12829,7 @@ async function runSearch(query, deps) {
   process.exitCode = EXIT_OK4;
 }
 async function runInstall(id, deps) {
-  const d = resolve24(deps);
+  const d = resolve25(deps);
   if (deps.local === true) {
     const local = readLocalExtension(id, {
       validatePluginManifest: d.core.validatePluginManifest,
@@ -12588,7 +12965,7 @@ function writePluginFiles(d, root, entry) {
   }
 }
 function runEnable(id, deps) {
-  const d = resolve24(deps);
+  const d = resolve25(deps);
   if (!d.core.isSafePluginId(id)) {
     d.err(source_default.red(`"${id}" is not a valid plugin id.`));
     process.exitCode = EXIT_USER_ERROR4;
@@ -12641,7 +13018,7 @@ function runEnable(id, deps) {
   process.exitCode = EXIT_OK4;
 }
 function runDisable(id, deps) {
-  const d = resolve24(deps);
+  const d = resolve25(deps);
   if (!d.core.isSafePluginId(id)) {
     d.err(source_default.red(`"${id}" is not a valid plugin id.`));
     process.exitCode = EXIT_USER_ERROR4;
@@ -12666,7 +13043,7 @@ function runDisable(id, deps) {
   process.exitCode = EXIT_OK4;
 }
 function runInfo(id, deps) {
-  const d = resolve24(deps);
+  const d = resolve25(deps);
   if (!d.core.isSafePluginId(id)) {
     d.err(source_default.red(`"${id}" is not a valid plugin id.`));
     process.exitCode = EXIT_USER_ERROR4;
@@ -12738,7 +13115,7 @@ function parseRunArgs(pairs, jsonArgs) {
   return { ok: true, args: args2 };
 }
 async function runRun(id, tool, pairs, deps) {
-  const d = resolve24(deps);
+  const d = resolve25(deps);
   if (!d.core.isSafePluginId(id)) {
     d.err(source_default.red(`"${id}" is not a valid plugin id.`));
     process.exitCode = EXIT_USER_ERROR4;
@@ -12890,220 +13267,18 @@ function registerPluginCommand(program) {
 }
 
 // packages/cli/src/commands/theme.ts
-import { writeFileSync as writeFileSync16 } from "node:fs";
-var EXIT_OK5 = 0;
 var EXIT_USER_ERROR5 = 1;
-var cachedCore3;
-async function defaultThemeCorePort() {
-  if (cachedCore3) return cachedCore3;
-  const mod = await import("./dist-TQMHMSBZ.js");
-  cachedCore3 = mod;
-  return mod;
-}
-function outOf(deps) {
-  return deps.out ?? ((l) => console.log(l));
-}
-function errOf(deps) {
-  return deps.err ?? ((l) => console.error(l));
-}
-function registryUrlOf(deps, core) {
-  return (deps.registryUrl ?? process.env["ZERO_REGISTRY_URL"] ?? core.DEFAULT_REGISTRY_URL ?? "").trim();
-}
-function runThemeList(deps = {}) {
-  const out = outOf(deps);
-  reloadInstalledThemes(deps.homeDir);
-  const active = loadSettings(deps.homeDir, deps.projectDir).theme;
-  const mark = (name) => {
-    const tags = [];
-    if (name === active) tags.push(source_default.cyan("active"));
-    if (name === DEFAULT_THEME_NAME) tags.push(source_default.green("default"));
-    return tags.length > 0 ? `  (${tags.join(", ")})` : "";
-  };
-  const line = (entry) => {
-    out(`  ${entry.name}${mark(entry.name)}`);
-    out(source_default.dim(`      ${entry.label} \u2014 ${entry.description}`));
-  };
-  out(source_default.bold("Built-in console themes"));
-  for (const name of THEME_NAMES) line(THEMES[name]);
-  const installed = installedThemeEntries(deps.homeDir);
-  out("");
-  if (installed.length === 0) {
-    out(source_default.dim(`Installed themes: none (${installedThemesDir(deps.homeDir)})`));
-  } else {
-    out(source_default.bold(`Installed themes (${installedThemesDir(deps.homeDir)})`));
-    for (const entry of installed) line(entry);
-  }
-  out("");
-  out(source_default.dim("Apply one with `0 theme apply <id>`; install more with `0 theme install <id>`."));
-  process.exitCode = EXIT_OK5;
-}
-async function runThemeInstall(id, deps = {}) {
-  const out = outOf(deps);
-  const err = errOf(deps);
-  const core = deps.core ?? await defaultThemeCorePort();
-  if (!isSafeThemeId(id)) {
-    err(source_default.red(`"${id}" is not a valid theme id; refused before any filesystem access.`));
-    process.exitCode = EXIT_USER_ERROR5;
-    return;
-  }
-  const registryUrl = registryUrlOf(deps, core);
-  if (registryUrl.length === 0) {
-    err(source_default.red("The Hackstore is disabled (registry URL is empty), so nothing can be installed."));
-    err("  Unset ZERO_REGISTRY_URL for the default community Hackstore, or point --registry at a theme index URL you trust.");
-    process.exitCode = EXIT_USER_ERROR5;
-    return;
-  }
-  const fetched = await core.fetchRegistryIndex(registryUrl, {
-    fetchImpl: deps.fetchImpl ?? fetch,
-    verifier: deps.verifier ?? core.unconfiguredVerifier
-  });
-  if (!fetched.ok) {
-    err(source_default.red(`Registry error: ${fetched.error}`));
-    process.exitCode = EXIT_USER_ERROR5;
-    return;
-  }
-  const artifact = fetched.result.artifacts.find(
-    (a) => a.kind === "theme" && a.id === id
-  );
-  if (!artifact) {
-    err(source_default.red(`Theme "${id}" is not available in the configured registry.`));
-    process.exitCode = EXIT_USER_ERROR5;
-    return;
-  }
-  const palette = artifact.manifest.theme.palette;
-  const issues = validateTheme(palette);
-  if (issues.length > 0) {
-    err(source_default.red(`Theme "${id}" has an invalid palette; refusing to install:`));
-    for (const issue of issues) err(source_default.dim(`  - ${issue.message}`));
-    process.exitCode = EXIT_USER_ERROR5;
-    return;
-  }
-  const written = writeInstalledTheme(
-    {
-      id,
-      label: artifact.manifest.theme.label,
-      description: artifact.manifest.theme.description,
-      mode: artifact.manifest.theme.mode,
-      palette
-    },
-    deps.homeDir
-  );
-  if (!written.ok) {
-    err(source_default.red(`Could not install "${id}": ${written.error}`));
-    process.exitCode = EXIT_USER_ERROR5;
-    return;
-  }
-  reloadInstalledThemes(deps.homeDir);
-  out(source_default.green(`Installed theme ${id}@${artifact.version}.`));
-  out(`  Written to: ${written.path}`);
-  out(`  Signature: ${artifact.signatureState}`);
-  out(source_default.dim("  No code ran \u2014 a theme is data (a palette), never an executable plugin."));
-  out(`  Apply it with:`);
-  out(source_default.cyan(`    0 theme apply ${id}`));
-  process.exitCode = EXIT_OK5;
-}
-function runThemeApply(id, deps = {}) {
-  const out = outOf(deps);
-  const err = errOf(deps);
-  configureSettingsStore({ homeDir: deps.homeDir, projectDir: deps.projectDir });
-  reloadInstalledThemes(deps.homeDir);
-  if (!isKnownTheme(id)) {
-    err(source_default.red(`"${id}" is not a known theme (neither a built-in nor an installed id).`));
-    err("  See `0 theme list`, or install it with `0 theme install <id>`.");
-    process.exitCode = EXIT_USER_ERROR5;
-    return;
-  }
-  const saved = updateSetting("theme", id, deps.scope ? { scope: deps.scope } : {});
-  if (!saved) {
-    err(source_default.yellow(`Applied "${id}" for this session, but could not persist it to disk.`));
-    process.exitCode = EXIT_USER_ERROR5;
-    return;
-  }
-  out(source_default.green(`Theme set to "${id}".`));
-  process.exitCode = EXIT_OK5;
-}
-function themeManifestFor(id, homeDir) {
-  reloadInstalledThemes(homeDir);
-  if (!isKnownTheme(id)) return null;
-  const entry = THEME_NAMES.includes(id) ? THEMES[id] : installedThemeEntries(homeDir).find((e) => e.name === id);
-  if (!entry) return null;
-  return {
-    kind: "theme",
-    id,
-    name: entry.label,
-    version: "1.0.0",
-    theme: {
-      label: entry.label,
-      description: entry.description,
-      mode: entry.mode,
-      palette: { ...entry.palette }
-    }
-  };
-}
-function runThemeExport(id, file, deps = {}) {
-  const out = outOf(deps);
-  const err = errOf(deps);
-  const manifest = themeManifestFor(id, deps.homeDir);
-  if (!manifest) {
-    err(source_default.red(`"${id}" is not a known theme.`));
-    process.exitCode = EXIT_USER_ERROR5;
-    return;
-  }
-  const json = `${JSON.stringify(manifest, null, 2)}
-`;
-  if (!file) {
-    out(json.trimEnd());
-    process.exitCode = EXIT_OK5;
-    return;
-  }
-  try {
-    writeFileSync16(file, json, "utf8");
-    out(source_default.green(`Exported theme "${id}" to ${file}.`));
-    process.exitCode = EXIT_OK5;
-  } catch (e) {
-    err(source_default.red(`Could not write ${file}: ${e instanceof Error ? e.message : String(e)}`));
-    process.exitCode = EXIT_USER_ERROR5;
-  }
-}
-function runThemeRemove(id, deps = {}) {
-  const out = outOf(deps);
-  const err = errOf(deps);
-  reloadInstalledThemes(deps.homeDir);
-  const result = removeInstalledTheme(id, deps.homeDir);
-  if (!result.ok) {
-    err(source_default.red(`Could not remove "${id}": ${result.error}`));
-    process.exitCode = EXIT_USER_ERROR5;
-    return;
-  }
-  reloadInstalledThemes(deps.homeDir);
-  out(source_default.green(`Removed installed theme "${id}".`));
-  out(source_default.dim("  If it was the active theme, the console falls back to the default until you apply another."));
-  process.exitCode = EXIT_OK5;
-}
 function registerThemeCommand(program) {
-  const theme = program.command("theme").description("List, install, apply, export, and remove console colour themes");
-  theme.command("list").description("List built-in and installed themes (marks the active + default)").action(() => {
-    runThemeList();
-  });
-  theme.command("install <id>").description("Fetch + validate + write a theme from the configured registry (installs data; runs no code)").option("--registry <url>", "Theme registry index URL (https)").action(async (id, opts) => {
-    await runThemeInstall(id, { registryUrl: opts.registry });
-  });
-  theme.command("apply <id>").description("Set the console theme (a built-in name or an installed id)").option("--project", "Write the choice to the per-project override instead of the global config").option("--global", "Write the choice to the global config").action((id, opts) => {
-    const scope = opts.project ? "project" : opts.global ? "global" : void 0;
-    runThemeApply(id, scope ? { scope } : {});
-  });
-  theme.command("export <id> [file]").description("Emit a built-in or installed theme as a shareable theme manifest JSON (stdout if no file)").action((id, file) => {
-    runThemeExport(id, file);
-  });
-  theme.command("remove <id>").description("Delete an installed theme (built-ins cannot be removed)").action((id) => {
-    runThemeRemove(id);
+  program.command("theme", { hidden: true }).argument("[legacy...]").allowUnknownOption(true).description("Retired terminal theme command; use browser Settings").action(() => {
+    console.error("Terminal themes are no longer used. Run 0 web and open Settings \u2192 Appearance. Existing theme files have not been changed.");
+    process.exitCode = EXIT_USER_ERROR5;
   });
 }
 
 // packages/cli/src/commands/evolve.ts
-import { readFileSync as readFileSync20, existsSync as existsSync15 } from "node:fs";
-import { resolve as resolve25 } from "node:path";
-var EXIT_OK6 = 0;
+import { readFileSync as readFileSync21, existsSync as existsSync15 } from "node:fs";
+import { resolve as resolve26 } from "node:path";
+var EXIT_OK5 = 0;
 var EXIT_USER_ERROR6 = 1;
 var EXIT_RUNTIME_ERROR = 2;
 var EXIT_INTERRUPT = 3;
@@ -13237,7 +13412,7 @@ function registerEvolveCommand(program) {
         else formatEvaluationResult(result, Boolean(opts.json), out);
         if (result.iterations.length === 0) break;
       }
-      process.exitCode = abortController.signal.aborted ? EXIT_INTERRUPT : EXIT_OK6;
+      process.exitCode = abortController.signal.aborted ? EXIT_INTERRUPT : EXIT_OK5;
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       if (opts.json) out(JSON.stringify({ error: message }));
@@ -13249,7 +13424,7 @@ function registerEvolveCommand(program) {
   });
   evolve.command("status").description("Show active and canary versions, snapshot identities, and registry events").option("--store <path>", "Required path to evolution store directory").option("--json", "Output structured JSON").action(async (opts) => {
     try {
-      const storePath = opts.store ? resolve25(opts.store) : void 0;
+      const storePath = opts.store ? resolve26(opts.store) : void 0;
       if (!storePath) {
         console.error(source_default.red("--store <path> is required. Point it to the evolution store directory containing registry.json."));
         process.exitCode = EXIT_USER_ERROR6;
@@ -13278,7 +13453,7 @@ function registerEvolveCommand(program) {
           if (campaign.status === "blocked" || campaign.status === "exhausted") console.log(`  ${campaign.resumeReason}`);
         }
       }
-      process.exitCode = EXIT_OK6;
+      process.exitCode = EXIT_OK5;
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       if (opts.json) {
@@ -13291,9 +13466,9 @@ function registerEvolveCommand(program) {
   });
   evolve.command("reconcile").description("Reconcile an interrupted dispatch using observed cost and an immutable receipt digest").requiredOption("--store <path>", "Path to evolution store directory").requiredOption("--dispatch <id>", "Unresolved dispatch reservation ID").requiredOption("--cost-usd <amount>", "Actual provider/execution charge", Number).requiredOption("--receipt-digest <sha256>", "Immutable observed cost receipt digest").option("--json", "Output structured campaign ledger").action((opts) => {
     try {
-      const ledger = reconcileCampaignDispatch(resolve25(opts.store), opts.dispatch, opts.costUsd, opts.receiptDigest);
+      const ledger = reconcileCampaignDispatch(resolve26(opts.store), opts.dispatch, opts.costUsd, opts.receiptDigest);
       console.log(opts.json ? JSON.stringify(ledger) : `Reconciled ${opts.dispatch}; campaign ${ledger.status}`);
-      process.exitCode = EXIT_OK6;
+      process.exitCode = EXIT_OK5;
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       if (opts.json) console.log(JSON.stringify({ error: message }));
@@ -13306,10 +13481,10 @@ function registerEvolveCommand(program) {
     const interrupt = () => controller.abort();
     process.once("SIGINT", interrupt);
     try {
-      const result = await approveEvolutionCandidate(resolve25(opts.store), opts.version, { signal: controller.signal });
+      const result = await approveEvolutionCandidate(resolve26(opts.store), opts.version, { signal: controller.signal });
       if (opts.json) console.log(JSON.stringify(result));
       else console.log(`Promoted ${result.versionId}; canary cost $${result.evaluationCostUsd.toFixed(4)}`);
-      process.exitCode = EXIT_OK6;
+      process.exitCode = EXIT_OK5;
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       if (opts.json) console.log(JSON.stringify({ error: message }));
@@ -13321,7 +13496,7 @@ function registerEvolveCommand(program) {
   });
   evolve.command("rollback").description("Retire an active or canary evolution version and restore its parent").requiredOption("--store <path>", "Path to evolution store directory").requiredOption("--version <id>", "Active or canary version ID to retire").option("--reason <text>", "Reason for rollback", "operator rollback").action(async (opts) => {
     try {
-      const storePath = resolve25(opts.store);
+      const storePath = resolve26(opts.store);
       if (!existsSync15(storePath)) {
         console.error(source_default.red(`store directory not found: ${storePath}`));
         process.exitCode = EXIT_USER_ERROR6;
@@ -13337,7 +13512,7 @@ function registerEvolveCommand(program) {
       await rollbackEvolutionVersion(storePath, opts.version, opts.reason);
       console.log(source_default.green(`Retired ${opts.version.slice(0, 12)}\u2026; restored ${loadEvolutionRegistry(storePath).activeId}`));
       console.log(`  Reason: ${opts.reason}`);
-      process.exitCode = EXIT_OK6;
+      process.exitCode = EXIT_OK5;
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       console.error(source_default.red(`Rollback failed: ${message}`));
@@ -13372,7 +13547,7 @@ function registerEvolveCommand(program) {
         if (exec.error) err(source_default.red(`  ${exec.error}`));
       }
       formatExecResult(executionResult.versionId, executionResult, Boolean(opts.json), out);
-      process.exitCode = abortController.signal.aborted ? EXIT_INTERRUPT : hasError ? EXIT_RUNTIME_ERROR : EXIT_OK6;
+      process.exitCode = abortController.signal.aborted ? EXIT_INTERRUPT : hasError ? EXIT_RUNTIME_ERROR : EXIT_OK5;
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       if (opts.json) {
@@ -13389,12 +13564,12 @@ function registerEvolveCommand(program) {
   const feedback = evolve.command("feedback").description("Capture, approve, and inspect evolution feedback candidates");
   feedback.command("capture").description("Capture an evidence-backed observation from a JSON file; does not confirm a finding").requiredOption("--input <path>", "Observation JSON file with source revision and evidence references").option("--store <path>", "Feedback queue JSON file").option("--allow-source-access", "Explicitly consent to source use for this observation").action((opts) => {
     try {
-      const input = parseObservationInput(JSON.parse(readFileSync20(resolve25(opts.input), "utf8")));
+      const input = parseObservationInput(JSON.parse(readFileSync21(resolve26(opts.input), "utf8")));
       const result = captureObservation({ ...input, consent: opts.allowSourceAccess === true }, {
-        ...opts.store ? { storePath: resolve25(opts.store) } : {}
+        ...opts.store ? { storePath: resolve26(opts.store) } : {}
       });
       console.log(JSON.stringify(result, null, 2));
-      process.exitCode = EXIT_OK6;
+      process.exitCode = EXIT_OK5;
     } catch (error) {
       console.error(source_default.red(`Feedback capture failed: ${error instanceof Error ? error.message : String(error)}`));
       process.exitCode = EXIT_RUNTIME_ERROR;
@@ -13402,14 +13577,14 @@ function registerEvolveCommand(program) {
   });
   feedback.command("approve").description("Approve independent positive, held-out, and negative fixtures for an observation").requiredOption("--id <feedback-id>", "Full observation ID").requiredOption("--fixtures <path>", "Curation JSON containing positives, heldOut, and negativeControls").option("--store <path>", "Feedback queue JSON file").option("--allow-source-access", "Explicitly consent to source use for synthesis").action((opts) => {
     try {
-      const shape = parseApprovedObservationShape(JSON.parse(readFileSync20(resolve25(opts.fixtures), "utf8")));
+      const shape = parseApprovedObservationShape(JSON.parse(readFileSync21(resolve26(opts.fixtures), "utf8")));
       const result = approveObservation(opts.id, shape, {
-        ...opts.store ? { storePath: resolve25(opts.store) } : {},
+        ...opts.store ? { storePath: resolve26(opts.store) } : {},
         ...opts.allowSourceAccess === true ? { allowModelSourceAccess: true } : {}
       });
       if (!result) throw new Error("observation was not found or is not pending");
       console.log(JSON.stringify(result, null, 2));
-      process.exitCode = EXIT_OK6;
+      process.exitCode = EXIT_OK5;
     } catch (error) {
       console.error(source_default.red(`Feedback approval failed: ${error instanceof Error ? error.message : String(error)}`));
       process.exitCode = EXIT_RUNTIME_ERROR;
@@ -13417,11 +13592,11 @@ function registerEvolveCommand(program) {
   });
   feedback.command("release").description("Release a stale processing claim after its worker has stopped").requiredOption("--id <feedback-id>", "Full observation ID").requiredOption("--claim-token <token>", "Exact claim token shown by feedback status --json").option("--store <path>", "Feedback queue JSON file").action((opts) => {
     try {
-      if (!releaseClaim(opts.id, opts.claimToken, opts.store ? { storePath: resolve25(opts.store) } : {})) {
+      if (!releaseClaim(opts.id, opts.claimToken, opts.store ? { storePath: resolve26(opts.store) } : {})) {
         throw new Error("observation or processing claim no longer matches");
       }
       console.log(`Released feedback claim ${opts.id}`);
-      process.exitCode = EXIT_OK6;
+      process.exitCode = EXIT_OK5;
     } catch (error) {
       console.error(`Feedback release failed: ${error instanceof Error ? error.message : String(error)}`);
       process.exitCode = EXIT_USER_ERROR6;
@@ -13429,11 +13604,11 @@ function registerEvolveCommand(program) {
   });
   feedback.command("status").description("Show retained observations and their approval/processing status").option("--store <path>", "Feedback queue JSON file").option("--json", "Output structured JSON").action((opts) => {
     try {
-      const observations = listObservations(void 0, { ...opts.store ? { storePath: resolve25(opts.store) } : {} });
+      const observations = listObservations(void 0, { ...opts.store ? { storePath: resolve26(opts.store) } : {} });
       if (opts.json) console.log(JSON.stringify(observations, null, 2));
       else if (observations.length === 0) console.log("No feedback observations.");
       else for (const observation of observations) console.log(`${observation.id}  ${observation.status}  ${observation.classHint}`);
-      process.exitCode = EXIT_OK6;
+      process.exitCode = EXIT_OK5;
     } catch (error) {
       console.error(source_default.red(`Feedback status failed: ${error instanceof Error ? error.message : String(error)}`));
       process.exitCode = EXIT_RUNTIME_ERROR;
@@ -13443,11 +13618,11 @@ function registerEvolveCommand(program) {
 
 // packages/cli/src/commands/learning.ts
 import { realpathSync as realpathSync3 } from "node:fs";
-import { isAbsolute as isAbsolute3, resolve as resolve26 } from "node:path";
+import { isAbsolute as isAbsolute3, resolve as resolve27 } from "node:path";
 import { homedir as homedir3 } from "node:os";
 async function defaultService() {
-  const { LearningService, HuntMemoryStore } = await import("./dist-TQMHMSBZ.js");
-  const { SecurityWorkflowStore: SecurityWorkflowStore2, learningProjectId } = await import("./dist-RKLQIXDT.js");
+  const { LearningService, HuntMemoryStore } = await import("./dist-ONIRKDH6.js");
+  const { SecurityWorkflowStore: SecurityWorkflowStore2, learningProjectId } = await import("./dist-QLMPTFT7.js");
   const workflows = new SecurityWorkflowStore2();
   const store = workflows.learningStore();
   const service = new LearningService(store, { workflows });
@@ -13461,7 +13636,7 @@ async function defaultService() {
         if (isAbsolute3(source) || /^\.{1,2}\//.test(source) || source.startsWith("~/")) {
           let root;
           try {
-            root = realpathSync3(source.startsWith("~/") ? resolve26(homedir3(), source.slice(2)) : source);
+            root = realpathSync3(source.startsWith("~/") ? resolve27(homedir3(), source.slice(2)) : source);
           } catch {
           }
           if (root) service.importCodebaseNotes(project(selected), root, new HuntMemoryStore());
@@ -13549,16 +13724,34 @@ function registerLearningCommand(program, deps = {}) {
 }
 
 // packages/cli/src/commands/config.ts
-import { readFileSync as readFileSync21, writeFileSync as writeFileSync17 } from "node:fs";
-var EXIT_OK7 = 0;
+import { readFileSync as readFileSync22, writeFileSync as writeFileSync16 } from "node:fs";
+var EXIT_OK6 = 0;
 var EXIT_USER_ERROR7 = 1;
+var CLI_CONFIG_KEYS = [
+  "busyInputMode",
+  "autoCompaction",
+  "compactionThreshold",
+  "allowSubagentPeerMessaging",
+  "allowSubagentOperatorMessaging",
+  "allowModelSelfExtension",
+  "allowDevSourceUpdates",
+  "executionProfile",
+  "analyticsLevel",
+  "diagnosticReporting",
+  "updatePolicy"
+];
+var PUBLIC_CONFIG_KEYS = new Set(CLI_CONFIG_KEYS);
+var INTERNAL_CONFIG_KEYS = /* @__PURE__ */ new Set(["onboardingCompleted", "diagnosticReportingPrompted", "modelPreference"]);
+function publicConfig(settings) {
+  return Object.fromEntries(CLI_CONFIG_KEYS.map((key) => [key, settings[key]]));
+}
 var SECURITY_KEYS = SETTING_DEFS.filter(
   (d) => d.group === "Security"
 ).map((d) => d.key);
-function outOf2(deps) {
+function outOf(deps) {
   return deps.out ?? ((l) => console.log(l));
 }
-function errOf2(deps) {
+function errOf(deps) {
   return deps.err ?? ((l) => console.error(l));
 }
 function renderValue(value) {
@@ -13567,39 +13760,39 @@ function renderValue(value) {
   return String(value);
 }
 function runConfigShow(deps = {}) {
-  const out = outOf2(deps);
+  const out = outOf(deps);
   const { settings, sources } = loadLayeredSettings({
     homeDir: deps.homeDir,
     projectDir: deps.projectDir
   });
-  out(source_default.bold("Effective console configuration"));
+  out(source_default.bold("Effective engine configuration"));
   out(source_default.dim(`  global:  ${settingsFilePath(deps.homeDir)}`));
   out(source_default.dim(`  project: ${projectSettingsFilePath(deps.projectDir)}`));
   out("");
-  const keys = Object.keys(settings);
+  const keys = CLI_CONFIG_KEYS;
   const width = Math.max(...keys.map((k) => k.length));
   for (const key of keys) {
     const layer = sources[key];
     const tag = layer === "project" ? source_default.cyan("[project]") : layer === "global" ? source_default.green("[global]") : source_default.dim("[default]");
     out(`  ${key.padEnd(width)}  ${renderValue(settings[key]).padEnd(11)} ${tag}`);
   }
-  process.exitCode = EXIT_OK7;
+  process.exitCode = EXIT_OK6;
 }
 function runConfigExport(file, deps = {}) {
-  const out = outOf2(deps);
-  const err = errOf2(deps);
+  const out = outOf(deps);
+  const err = errOf(deps);
   const settings = deps.global ? loadGlobalSettings(deps.homeDir) : loadLayeredSettings({ homeDir: deps.homeDir, projectDir: deps.projectDir }).settings;
-  const json = `${JSON.stringify(settings, null, 2)}
+  const json = `${JSON.stringify(publicConfig(settings), null, 2)}
 `;
   if (!file) {
     out(json.trimEnd());
-    process.exitCode = EXIT_OK7;
+    process.exitCode = EXIT_OK6;
     return;
   }
   try {
-    writeFileSync17(file, json, "utf8");
+    writeFileSync16(file, json, "utf8");
     out(source_default.green(`Exported ${deps.global ? "global" : "effective"} config to ${file}.`));
-    process.exitCode = EXIT_OK7;
+    process.exitCode = EXIT_OK6;
   } catch (e) {
     err(source_default.red(`Could not write ${file}: ${e instanceof Error ? e.message : String(e)}`));
     process.exitCode = EXIT_USER_ERROR7;
@@ -13612,24 +13805,32 @@ function extractConfigBag(parsed) {
   return parsed;
 }
 function runConfigImport(file, deps = {}) {
-  const out = outOf2(deps);
-  const err = errOf2(deps);
+  const out = outOf(deps);
+  const err = errOf(deps);
   const scope = deps.scope ?? "global";
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync21(file, "utf8"));
+    parsed = JSON.parse(readFileSync22(file, "utf8"));
   } catch (e) {
     err(source_default.red(`Could not read ${file}: ${e instanceof Error ? e.message : String(e)}`));
     process.exitCode = EXIT_USER_ERROR7;
     return;
   }
   const bag = extractConfigBag(parsed);
+  const legacyKeys = typeof bag === "object" && bag !== null && !Array.isArray(bag) ? Object.keys(bag).filter((key) => Object.hasOwn(DEFAULT_SETTINGS, key) && !PUBLIC_CONFIG_KEYS.has(key) && !INTERNAL_CONFIG_KEYS.has(key)) : [];
+  if (legacyKeys.length) {
+    err(source_default.red(`Retired terminal settings cannot be imported: ${legacyKeys.join(", ")}. Nothing was written.`));
+    err("Use 0 web \u2192 Settings for browser appearance. Remove retired keys to import engine settings.");
+    process.exitCode = EXIT_USER_ERROR7;
+    return;
+  }
   const patch = sanitizeOverrides(bag);
   const profile = typeof bag === "object" && bag !== null ? bag["executionProfile"] : void 0;
   const profileChoices = SETTING_DEFS.find((def) => def.key === "executionProfile")?.choices;
   if (scope === "global" && typeof profile === "string" && profileChoices?.includes(profile)) {
     patch.executionProfile = profile;
   }
+  for (const key of Object.keys(patch)) if (!PUBLIC_CONFIG_KEYS.has(key)) delete patch[key];
   const patchKeys = Object.keys(patch);
   const skipped = typeof bag === "object" && bag !== null && !Array.isArray(bag) ? Object.keys(bag).filter((k) => !patchKeys.includes(k)) : [];
   if (patchKeys.length === 0) {
@@ -13670,10 +13871,10 @@ function runConfigImport(file, deps = {}) {
   }
   if (changes.length === 0) out(source_default.dim("  (all imported values already matched the current config)"));
   if (skipped.length > 0) out(source_default.dim(`  Skipped unknown/invalid keys: ${skipped.join(", ")}`));
-  process.exitCode = EXIT_OK7;
+  process.exitCode = EXIT_OK6;
 }
 function registerConfigCommand(program) {
-  const config = program.command("config").description("Inspect, export, and import console configuration (global and project layers)");
+  const config = program.command("config").description("Inspect, export, and import engine configuration (global and project layers)");
   config.command("show").description("Show the effective config with the source layer (default/global/project) per key").action(() => {
     runConfigShow();
   });
@@ -13731,16 +13932,16 @@ function registerReviewChecksCommand(program) {
 import { open } from "node:fs/promises";
 import { constants as constants4 } from "node:fs";
 var defaults = {
-  createRemoteRuntime: async (options) => (await import("./remote-workflow-runtime-DB52SINR.js")).createRemoteWorkflowRuntime(options),
+  createRemoteRuntime: async (options) => (await import("./remote-workflow-runtime-GOI4TYP5.js")).createRemoteWorkflowRuntime(options),
   createRuntime: async (options) => {
-    const { createCliWorkflowRuntime } = await import("./workflow-runtime-AR627I26.js");
+    const { createCliWorkflowRuntime } = await import("./workflow-runtime-CQTDASFA.js");
     return await createCliWorkflowRuntime(options);
   },
   out: (text2) => process.stdout.write(`${text2}
 `),
   err: (text2) => process.stderr.write(`${text2}
 `),
-  sleep: () => new Promise((resolve28) => setTimeout(resolve28, 100))
+  sleep: () => new Promise((resolve29) => setTimeout(resolve29, 100))
 };
 function positive(value, name, integer = false) {
   if (value === void 0) return void 0;
@@ -13941,9 +14142,9 @@ function registerWorkflowCommand(program, deps = defaults) {
 }
 
 // packages/cli/src/commands/team.ts
-import { constants as constants5, closeSync as closeSync4, fstatSync as fstatSync3, openSync as openSync4, readFileSync as readFileSync22, renameSync, unlinkSync as unlinkSync2, writeFileSync as writeFileSync18 } from "node:fs";
+import { constants as constants5, closeSync as closeSync4, fstatSync as fstatSync3, openSync as openSync4, readFileSync as readFileSync23, renameSync, unlinkSync as unlinkSync2, writeFileSync as writeFileSync17 } from "node:fs";
 import { randomUUID as randomUUID3 } from "node:crypto";
-import { resolve as resolve27 } from "node:path";
+import { resolve as resolve28 } from "node:path";
 import { emitKeypressEvents } from "node:readline";
 var memberSchema = external_exports.object({ id: external_exports.string().trim().min(1).max(160), name: external_exports.string().trim().min(1).max(160), role: external_exports.enum(["owner", "editor", "viewer"]), passwordHash: external_exports.string().regex(/^scrypt\$[a-f0-9]{32}\$[a-f0-9]{128}$/).optional(), oidcSub: external_exports.string().min(1).optional() }).strict();
 var configSchema = external_exports.object({ workspace: external_exports.object({ id: external_exports.string().min(1), name: external_exports.string().trim().min(1).max(160) }).strict(), users: external_exports.array(memberSchema).min(1).max(1e3), oidc: external_exports.object({ issuer: external_exports.string().url(), clientId: external_exports.string().min(1), clientSecretEnv: external_exports.string().min(1).optional(), redirectUri: external_exports.string().url() }).strict().optional() }).strict();
@@ -13953,7 +14154,7 @@ function readPrivateConfig(path) {
     const stat3 = fstatSync3(fd);
     if (!stat3.isFile() || (stat3.mode & 63) !== 0) throw new Error("Team configuration must be a private regular file (chmod 600)");
     if (stat3.size > 1024 * 1024) throw new Error("Team configuration is too large");
-    const cfg = configSchema.parse(JSON.parse(readFileSync22(fd, "utf8")));
+    const cfg = configSchema.parse(JSON.parse(readFileSync23(fd, "utf8")));
     if (new Set(cfg.users.map((user) => user.id)).size !== cfg.users.length) throw new Error("Team user IDs must be unique");
     return cfg;
   } finally {
@@ -14005,7 +14206,7 @@ async function readPassword() {
 function writeNew(path, config) {
   const fd = openSync4(path, "wx", 384);
   try {
-    writeFileSync18(fd, `${JSON.stringify(config, null, 2)}
+    writeFileSync17(fd, `${JSON.stringify(config, null, 2)}
 `, "utf8");
   } catch (error) {
     try {
@@ -14036,11 +14237,11 @@ function registerTeamCommand(program, dependencies = {}) {
     const opts = init.opts();
     const member = memberSchema.parse({ id: opts.owner, name: opts.displayName, role: "owner" });
     const workspace = configSchema.shape.workspace.parse({ id: randomUUID3(), name: opts.name });
-    const path = resolve27(opts.config);
+    const path = resolve28(opts.config);
     const fd = openSync4(path, "wx", 384);
     try {
       member.passwordHash = await hashTeamPassword(await password());
-      writeFileSync18(fd, `${JSON.stringify({ workspace, users: [member] }, null, 2)}
+      writeFileSync17(fd, `${JSON.stringify({ workspace, users: [member] }, null, 2)}
 `, "utf8");
     } catch (failure) {
       try {
@@ -14057,7 +14258,7 @@ function registerTeamCommand(program, dependencies = {}) {
   add.action(perform(async () => {
     const opts = add.opts();
     const member = memberSchema.parse({ id: opts.user, name: opts.displayName, role: opts.role });
-    const path = resolve27(opts.config);
+    const path = resolve28(opts.config);
     const lock = `${path}.lock`;
     const lockFD = openSync4(lock, "wx", 384);
     const temporary = `${path}.${randomUUID3()}.tmp`;
@@ -14081,13 +14282,110 @@ function registerTeamCommand(program, dependencies = {}) {
   }));
   const list = team.command("list").description("List workspace accounts without credentials").requiredOption("--config <path>", "Team configuration");
   list.action(perform(() => {
-    const config = readPrivateConfig(resolve27(list.opts().config));
+    const config = readPrivateConfig(resolve28(list.opts().config));
     out(JSON.stringify({ workspace: config.workspace, users: config.users.map(({ id, name, role }) => ({ id, name, role })) }, null, 2));
   }));
 }
+
+// packages/cli/src/commands/api.ts
+import { constants as constants6 } from "node:fs";
+import { open as open2 } from "node:fs/promises";
+var MAX_BODY = 1e6;
+var METHODS = ["GET", "POST", "PATCH", "PUT", "DELETE", "HEAD"];
+async function parseBody(input) {
+  if (input === void 0) return void 0;
+  let text2 = input;
+  if (input.startsWith("@")) {
+    if (input.length === 1) throw new Error("--data @file requires a file path.");
+    const file = await open2(input.slice(1), constants6.O_RDONLY | constants6.O_NONBLOCK);
+    try {
+      const stat3 = await file.stat();
+      if (!stat3.isFile() || stat3.size > MAX_BODY) throw new Error("API data must be a regular JSON file of at most 1 MB.");
+      const buffer = Buffer.alloc(MAX_BODY + 1);
+      let length = 0;
+      while (length < buffer.length) {
+        const { bytesRead } = await file.read(buffer, length, buffer.length - length, length);
+        if (!bytesRead) break;
+        length += bytesRead;
+      }
+      if (length > MAX_BODY) throw new Error("API data exceeds 1 MB.");
+      text2 = buffer.subarray(0, length).toString("utf8");
+    } finally {
+      await file.close();
+    }
+  }
+  if (Buffer.byteLength(text2) > MAX_BODY) throw new Error("API data exceeds 1 MB.");
+  let body;
+  try {
+    body = JSON.parse(text2);
+  } catch {
+    throw new Error("--data must contain valid JSON, or @file containing JSON.");
+  }
+  if (Buffer.byteLength(JSON.stringify(body)) > MAX_BODY) throw new Error("API data exceeds 1 MB.");
+  return body;
+}
+async function runApiCommand(path, options, deps = {}) {
+  const out = deps.out ?? ((text2) => {
+    process.stdout.write(`${text2}
+`);
+  });
+  const err = deps.err ?? ((text2) => {
+    process.stderr.write(`${text2}
+`);
+  });
+  const fail2 = deps.setExitCode ?? ((code) => {
+    process.exitCode = code;
+  });
+  let registry;
+  try {
+    const method = (options.method ?? "GET").toUpperCase();
+    if (!METHODS.includes(method)) throw new Error(`--method must be one of ${METHODS.join(", ")}.`);
+    if (options.data !== void 0 && (method === "GET" || method === "HEAD")) throw new Error("GET and HEAD cannot include --data.");
+    if (options.engineUrl && (options.backend || options.backendsConfig)) throw new Error("--engine-url cannot be combined with --backend or --backends-config.");
+    if (Boolean(options.engineUrl) !== Boolean(options.engineTokenEnv)) throw new Error("Direct attachment requires both --engine-url and --engine-token-env.");
+    if (!options.engineUrl && !options.backend) throw new Error("Select --backend or --engine-url with --engine-token-env explicitly.");
+    if (options.backend === "local") throw new Error("Use an explicit HTTP engine URL or registered HTTP backend; local is not an API transport.");
+    const requestPath = path ?? "/api/backend/handshake";
+    if (requestPath.includes("#")) throw new Error("API paths cannot contain fragments.");
+    if (!requestPath.startsWith("/api/") || requestPath.split("?")[0] !== "/api/backend/handshake" && !backendCapabilitiesForApiPath(requestPath.split("?")[0]).length) throw new Error("Supply an admitted /api/ path.");
+    const body = await parseBody(options.data);
+    const env = deps.env ?? process.env;
+    const backendId = options.backend ?? "attached-engine";
+    const connections = options.engineUrl ? [{ id: backendId, name: "Attached engine", url: options.engineUrl, bearerTokenEnv: options.engineTokenEnv }] : loadBackendConnectionConfig(options.backendsConfig);
+    const connection = connections.find((row) => row.id === backendId);
+    if (!connection) throw new Error("Backend is not registered.");
+    if (options.engineUrl) backendBearerFromEnv(connection.bearerTokenEnv, env);
+    const localHandshake = { protocolVersion: BACKEND_PROTOCOL_VERSION, engineId: "api-client", capabilities: [], platform: { os: process.platform, pathStyle: process.platform === "win32" ? "windows" : "posix" } };
+    registry = new BackendConnectionRegistry({ ...options.engineUrl ? { connections } : { configPath: options.backendsConfig }, env, ...deps.fetch ? { fetch: deps.fetch } : {}, localHandshake });
+    const response = await registry.request(backendId, requestPath, { method, ...body !== void 0 ? { body } : {} });
+    const text2 = method === "HEAD" || response.status === 204 ? "" : await response.text();
+    let data = text2 || null;
+    if (text2 && /(?:application\/json|\+json)(?:;|$)/i.test(response.headers.get("content-type") ?? "")) {
+      try {
+        data = JSON.parse(text2);
+      } catch {
+        throw new Error(`Engine returned malformed JSON (HTTP ${response.status}).`);
+      }
+    }
+    out(JSON.stringify({ ok: response.ok, status: response.status, data }));
+    if (!response.ok) {
+      err(JSON.stringify({ ok: false, status: response.status, error: `Engine request failed (HTTP ${response.status}).` }));
+      fail2(2);
+    }
+  } catch (error) {
+    err(JSON.stringify({ ok: false, status: error instanceof BackendConnectionError ? error.statusCode : null, error: error instanceof Error ? error.message : "API request failed." }));
+    fail2(2);
+  } finally {
+    registry?.dispose();
+  }
+}
+function registerApiCommand(program, deps = {}) {
+  program.command("api [path]").description("Call a trusted engine API with deterministic JSON output (defaults to its handshake)").option("--method <method>", "GET, POST, PATCH, PUT, DELETE or HEAD", "GET").option("--data <json-or-@file>", "JSON body, or @regular-file containing JSON (at most 1 MB)").option("--backend <id>", "Registered HTTP engine ID").option("--backends-config <path>", "Operator backend registry JSON file").option("--engine-url <url>", "Attach directly to a trusted HTTP engine").option("--engine-token-env <name>", "Environment variable containing its engine token").action((path, options) => runApiCommand(path, options, deps));
+}
 export {
   registerAdGraphCommand,
   registerAgentAssureCommand,
+  registerApiCommand,
   registerAssumptionHuntCommand,
   registerAuditCommand,
   registerBenchCommand,
@@ -14133,6 +14431,7 @@ export {
   registerResumeCommand,
   registerReviewChecksCommand,
   registerReviewCommand,
+  registerRoutingCommand,
   registerScanCommand,
   registerSecureCommand,
   registerSpecdriftCommand,