@agentproto/corpus-cli 0.3.0 → 0.4.0

package/LICENSE

@@ -1,21 +1,202 @@
-MIT License
-
-Copyright (c) 2026 agentproto contributors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -10,6 +10,7 @@ pnpm add -g @agentproto/corpus-cli
 corpus init marketing ./my-corpus      # scaffold a starter workspace
 corpus validate ./my-corpus             # validate every AIP file
 corpus lint ./my-corpus                 # run KNOWLEDGE.md-declared lints
+corpus verify ./my-corpus --facets landscape,daemons  # coverage + self-flag scan
 corpus events:emit corpus.entry.promoted --payload '{"slug":"foo"}' ./my-corpus
 corpus events:tail ./my-corpus          # tail _log.md
 ```
@@ -21,6 +22,7 @@ Minimum-viable local host:
 - `corpus init <vertical> [path]` — seed a starter workspace
 - `corpus validate [path]` — JSON Schema check across every AIP file
 - `corpus lint [path]` — run the lints declared in KNOWLEDGE.md
+- `corpus verify [path] --facets a,b,... [--thin 8] [--apply] [--contaminated]` — SOP ⑤b VERIFY pass: active-entry coverage per facet tag (facets below `--thin` are reported `THIN`) plus a self-flag scan for entries whose own text signals a bad scrape. `--apply` moves flagged entries to `demoted/` (a sibling of `entries/`, non-destructive); `--contaminated` also demotes every entry sharing a source with a flagged entry.
 - `corpus events:emit <kind> --payload <json> [path]` — append an event to `_log.md`
 - `corpus events:tail [path]` — print `_log.md`
 

package/dist/cli.mjs

@@ -12,7 +12,7 @@ import matter2 from 'gray-matter';
 import { execFile } from 'child_process';
 import { promisify } from 'util';
 import { parseClaudeJsonOutput, spawnWithStdin } from '@agentproto/cli-exec';
-import { stitchReport, buildPacks, reportConfigSchema } from '@agentproto/corpus/report';
+import { stitchReport, buildPacks, lintReportConfig, reportConfigSchema } from '@agentproto/corpus/report';
 
 /**
  * @agentproto/corpus-cli v0.1.0-alpha
@@ -104,9 +104,9 @@ function resolvePackageJson(packageName) {
   }
   return null;
 }
-async function readJsonIfExists(path5) {
+async function readJsonIfExists(path6) {
   try {
-    const raw = await readFile(path5, "utf8");
+    const raw = await readFile(path6, "utf8");
     return JSON.parse(raw);
   } catch (err) {
     if (err.code === "ENOENT") return void 0;
@@ -115,9 +115,9 @@ async function readJsonIfExists(path5) {
 }
 async function readConfiguredPresetPackages() {
   const base = process.env["AGENTPROTO_HOME"] ?? join(homedir(), ".agentproto");
-  const path5 = join(base, "config.json");
+  const path6 = join(base, "config.json");
   try {
-    const raw = await readFile(path5, "utf8");
+    const raw = await readFile(path6, "utf8");
     const parsed = JSON.parse(raw);
     const list = parsed.corpusPresetPackages;
     if (Array.isArray(list) && list.length > 0) return list;
@@ -631,6 +631,160 @@ async function runLint(args) {
   );
   return report.errorCount > 0 ? 1 : 0;
 }
+var FLAG_PATTERNS = [
+  /does not match/i,
+  /content is about/i,
+  /no substantive content/i,
+  /content mismatch/i,
+  /appears to be a (?:newsletter|navigation|login|error) page/i,
+  /stated title/i,
+  /placeholder page/i,
+  /cookie consent/i,
+  /page could not be/i
+];
+function parse(args) {
+  const out = {
+    workspace: void 0,
+    facets: [],
+    thin: 8,
+    apply: false,
+    contaminated: false
+  };
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    const next = () => args[++i];
+    switch (a) {
+      case "--facets": {
+        const v = next();
+        if (v) out.facets = v.split(",").map((s) => s.trim()).filter(Boolean);
+        break;
+      }
+      case "--thin": {
+        const v = next();
+        if (v) out.thin = Number(v);
+        break;
+      }
+      case "--apply":
+        out.apply = true;
+        break;
+      case "--contaminated":
+        out.contaminated = true;
+        break;
+      default:
+        if (!a.startsWith("-") && out.workspace === void 0) out.workspace = a;
+    }
+  }
+  return out;
+}
+function firstFlag(haystack) {
+  for (const re of FLAG_PATTERNS) {
+    const m = haystack.match(re);
+    if (m) return m[0];
+  }
+  return void 0;
+}
+function entryStatus(entry) {
+  const corpus = entry.frontmatter.metadata?.corpus;
+  return corpus?.status ?? "active";
+}
+function tagsOf(entry) {
+  const tags = entry.frontmatter.tags;
+  return Array.isArray(tags) ? tags.map(String) : [];
+}
+function sourcesOf(entry) {
+  const sources = entry.frontmatter.sources;
+  return Array.isArray(sources) ? sources.map(String) : [];
+}
+async function runVerify(args) {
+  const parsed = parse(args);
+  if (parsed.facets.length === 0) {
+    return fail(
+      "verify requires --facets a,b,c. Usage: corpus verify <workspace> --facets landscape,daemons,... [--thin 8] [--apply] [--contaminated]",
+      2
+    );
+  }
+  const target = resolveWorkspacePath(parsed.workspace);
+  const fs = new NodeFsAdapter({ root: target });
+  if (!await fs.exists("entries")) {
+    return fail(`verify: no entries/ under ${target}`, 1);
+  }
+  const snapshot = await new CorpusWorkspaceReader({ fs }).read("");
+  const entries = snapshot.entries.filter((e) => entryStatus(e) === "active");
+  const perFacet = /* @__PURE__ */ new Map();
+  for (const facet of parsed.facets) perFacet.set(facet, 0);
+  for (const entry of entries) {
+    for (const tag of tagsOf(entry)) {
+      if (perFacet.has(tag)) perFacet.set(tag, (perFacet.get(tag) ?? 0) + 1);
+    }
+  }
+  process.stdout.write(`== coverage (${entries.length} entries) ==
+`);
+  const thin = [];
+  for (const facet of parsed.facets) {
+    const n = perFacet.get(facet) ?? 0;
+    if (n < parsed.thin) thin.push(facet);
+    const mark = n < parsed.thin ? "  THIN \u26A0" : "";
+    process.stdout.write(`  ${facet.padEnd(16)} ${String(n).padStart(4)}${mark}
+`);
+  }
+  const flagged = [];
+  for (const entry of entries) {
+    const title = String(entry.frontmatter.title ?? "");
+    const why = firstFlag(`${title}
+${entry.body}`);
+    if (why) flagged.push({ entry, why });
+  }
+  process.stdout.write(`
+== self-flagged entries (${flagged.length}) ==
+`);
+  const poisonedSources = /* @__PURE__ */ new Set();
+  for (const { entry, why } of flagged) {
+    process.stdout.write(`  ${entry.path}  [${why}]
+`);
+    for (const s of sourcesOf(entry)) poisonedSources.add(s);
+  }
+  const flaggedPaths = new Set(flagged.map((f) => f.entry.path));
+  const contaminated = [];
+  if (parsed.contaminated && poisonedSources.size > 0) {
+    for (const entry of entries) {
+      if (flaggedPaths.has(entry.path)) continue;
+      if (sourcesOf(entry).some((s) => poisonedSources.has(s))) {
+        contaminated.push(entry);
+      }
+    }
+    process.stdout.write(
+      `
+== contaminated siblings (${contaminated.length}) from ${poisonedSources.size} poisoned source(s) ==
+`
+    );
+    for (const entry of contaminated) {
+      process.stdout.write(`  ${entry.path}
+`);
+    }
+  }
+  if (parsed.apply) {
+    const toMove = [...flagged.map((f) => f.entry), ...contaminated];
+    for (const entry of toMove) {
+      const rel = path.relative("entries", entry.path);
+      const dest = path.join(target, "demoted", rel);
+      await mkdir(path.dirname(dest), { recursive: true });
+      await rename(path.join(target, entry.path), dest);
+    }
+    process.stdout.write(`
+moved ${toMove.length} entries \u2192 demoted/
+`);
+  } else if (flagged.length > 0) {
+    process.stdout.write(
+      "\n(re-run with --apply to quarantine; --contaminated to also demote siblings)\n"
+    );
+  }
+  if (thin.length > 0) {
+    process.stdout.write(`
+thin facets \u2192 loop back to \u2461 DISCOVER: ${thin.join(", ")}
+`);
+  }
+  return 0;
+}
 var OsIdentityAdapter = class {
   cached;
   constructor(opts) {
@@ -1297,18 +1451,18 @@ var AssemblyAiStt = class {
       ...job.language_code ? { language: job.language_code } : {}
     };
   }
-  async post(path5, body) {
-    const r = await fetch(`${this.baseUrl}${path5}`, {
+  async post(path6, body) {
+    const r = await fetch(`${this.baseUrl}${path6}`, {
       method: "POST",
       headers: { authorization: this.apiKey, "content-type": "application/json" },
       body: JSON.stringify(body)
     });
-    if (!r.ok) throw new Error(`AssemblyAI POST ${path5} ${r.status}: ${(await r.text()).slice(0, 200)}`);
+    if (!r.ok) throw new Error(`AssemblyAI POST ${path6} ${r.status}: ${(await r.text()).slice(0, 200)}`);
     return AAI_TRANSCRIPT.parse(await r.json());
   }
-  async get(path5) {
-    const r = await fetch(`${this.baseUrl}${path5}`, { headers: { authorization: this.apiKey } });
-    if (!r.ok) throw new Error(`AssemblyAI GET ${path5} ${r.status}: ${(await r.text()).slice(0, 200)}`);
+  async get(path6) {
+    const r = await fetch(`${this.baseUrl}${path6}`, { headers: { authorization: this.apiKey } });
+    if (!r.ok) throw new Error(`AssemblyAI GET ${path6} ${r.status}: ${(await r.text()).slice(0, 200)}`);
     return AAI_TRANSCRIPT.parse(await r.json());
   }
 };
@@ -1593,7 +1747,7 @@ var SOURCE_URL_FRONTMATTER = z.object({
     }).loose().optional().catch(void 0)
   }).loose().optional().catch(void 0)
 }).loose();
-function parse(args) {
+function parse2(args) {
   const out = {
     workspace: void 0,
     urlsFile: void 0,
@@ -1723,7 +1877,7 @@ async function scanIngestedUrls(workspaceRoot) {
   return seen;
 }
 async function runImportWeb(args) {
-  const parsed = parse(args);
+  const parsed = parse2(args);
   const target = resolveWorkspacePath(parsed.workspace);
   const urls = await readUrls(parsed);
   if (urls.length === 0) {
@@ -1863,7 +2017,7 @@ knowledge engine (RAG) via the WriterPort. Import only stages the sources.
 function msg3(e) {
   return e instanceof Error ? e.message : String(e);
 }
-function parse2(args) {
+function parse3(args) {
   const out = {
     topic: void 0,
     outputPath: void 0,
@@ -1871,7 +2025,8 @@ function parse2(args) {
     channels: /* @__PURE__ */ new Set(["web"]),
     lang: void 0,
     tags: [],
-    doImport: false
+    doImport: false,
+    fresh: false
   };
   for (let i = 0; i < args.length; i++) {
     const a = args[i];
@@ -1898,6 +2053,9 @@ function parse2(args) {
       case "--import":
         out.doImport = true;
         break;
+      case "--fresh":
+        out.fresh = true;
+        break;
       default:
         if (!a.startsWith("-")) {
           if (out.topic === void 0) out.topic = a;
@@ -2025,10 +2183,18 @@ async function discoverSocial(_topic, _lang, _max) {
   process.stdout.write("  social channel needs a Bureau session \u2014 skipped.\n");
   return [];
 }
+async function readExistingUrls(outFile) {
+  try {
+    const prior = await readFile(outFile, "utf-8");
+    return prior.split("\n").map((l) => l.trim()).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
 async function runDiscover(args) {
-  const parsed = parse2(args);
+  const parsed = parse3(args);
   if (!parsed.topic) {
-    return fail("discover requires a <topic> argument. Usage: corpus discover <topic> [path] [--max N] [--channels web,youtube,social] [--lang fr] [--tags t] [--import]", 2);
+    return fail("discover requires a <topic> argument. Usage: corpus discover <topic> [path] [--max N] [--channels web,youtube,social] [--lang fr] [--tags t] [--import] [--fresh]", 2);
   }
   const outputPath = parsed.outputPath ? resolveWorkspacePath(parsed.outputPath) : process.cwd();
   process.stdout.write(`discover "${parsed.topic}"
