@agentcash/discovery 0.1.0 → 0.1.2

package/dist/cli.js

@@ -25,6 +25,19 @@ function parseTimeoutMs(value) {
   }
   return parsed;
 }
+function parseClient(value) {
+  if (value === "claude-code" || value === "skill-cli" || value === "generic-mcp" || value === "generic") {
+    return value;
+  }
+  return null;
+}
+function parseContextWindowTokens(value) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0 || !Number.isInteger(parsed)) {
+    return null;
+  }
+  return parsed;
+}
 function parseCliArgs(argv) {
   let target;
   let verbose = false;
@@ -33,6 +46,10 @@ function parseCliArgs(argv) {
   let timeoutMs = DEFAULT_TIMEOUT_MS;
   let compatMode = DEFAULT_COMPAT_MODE;
   let color = true;
+  let noTruncate = false;
+  let harness = false;
+  let client = "claude-code";
+  let contextWindowTokens;
   for (let i = 0; i < argv.length; i += 1) {
     const arg = argv[i];
     if (arg === "--help" || arg === "-h") {
@@ -54,6 +71,14 @@ function parseCliArgs(argv) {
       color = false;
       continue;
     }
+    if (arg === "--no-truncate") {
+      noTruncate = true;
+      continue;
+    }
+    if (arg === "--harness") {
+      harness = true;
+      continue;
+    }
     if (arg === "--compat") {
       const value = argv[i + 1];
       if (!value) {
@@ -86,6 +111,38 @@ function parseCliArgs(argv) {
       i += 1;
       continue;
     }
+    if (arg === "--client") {
+      const value = argv[i + 1];
+      if (!value) {
+        return { kind: "error", message: "Missing value for --client." };
+      }
+      const parsed = parseClient(value);
+      if (!parsed) {
+        return {
+          kind: "error",
+          message: "Invalid --client value '" + value + "'. Expected: claude-code | skill-cli | generic-mcp | generic."
+        };
+      }
+      client = parsed;
+      i += 1;
+      continue;
+    }
+    if (arg === "--context-window-tokens") {
+      const value = argv[i + 1];
+      if (!value) {
+        return { kind: "error", message: "Missing value for --context-window-tokens." };
+      }
+      const parsed = parseContextWindowTokens(value);
+      if (!parsed) {
+        return {
+          kind: "error",
+          message: `Invalid --context-window-tokens value '${value}'. Expected a positive integer.`
+        };
+      }
+      contextWindowTokens = parsed;
+      i += 1;
+      continue;
+    }
     if (arg.startsWith("-")) {
       return { kind: "error", message: `Unknown flag '${arg}'.` };
     }
@@ -109,7 +166,11 @@ function parseCliArgs(argv) {
       compatMode,
       probe,
       timeoutMs,
-      color
+      color,
+      noTruncate,
+      harness,
+      client,
+      ...contextWindowTokens ? { contextWindowTokens } : {}
     }
   };
 }
@@ -122,13 +183,19 @@ function renderHelp() {
     "  --json                 Emit JSON output",
     "  --compat <mode>        Compatibility mode: on | off | strict (default: on)",
     "  --probe                Re-run with probe candidates from discovered paths",
+    "  --harness              Render L0-L5 context harness audit view",
+    "  --client <id>          Harness client: claude-code | skill-cli | generic-mcp | generic",
+    "  --context-window-tokens <n>",
+    "                         Override client context window for harness budget checks",
     "  --timeout-ms <ms>      Per-request timeout in milliseconds (default: 5000)",
     "  --no-color             Disable ANSI colors",
+    "  --no-truncate          Disable output truncation in verbose tables",
     "  -h, --help             Show help"
   ].join("\n");
 }
 
 // src/cli/render.ts
+import { getBorderCharacters, table } from "table";
 function createPalette(enabled) {
   const wrap = (code) => (value) => enabled ? `\x1B[${code}m${value}\x1B[0m` : value;
   return {
@@ -151,7 +218,7 @@ function summarizeWarnings(warnings) {
     },
     {}
   );
-  const codes = Object.entries(codeCounts).sort((a, b) => b[1] - a[1]).slice(0, 8).map(([code]) => code);
+  const codes = Object.entries(codeCounts).sort((a, b) => b[1] - a[1]).map(([code, count]) => ({ code, count }));
   return {
     total: warnings.length,
     errors,
@@ -160,53 +227,134 @@ function summarizeWarnings(warnings) {
     codes
   };
 }
+function asYesNo(value) {
+  return value ? "yes" : "no";
+}
+function truncate(value, max, noTruncate) {
+  if (noTruncate || value.length <= max) {
+    return value;
+  }
+  if (max <= 1) return value.slice(0, max);
+  return `${value.slice(0, Math.max(1, max - 1))}...`;
+}
 function formatPricing(resource) {
   if (resource.authHint !== "paid") return "-";
   if (resource.pricing) {
     if (resource.pricing.pricingMode === "fixed") {
-      return `fixed:${resource.pricing.price ?? "?"}`;
+      return resource.pricing.price ? `fixed ${resource.pricing.price}` : "fixed";
     }
     if (resource.pricing.pricingMode === "range") {
-      return `range:${resource.pricing.minPrice ?? "?"}-${resource.pricing.maxPrice ?? "?"}`;
+      return `range ${resource.pricing.minPrice ?? "?"}-${resource.pricing.maxPrice ?? "?"}`;
     }
     return "quote";
   }
-  return resource.priceHint ?? "-";
+  return resource.priceHint ? `hint ${resource.priceHint}` : "-";
 }
-function asYesNo(value) {
-  return value ? "yes" : "no";
+function statusBadge(ok, palette) {
+  return ok ? palette.green("[PASS]") : palette.red("[FAIL]");
 }
-function createTable(headers, rows) {
-  const widths = headers.map((header, idx) => {
-    const cellWidths = rows.map((row) => row[idx]?.length ?? 0);
-    return Math.max(header.length, ...cellWidths);
-  });
-  const line = (row) => row.map((cell, idx) => {
-    const value = cell ?? "";
-    return value.padEnd(widths[idx], " ");
-  }).join(" | ");
-  const separator = widths.map((width) => "-".repeat(width)).join("-|-");
-  return [line(headers), separator, ...rows.map((row) => line(row))].join("\n");
-}
-function stageRows(result) {
-  return result.trace.map((entry) => {
-    const uniqueWarningCodes = [...new Set(entry.warnings.map((warning2) => warning2.code))];
+function riskBadge(summary, palette) {
+  if (summary.errors > 0) return palette.red("HIGH");
+  if (summary.warns > 0) return palette.yellow("MEDIUM");
+  return palette.green("LOW");
+}
+function sectionHeader(title, palette) {
+  return `${palette.bold(title)}
+${palette.dim("-".repeat(title.length))}`;
+}
+function introBlock(run, options, palette) {
+  const summary = summarizeWarnings(run.result.warnings);
+  const topCodes = summary.codes.slice(0, 3).map(({ code, count }) => `${code} (${count})`).join(", ");
+  const lines = [
+    `${palette.bold("AGENTCASH DISCOVERY AUDIT")} ${statusBadge(run.result.resources.length > 0, palette)}`,
+    `${palette.dim("=".repeat(74))}`,
+    `Target        ${options.target}`,
+    `Origin        ${run.result.origin}`,
+    `Stage         ${run.result.selectedStage ?? "none"}   Compat: ${run.result.compatMode}`,
+    `Resources     ${run.result.resources.length}   Duration: ${run.durationMs}ms`,
+    `Risk          ${riskBadge(summary, palette)}   Upgrade suggested: ${run.result.upgradeSuggested ? "yes" : "no"}`,
+    `Warnings      error=${summary.errors} warn=${summary.warns} info=${summary.infos}`,
+    `Top signals   ${topCodes || "-"}`
+  ];
+  return lines.join("\n");
+}
+function outcomeLine(run) {
+  const selectedStage = run.result.selectedStage ?? "none";
+  if (run.result.resources.length === 0) {
+    return "No usable discovery metadata was found.";
+  }
+  if (selectedStage === "openapi" || selectedStage === "override") {
+    return `Canonical discovery succeeded via ${selectedStage}.`;
+  }
+  return `Discovery succeeded, but only via legacy stage ${selectedStage}.`;
+}
+function actionItems(run, options) {
+  const target = options.target;
+  if (run.result.resources.length === 0) {
+    return [
+      `Run deeper diagnostics: npx @agentcash/discovery ${target} -v --probe --compat on`,
+      `Check that ${target} serves /openapi.json or /.well-known/x402`,
+      "If endpoint exists, verify it returns parseable JSON and non-empty resources"
+    ];
+  }
+  if (run.result.selectedStage === "openapi" || run.result.selectedStage === "override") {
+    return [
+      `Run strict mode hardening: npx @agentcash/discovery ${target} --compat strict -v`,
+      "Reduce warning count to near-zero and keep pricing/auth hints explicit"
+    ];
+  }
+  return [
+    "Publish canonical OpenAPI discovery metadata with x-agentcash extensions",
+    `Validate migration path: npx @agentcash/discovery ${target} --compat strict -v --probe`,
+    "Keep legacy well-known path only during sunset window"
+  ];
+}
+function buildTable(data, maxColWidths, noTruncate) {
+  const rendered = data.map(
+    (row) => row.map((cell, idx) => {
+      const width = maxColWidths[idx] ?? 120;
+      return noTruncate ? cell : truncate(cell, width, false);
+    })
+  );
+  return table(rendered, {
+    border: getBorderCharacters("ramac"),
+    columns: maxColWidths.reduce(
+      (acc, width, idx) => {
+        acc[idx] = noTruncate ? { wrapWord: false, alignment: "left" } : { width, truncate: width, wrapWord: false, alignment: "left" };
+        return acc;
+      },
+      {}
+    ),
+    drawHorizontalLine: (index, size) => index === 0 || index === 1 || index === size,
+    columnDefault: {
+      paddingLeft: 1,
+      paddingRight: 1
+    }
+  }).trimEnd();
+}
+function stageMatrixRows(result) {
+  const header = ["stage", "valid", "resources", "duration", "selected", "warning codes"];
+  const rows = result.trace.map((entry) => {
+    const codes = [...new Set(entry.warnings.map((warning2) => warning2.code))].join(", ");
     return [
       entry.stage,
       asYesNo(entry.valid),
       String(entry.resourceCount),
       `${entry.durationMs}ms`,
-      uniqueWarningCodes.length > 0 ? uniqueWarningCodes.join(",") : "-",
-      result.selectedStage === entry.stage ? "yes" : "-"
+      result.selectedStage === entry.stage ? "yes" : "-",
+      codes || "-"
     ];
   });
+  return [header, ...rows];
 }
-function resourceRows(result) {
-  return [...result.resources].sort((a, b) => {
+function resourceMatrixRows(result) {
+  const sorted = [...result.resources].sort((a, b) => {
     if (a.path !== b.path) return a.path.localeCompare(b.path);
     if (a.method !== b.method) return a.method.localeCompare(b.method);
     return a.origin.localeCompare(b.origin);
-  }).map((resource) => [
+  });
+  const header = ["method", "path", "auth", "pricing", "source", "verified", "notes"];
+  const rows = sorted.map((resource) => [
     resource.method,
     resource.path,
     resource.authHint ?? "-",
@@ -215,61 +363,226 @@ function resourceRows(result) {
     asYesNo(resource.verified),
     resource.authHint === "siwx" ? "siwx" : "-"
   ]);
+  return [header, ...rows];
+}
+function warningRows(summary, result) {
+  const hintByCode = /* @__PURE__ */ new Map();
+  for (const warning2 of result.warnings) {
+    if (!hintByCode.has(warning2.code)) {
+      hintByCode.set(warning2.code, warning2.hint ?? warning2.message);
+    }
+  }
+  const header = ["severity", "code", "count", "hint/message"];
+  const rows = summary.codes.slice(0, 8).map(({ code, count }) => {
+    const sample = hintByCode.get(code) ?? "-";
+    const severity = code.includes("NO_DISCOVERY") ? "error" : code.includes("LEGACY") ? "warn" : "info";
+    return [severity, code, String(count), sample];
+  });
+  return [header, ...rows];
 }
-function renderHeader(run, options, palette, withVerboseSuffix) {
-  const ok = run.result.resources.length > 0;
-  const status = ok ? palette.green("PASS") : palette.red("FAIL");
-  const warningSummary = summarizeWarnings(run.result.warnings);
-  const mode = options.compatMode;
+function harnessBudgetTable(report) {
   return [
-    `${palette.bold("agentcash discovery audit")}${withVerboseSuffix ? ` ${palette.cyan("(verbose)")}` : ""}`,
-    `target: ${options.target}`,
-    `origin: ${run.result.origin}`,
-    `status: ${status}`,
-    `resources: ${run.result.resources.length}`,
-    `selected_stage: ${run.result.selectedStage ?? "none"}`,
-    `compat_mode: ${mode}`,
-    `upgrade_suggested: ${run.result.upgradeSuggested ? palette.yellow("yes") : "no"}`,
-    `duration_ms: ${run.durationMs}`,
-    `warnings: total=${warningSummary.total} error=${warningSummary.errors} warn=${warningSummary.warns} info=${warningSummary.infos}`,
-    warningSummary.codes.length > 0 ? `warning_codes: ${warningSummary.codes.join(", ")}` : "warning_codes: -",
-    options.probe ? `probe_candidates: ${run.probeCandidateCount}` : "probe_candidates: disabled"
-  ].join("\n");
+    ["metric", "value"],
+    ["client", `${report.client.id} (${report.client.surface})`],
+    ["context window tokens", String(report.budget.contextWindowTokens)],
+    ["zero-hop budget tokens", String(report.budget.zeroHopBudgetTokens)],
+    ["estimated L0+L1 tokens", String(report.budget.estimatedZeroHopTokens)],
+    ["within budget", report.budget.withinBudget ? "yes" : "no"]
+  ];
+}
+function harnessLayerSummaryRows(report) {
+  return [
+    ["layer", "what", "primary command", "status"],
+    [
+      "L0",
+      "trigger layer",
+      report.levels.l0.installCommand,
+      `${report.levels.l0.intentTriggers.length} triggers`
+    ],
+    [
+      "L1",
+      "installed domain index",
+      report.levels.l1.fanoutCommands[0] ?? "-",
+      `${report.levels.l1.domainClass}; stage=${report.levels.l1.selectedDiscoveryStage ?? "none"}`
+    ],
+    [
+      "L2",
+      "domain resources",
+      report.levels.l2.command,
+      `${report.levels.l2.resourceCount} resources`
+    ],
+    [
+      "L3",
+      "resource details",
+      report.levels.l3.command,
+      `${report.levels.l3.pricedResourceCount} priced`
+    ],
+    ["L4", "domain guidance", report.levels.l4.llmsTxtUrl ?? "-", report.levels.l4.guidanceStatus],
+    ["L5", "cross-domain composition", "-", report.levels.l5.status]
+  ];
+}
+function harnessL2PreviewRows(report, noTruncate) {
+  const header = ["method", "path", "auth", "source"];
+  const rows = report.levels.l2.resources.slice(0, 15).map((resource) => [
+    resource.method,
+    truncate(resource.path, 54, noTruncate),
+    resource.authMode ?? "-",
+    resource.source
+  ]);
+  return [header, ...rows];
+}
+function renderHarnessSummary(report, options, palette) {
+  const lines = [];
+  lines.push(
+    `${palette.bold("L0-L5 Context Harness")} ${statusBadge(report.levels.l2.resourceCount > 0, palette)}`
+  );
+  lines.push(`${palette.dim("=".repeat(74))}`);
+  lines.push(`Client        ${report.client.label}`);
+  lines.push(`Domain        ${report.levels.l1.domain}`);
+  lines.push(`L2 resources  ${report.levels.l2.resourceCount}`);
+  lines.push(
+    `Budget        ${report.budget.estimatedZeroHopTokens}/${report.budget.zeroHopBudgetTokens} tokens (L0+L1)`
+  );
+  lines.push("");
+  lines.push("Layer map:");
+  lines.push("1. L0 trigger surface -> install and route to agentcash");
+  lines.push(`2. L1 domain index -> ${report.levels.l1.fanoutCommands[0]}`);
+  lines.push(`3. L2 resources -> ${report.levels.l2.command}`);
+  lines.push(`4. L3 details -> ${report.levels.l3.command}`);
+  lines.push(
+    `5. L4 guidance -> ${report.levels.l4.guidanceStatus}${report.levels.l4.llmsTxtUrl ? ` (${report.levels.l4.llmsTxtUrl})` : ""}`
+  );
+  lines.push("6. L5 cross-domain -> out of scope in v1");
+  lines.push("");
+  lines.push(
+    `Next: npx @agentcash/discovery ${options.target} --harness -v --client ${report.client.id}`
+  );
+  return lines.join("\n");
+}
+function renderHarnessVerbose(report, options, palette) {
+  const lines = [];
+  lines.push(
+    `${palette.bold("L0-L5 Context Harness (Verbose)")} ${statusBadge(report.levels.l2.resourceCount > 0, palette)}`
+  );
+  lines.push(`${palette.dim("=".repeat(74))}`);
+  lines.push(`Target ${report.target}`);
+  lines.push(`Origin ${report.origin}`);
+  lines.push(`Client ${report.client.label}`);
+  lines.push("");
+  lines.push(sectionHeader("Budget check", palette));
+  lines.push(buildTable(harnessBudgetTable(report), [30, 42], options.noTruncate));
+  lines.push("");
+  lines.push(sectionHeader("Layer summary", palette));
+  lines.push(buildTable(harnessLayerSummaryRows(report), [8, 24, 44, 28], options.noTruncate));
+  lines.push("");
+  lines.push(sectionHeader("L2 resource preview", palette));
+  if (report.levels.l2.resources.length === 0) {
+    lines.push(palette.dim("(no discovered resources)"));
+  } else {
+    lines.push(
+      buildTable(
+        harnessL2PreviewRows(report, options.noTruncate),
+        [10, 54, 12, 20],
+        options.noTruncate
+      )
+    );
+    if (report.levels.l2.resources.length > 15) {
+      lines.push(
+        palette.dim(
+          `Showing 15/${report.levels.l2.resources.length} resources. Use --json to inspect full L2/L3 payload.`
+        )
+      );
+    }
+  }
+  lines.push("");
+  lines.push(sectionHeader("L4 guidance", palette));
+  lines.push(`status: ${report.levels.l4.guidanceStatus}`);
+  lines.push(`llms.txt url: ${report.levels.l4.llmsTxtUrl ?? "-"}`);
+  lines.push(`llms.txt tokens: ${report.levels.l4.llmsTxtTokenEstimate}`);
+  lines.push(`preview: ${report.levels.l4.guidancePreview ?? "-"}`);
+  lines.push("");
+  lines.push(sectionHeader("Diagnostics", palette));
+  lines.push(
+    `warnings: ${report.diagnostics.warningCount} (errors=${report.diagnostics.errorWarningCount})`
+  );
+  lines.push(`selected stage: ${report.diagnostics.selectedStage ?? "none"}`);
+  lines.push(`upgrade suggested: ${report.diagnostics.upgradeSuggested ? "yes" : "no"}`);
+  lines.push(
+    `upgrade reasons: ${report.diagnostics.upgradeReasons.length > 0 ? report.diagnostics.upgradeReasons.join(", ") : "-"}`
+  );
+  return lines.join("\n");
 }
 function renderSummary(run, options) {
   const palette = createPalette(options.color);
-  return renderHeader(run, options, palette, false);
+  if (options.harness && run.harness) {
+    return renderHarnessSummary(run.harness, options, palette);
+  }
+  const body = [];
+  body.push(introBlock(run, options, palette));
+  body.push("");
+  body.push(`Outcome: ${outcomeLine(run)}`);
+  const items = actionItems(run, options);
+  body.push("Next:");
+  for (let i = 0; i < items.length; i += 1) {
+    body.push(`${i + 1}. ${items[i]}`);
+  }
+  if (options.probe) {
+    body.push(`Probe candidates considered: ${run.probeCandidateCount}`);
+  }
+  return body.join("\n");
 }
 function renderVerbose(run, options) {
   const palette = createPalette(options.color);
-  const parts = [renderHeader(run, options, palette, true), ""];
-  parts.push(palette.bold("stage_matrix"));
-  parts.push(
-    createTable(
-      ["stage", "valid", "resources", "duration", "warning_codes", "selected"],
-      stageRows(run.result)
-    )
-  );
-  parts.push("");
-  parts.push(palette.bold("resource_matrix"));
+  if (options.harness && run.harness) {
+    return renderHarnessVerbose(run.harness, options, palette);
+  }
+  const summary = summarizeWarnings(run.result.warnings);
+  const noTruncate = options.noTruncate;
+  const body = [];
+  body.push(introBlock(run, options, palette));
+  body.push("");
+  body.push(sectionHeader("What this means", palette));
+  body.push(outcomeLine(run));
+  body.push("");
+  body.push(sectionHeader("Recommended actions", palette));
+  const items = actionItems(run, options);
+  for (let i = 0; i < items.length; i += 1) {
+    body.push(`${i + 1}. ${items[i]}`);
+  }
+  body.push("");
+  body.push(sectionHeader("Compatibility matrix", palette));
+  body.push(buildTable(stageMatrixRows(run.result), [18, 8, 10, 10, 10, 56], noTruncate));
+  body.push("");
+  body.push(sectionHeader("Resource matrix", palette));
   if (run.result.resources.length === 0) {
-    parts.push(palette.dim("(no discovered resources)"));
+    body.push(palette.dim("(no discovered resources)"));
   } else {
-    parts.push(
-      createTable(
-        ["method", "path", "auth", "pricing", "source", "verified", "notes"],
-        resourceRows(run.result)
-      )
-    );
+    const allRows = resourceMatrixRows(run.result);
+    const previewRows = allRows.slice(0, 16);
+    body.push(buildTable(previewRows, [8, 44, 10, 24, 18, 10, 10], noTruncate));
+    if (allRows.length > previewRows.length) {
+      body.push(
+        palette.dim(
+          `Showing ${previewRows.length - 1}/${allRows.length - 1} resources. Use --no-truncate or --json for complete output.`
+        )
+      );
+    }
+  }
+  body.push("");
+  body.push(sectionHeader("Warning breakdown", palette));
+  if (summary.codes.length === 0) {
+    body.push(palette.dim("(no warnings)"));
+  } else {
+    body.push(buildTable(warningRows(summary, run.result), [10, 34, 8, 62], noTruncate));
   }
   if (run.result.upgradeReasons.length > 0) {
-    parts.push("");
-    parts.push(palette.bold("upgrade_reasons"));
+    body.push("");
+    body.push(sectionHeader("Upgrade guidance", palette));
     for (const reason of run.result.upgradeReasons) {
-      parts.push(`- ${reason}`);
+      body.push(`- ${reason}`);
     }
   }
-  return parts.join("\n");
+  return body.join("\n");
 }
 function renderJson(run, options) {
   return JSON.stringify(
@@ -289,13 +602,17 @@ function renderJson(run, options) {
         probeEnabled: options.probe,
         probeCandidateCount: run.probeCandidateCount,
         timeoutMs: options.timeoutMs
-      }
+      },
+      ...run.harness ? { harness: run.harness } : {}
     },
     null,
     2
   );
 }
 
+// src/mmm-enabled.ts
+var isMmmEnabled = () => "0.1.2".includes("-mmm");
+
 // src/core/constants.ts
 var OPENAPI_PATH_CANDIDATES = ["/openapi.json", "/.well-known/openapi.json"];
 var WELL_KNOWN_MPP_PATH = "/.well-known/mpp";
@@ -1248,7 +1565,7 @@ function detectProtocols(response) {
   }
   const authHeader = response.headers.get("www-authenticate")?.toLowerCase() ?? "";
   if (authHeader.includes("x402")) protocols.add("x402");
-  if (authHeader.includes("mpp")) protocols.add("mpp");
+  if (isMmmEnabled() && authHeader.includes("mpp")) protocols.add("mpp");
   return [...protocols];
 }
 async function runProbeStage(options) {
@@ -1580,7 +1897,7 @@ async function runDiscovery({
         includeRaw
       })
     );
-    if (includeInteropMpp) {
+    if (includeInteropMpp && isMmmEnabled()) {
       stages.push(
         () => runInteropMppStage({
           origin,
@@ -1682,6 +1999,216 @@ async function runDiscovery({
   };
 }
 
+// src/harness.ts
+var INTENT_TRIGGERS = ["x402", "mpp", "pay for", "micropayment", "agentic commerce"];
+var CLIENT_PROFILES = {
+  "claude-code": {
+    id: "claude-code",
+    label: "Claude Code MCP Harness",
+    surface: "mcp",
+    defaultContextWindowTokens: 2e5,
+    zeroHopBudgetPercent: 0.1,
+    notes: "Targets environments where MCP context can use roughly 10% of total context."
+  },
+  "skill-cli": {
+    id: "skill-cli",
+    label: "Skill + CLI Harness",
+    surface: "skill-cli",
+    defaultContextWindowTokens: 2e5,
+    zeroHopBudgetPercent: 0.02,
+    notes: "Targets constrained skill contexts with title/description-heavy routing."
+  },
+  "generic-mcp": {
+    id: "generic-mcp",
+    label: "Generic MCP Harness",
+    surface: "mcp",
+    defaultContextWindowTokens: 128e3,
+    zeroHopBudgetPercent: 0.05,
+    notes: "Conservative MCP profile when specific client budgets are unknown."
+  },
+  generic: {
+    id: "generic",
+    label: "Generic Agent Harness",
+    surface: "generic",
+    defaultContextWindowTokens: 128e3,
+    zeroHopBudgetPercent: 0.03,
+    notes: "Fallback profile for unknown clients."
+  }
+};
+function isFirstPartyDomain(hostname) {
+  const normalized = hostname.toLowerCase();
+  return normalized.endsWith(".dev") && normalized.startsWith("stable");
+}
+function safeHostname(origin) {
+  try {
+    return new URL(origin).hostname;
+  } catch {
+    return origin.replace(/^https?:\/\//, "").split("/")[0] ?? origin;
+  }
+}
+function previewText(text) {
+  if (!text) return null;
+  const compact = text.replace(/\s+/g, " ").trim();
+  if (!compact) return null;
+  return compact.length > 220 ? `${compact.slice(0, 217)}...` : compact;
+}
+function toAuthModeCount(resources) {
+  const counts = {
+    paid: 0,
+    siwx: 0,
+    apiKey: 0,
+    unprotected: 0,
+    unknown: 0
+  };
+  for (const resource of resources) {
+    const mode = resource.authHint;
+    if (mode === "paid" || mode === "siwx" || mode === "apiKey" || mode === "unprotected") {
+      counts[mode] += 1;
+    } else {
+      counts.unknown += 1;
+    }
+  }
+  return counts;
+}
+function toSourceCount(resources) {
+  return resources.reduce(
+    (acc, resource) => {
+      acc[resource.source] = (acc[resource.source] ?? 0) + 1;
+      return acc;
+    },
+    {}
+  );
+}
+function toL2Entries(resources) {
+  return [...resources].sort((a, b) => {
+    if (a.path !== b.path) return a.path.localeCompare(b.path);
+    if (a.method !== b.method) return a.method.localeCompare(b.method);
+    return a.resourceKey.localeCompare(b.resourceKey);
+  }).map((resource) => ({
+    resourceKey: resource.resourceKey,
+    method: resource.method,
+    path: resource.path,
+    source: resource.source,
+    authMode: resource.authHint ?? null
+  }));
+}
+function getLlmsTxtInfo(result) {
+  const llmsTxtUrl = result.trace.find((entry) => entry.links?.llmsTxtUrl)?.links?.llmsTxtUrl ?? result.resources.find((resource) => resource.links?.llmsTxtUrl)?.links?.llmsTxtUrl ?? null;
+  const llmsTxt = result.rawSources?.llmsTxt;
+  if (llmsTxt) {
+    return {
+      llmsTxtUrl,
+      llmsTxtTokenEstimate: estimateTokenCount(llmsTxt),
+      guidancePreview: previewText(llmsTxt),
+      guidanceStatus: "present"
+    };
+  }
+  if (llmsTxtUrl) {
+    const failed = result.warnings.some((warning2) => warning2.code === "LLMSTXT_FETCH_FAILED");
+    return {
+      llmsTxtUrl,
+      llmsTxtTokenEstimate: 0,
+      guidancePreview: null,
+      guidanceStatus: failed ? "advertised_but_unfetched" : "missing"
+    };
+  }
+  return {
+    llmsTxtUrl: null,
+    llmsTxtTokenEstimate: 0,
+    guidancePreview: null,
+    guidanceStatus: "not_advertised"
+  };
+}
+function getHarnessClientProfile(client = "claude-code") {
+  return CLIENT_PROFILES[client] ?? CLIENT_PROFILES.generic;
+}
+function buildContextHarnessReport(options) {
+  const client = getHarnessClientProfile(options.client);
+  const contextWindowTokens = options.contextWindowTokens ?? client.defaultContextWindowTokens;
+  const zeroHopBudgetTokens = Math.floor(contextWindowTokens * client.zeroHopBudgetPercent);
+  const hostname = safeHostname(options.result.origin);
+  const domainClass = isFirstPartyDomain(hostname) ? "first-party" : "ugc";
+  const l0Summary = "Route payment-capable intents to agentcash and use install/discover commands for progressive disclosure.";
+  const l1Summary = "Expose installed domain routing hints and trigger fan-out into L2/L3 commands when user intent matches domain capabilities.";
+  const l0EstimatedTokens = estimateTokenCount(
+    `${INTENT_TRIGGERS.join(", ")} npx agentcash install npx agentcash install-ext`
+  );
+  const l1EstimatedTokens = estimateTokenCount(
+    `${hostname} ${l1Summary} npx agentcash discover ${hostname} npx agentcash discover ${hostname} --verbose`
+  );
+  const llmsInfo = getLlmsTxtInfo(options.result);
+  return {
+    target: options.target,
+    origin: options.result.origin,
+    client,
+    budget: {
+      contextWindowTokens,
+      zeroHopBudgetTokens,
+      estimatedZeroHopTokens: l0EstimatedTokens + l1EstimatedTokens,
+      withinBudget: l0EstimatedTokens + l1EstimatedTokens <= zeroHopBudgetTokens
+    },
+    levels: {
+      l0: {
+        layer: "L0",
+        intentTriggers: INTENT_TRIGGERS,
+        installCommand: "npx agentcash install",
+        deliverySurfaces: ["MCP", "Skill+CLI"],
+        summary: l0Summary,
+        estimatedTokens: l0EstimatedTokens
+      },
+      l1: {
+        layer: "L1",
+        domain: hostname,
+        domainClass,
+        selectedDiscoveryStage: options.result.selectedStage ?? null,
+        summary: l1Summary,
+        fanoutCommands: [
+          `npx agentcash discover ${hostname}`,
+          `npx agentcash discover ${hostname} --verbose`
+        ],
+        estimatedTokens: l1EstimatedTokens
+      },
+      l2: {
+        layer: "L2",
+        command: `npx agentcash discover ${hostname}`,
+        tokenLight: true,
+        resourceCount: options.result.resources.length,
+        resources: toL2Entries(options.result.resources)
+      },
+      l3: {
+        layer: "L3",
+        command: `npx agentcash discover ${hostname} --verbose`,
+        detailLevel: "endpoint-schema-and-metadata",
+        countsByAuthMode: toAuthModeCount(options.result.resources),
+        countsBySource: toSourceCount(options.result.resources),
+        pricedResourceCount: options.result.resources.filter(
+          (resource) => resource.authHint === "paid"
+        ).length
+      },
+      l4: {
+        layer: "L4",
+        guidanceSource: llmsInfo.llmsTxtUrl ? "llms.txt" : "none",
+        llmsTxtUrl: llmsInfo.llmsTxtUrl,
+        llmsTxtTokenEstimate: llmsInfo.llmsTxtTokenEstimate,
+        guidancePreview: llmsInfo.guidancePreview,
+        guidanceStatus: llmsInfo.guidanceStatus
+      },
+      l5: {
+        layer: "L5",
+        status: "out_of_scope",
+        note: "Cross-domain composition is intentionally out of scope for discovery v1."
+      }
+    },
+    diagnostics: {
+      warningCount: options.result.warnings.length,
+      errorWarningCount: options.result.warnings.filter((warning2) => warning2.severity === "error").length,
+      selectedStage: options.result.selectedStage ?? null,
+      upgradeSuggested: options.result.upgradeSuggested,
+      upgradeReasons: options.result.upgradeReasons
+    }
+  };
+}
+
 // src/index.ts
 async function discoverDetailed(options) {
   return await runDiscovery({ detailed: true, options });
@@ -1732,7 +2259,7 @@ async function runAudit(options, deps = {}) {
     headers: {
       "user-agent": CLI_USER_AGENT
     },
-    rawView: "none"
+    rawView: options.harness ? "full" : "none"
   };
   const startedAt = Date.now();
   let result = await discoverDetailedFn(baseOptions);
@@ -1750,7 +2277,15 @@ async function runAudit(options, deps = {}) {
   return {
     result,
     durationMs: Date.now() - startedAt,
-    probeCandidateCount
+    probeCandidateCount,
+    ...options.harness ? {
+      harness: buildContextHarnessReport({
+        target: options.target,
+        result,
+        client: options.client,
+        contextWindowTokens: options.contextWindowTokens
+      })
+    } : {}
   };
 }