@@ -2071,10 +2237,22 @@ async function runDiscover(args) {
   }
   await mkdir(outputPath, { recursive: true });
   const outFile = join(outputPath, "urls.discovered.txt");
-  await writeFile(outFile, allUrls.join("\n") + "\n", "utf-8");
-  process.stdout.write(`
-  written \u2192 ${outFile}
-`);
+  const existing = parsed.fresh ? [] : await readExistingUrls(outFile);
+  const merged = [...existing];
+  const known = new Set(existing);
+  for (const url of allUrls) {
+    if (!known.has(url)) {
+      known.add(url);
+      merged.push(url);
+    }
+  }
+  const added = merged.length - existing.length;
+  await writeFile(outFile, merged.join("\n") + "\n", "utf-8");
+  process.stdout.write(
+    `
+  written \u2192 ${outFile} (${merged.length} URLs` + (parsed.fresh ? ", --fresh overwrite" : `, ${added} new, ${existing.length} kept from previous runs`) + `)
+`
+  );
   if (parsed.doImport) {
     process.stdout.write("\n  --import: chaining import-web\u2026\n");
     const importArgs = [
@@ -2445,7 +2623,7 @@ var DISTILLER_ENGINES = {
     ])
   )
 };
-function parse3(args) {
+function parse4(args) {
   const out = {
     workspace: void 0,
     sourceId: void 0,
@@ -2500,13 +2678,13 @@ async function readSources(root) {
   const out = [];
   for (const e of entries) {
     if (!e.isFile() || !e.name.endsWith(".md")) continue;
-    const path5 = join(e.parentPath, e.name);
+    const path6 = join(e.parentPath, e.name);
     try {
-      const parsed = matter2(await readFile(path5, "utf-8"));
+      const parsed = matter2(await readFile(path6, "utf-8"));
       const fm = SOURCE_FRONTMATTER.parse(parsed.data);
       if (!fm.id || !parsed.content.trim()) continue;
       out.push({
-        path: path5,
+        path: path6,
         id: fm.id,
         title: fm.title ?? fm.id,
         body: parsed.content.trim(),
@@ -2542,7 +2720,7 @@ async function scanDistilledSourceIds(root) {
 }
 var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 async function runDistill(args) {
-  const parsed = parse3(args);
+  const parsed = parse4(args);
   const target = resolveWorkspacePath(parsed.workspace);
   const engine = DISTILLER_ENGINES[parsed.engine];
   if (!engine) {
@@ -2681,7 +2859,12 @@ async function runReport(args) {
 }
 function loadReportConfig(configPath) {
   const raw = readFileSync(path.resolve(process.cwd(), configPath), "utf8");
-  return reportConfigSchema.parse(JSON.parse(raw));
+  const parsed = JSON.parse(raw);
+  for (const warning of lintReportConfig(parsed)) {
+    process.stderr.write(`corpus report: ${warning}
+`);
+  }
+  return reportConfigSchema.parse(parsed);
 }
 async function runReportPacks(args) {
   let dataset;
@@ -3162,12 +3345,20 @@ Commands:
                                          (--preset seeds a full vertical; --list shows them)
   validate [path]                        JSON Schema check across every AIP file
   lint [path]                            Run lints declared in KNOWLEDGE.md
+  verify [path] --facets a,b,... [--thin 8] [--apply] [--contaminated]
+                                         SOP \u2464b: coverage per facet tag +
+                                         quarantine of self-flagged bad scrapes.
+                                         --apply moves flagged entries to
+                                         demoted/ (reversible); --contaminated
+                                         (with --apply) also demotes siblings
+                                         sharing a poisoned source.
   events:emit <kind> --payload <json> [path]
                                          Append an event to _log.md
   events:tail [path]                     Print _log.md
-  discover <topic> [path] [--max N --channels web,youtube,social --lang l --tags t --import]
+  discover <topic> [path] [--max N --channels web,youtube,social --lang l --tags t --import --fresh]
                                          Fan out across channels (web search + YouTube +
-                                         social), dedup, write urls.discovered.txt.
+                                         social), dedup, merge into urls.discovered.txt
+                                         (union with previous runs; --fresh overwrites).
                                          Web: auto-picks first available key (SERPER /
                                          EXA / TAVILY / GOOGLE_SEARCH). YouTube: yt-dlp
                                          flat-playlist. --import chains import-web.
@@ -3229,6 +3420,8 @@ async function main(argv2) {
       return await runValidate(rest);
     case "lint":
       return await runLint(rest);
+    case "verify":
+      return await runVerify(rest);
     case "events:emit":
       return await runEventsEmit(rest);
     case "events:tail":