@agentproto/corpus-cli 0.1.0-alpha.1

package/dist/cli.mjs

@@ -0,0 +1,2607 @@
+#!/usr/bin/env node
+import { readFile, stat, mkdir, writeFile, rename, appendFile, readdir, rm, mkdtemp } from 'fs/promises';
+import os, { tmpdir, homedir } from 'os';
+import { createRequire } from 'module';
+import path, { basename, join, extname, dirname } from 'path';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { z } from 'zod';
+import { randomBytes, randomUUID } from 'crypto';
+import { readFileSync, existsSync } from 'fs';
+import { buildDistillPrompt, parseItems, isRefinedKind, SyncRunner, resolveKnowledge, DistillRunner, systemClock, WebImporter, ImporterRunner, CorpusEventEmitter, CorpusWorkspaceReader, CorpusLinter, CorpusValidator, normalizeLanguageTag } from '@agentproto/corpus';
+import matter2 from 'gray-matter';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import { parseClaudeJsonOutput, spawnWithStdin } from '@agentproto/cli-exec';
+
+/**
+ * @agentproto/corpus-cli v0.1.0-alpha
+ * The `corpus` binary — local-topology host for AIP-10 corpora.
+ */
+
+var CORPUS_PRESET_MANIFEST_SCHEMA = "agentproto/corpus-preset/v1";
+var PresetEntrySchema = z.object({
+  /** The slug `corpus init <slug>` matches. */
+  slug: z.string().regex(/^[a-z][a-z0-9-]*$/),
+  /** Path to the entry module, relative to the preset package root. */
+  entry: z.string().min(1),
+  /** Named export inside `entry` — the CorpusPreset constant. */
+  export: z.string().min(1),
+  /** Free-form description; shown when listing available slugs. */
+  description: z.string().optional()
+}).loose();
+var CorpusPresetManifestSchema = z.object({
+  schema: z.literal(CORPUS_PRESET_MANIFEST_SCHEMA),
+  presets: z.array(PresetEntrySchema).default([])
+}).loose();
+
+// src/registry/preset-loader.ts
+var DEFAULT_PRESET_PACKAGES = ["@agentproto/corpus-presets"];
+async function discoverPresets() {
+  const packages = await readConfiguredPresetPackages();
+  const out = /* @__PURE__ */ new Map();
+  for (const pkg of packages) {
+    const result = await readPresetManifest(pkg);
+    if (!result) continue;
+    const { manifest, packageRoot } = result;
+    for (const entry of manifest.presets) {
+      out.set(entry.slug, {
+        ...entry,
+        packageName: pkg,
+        packageRoot
+      });
+    }
+  }
+  return out;
+}
+async function loadPreset(slug) {
+  const presets = await discoverPresets();
+  const entry = presets.get(slug);
+  if (!entry) return null;
+  const abs = entry.entry.startsWith(".") ? join(entry.packageRoot, entry.entry) : entry.entry;
+  const url = entry.entry.startsWith(".") ? pathToFileURL(abs).href : entry.entry;
+  const mod = await import(url);
+  const exported = mod[entry.export];
+  if (!exported || typeof exported !== "object") {
+    throw new Error(
+      `corpus-presets: '${entry.packageName}' entry '${entry.entry}' has no object export '${entry.export}' (got ${typeof exported}).`
+    );
+  }
+  return exported;
+}
+async function readPresetManifest(packageName) {
+  const packageJsonPath = resolvePackageJson(packageName);
+  if (!packageJsonPath) return null;
+  const packageRoot = dirname(packageJsonPath);
+  const standalonePath = join(packageRoot, "agentproto-corpus-preset.json");
+  const standalone = await readJsonIfExists(standalonePath);
+  if (standalone !== void 0) {
+    return {
+      manifest: CorpusPresetManifestSchema.parse(standalone),
+      packageRoot
+    };
+  }
+  const pkgJson = await readJsonIfExists(packageJsonPath);
+  const block = pkgJson?.["agentproto-corpus-preset"];
+  if (block && typeof block === "object") {
+    return {
+      manifest: CorpusPresetManifestSchema.parse(block),
+      packageRoot
+    };
+  }
+  return null;
+}
+function resolvePackageJson(packageName) {
+  const candidates = [
+    import.meta.url,
+    pathToFileURL(join(process.cwd(), "package.json")).href
+  ];
+  for (const root of candidates) {
+    try {
+      return createRequire(root).resolve(`${packageName}/package.json`);
+    } catch {
+    }
+  }
+  return null;
+}
+async function readJsonIfExists(path4) {
+  try {
+    const raw = await readFile(path4, "utf8");
+    return JSON.parse(raw);
+  } catch (err) {
+    if (err.code === "ENOENT") return void 0;
+    throw err;
+  }
+}
+async function readConfiguredPresetPackages() {
+  const base = process.env["AGENTPROTO_HOME"] ?? join(homedir(), ".agentproto");
+  const path4 = join(base, "config.json");
+  try {
+    const raw = await readFile(path4, "utf8");
+    const parsed = JSON.parse(raw);
+    const list = parsed.corpusPresetPackages;
+    if (Array.isArray(list) && list.length > 0) return list;
+  } catch {
+  }
+  return DEFAULT_PRESET_PACKAGES;
+}
+var NodeFsAdapter = class {
+  root;
+  constructor(opts) {
+    this.root = opts.root;
+  }
+  async exists(p) {
+    try {
+      await stat(this.resolve(p));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async readFile(p) {
+    return await readFile(this.resolve(p), "utf8");
+  }
+  /**
+   * Atomic write: write to `${target}.tmp-{nonce}`, fsync, rename.
+   * Rename is atomic on the same filesystem. Creates parent dirs as
+   * needed (most callers expect mkdir -p semantics).
+   */
+  async writeFile(p, content) {
+    const target = this.resolve(p);
+    await mkdir(path.dirname(target), { recursive: true });
+    const tmp = `${target}.tmp-${randomBytes(8).toString("hex")}`;
+    await writeFile(tmp, content, "utf8");
+    await rename(tmp, target);
+  }
+  async appendFile(p, content) {
+    const target = this.resolve(p);
+    await mkdir(path.dirname(target), { recursive: true });
+    await appendFile(target, content, "utf8");
+  }
+  async readdir(p) {
+    const target = this.resolve(p);
+    const entries = await readdir(target);
+    return entries;
+  }
+  async walk(p) {
+    const out = [];
+    const start = this.resolve(p);
+    const rootForRelative = start;
+    const visit = async (dir) => {
+      let entries = [];
+      try {
+        entries = await readdir(dir);
+      } catch {
+        return;
+      }
+      for (const ent of entries) {
+        if (ent.startsWith(".")) continue;
+        const full = path.join(dir, ent);
+        const s = await stat(full);
+        if (s.isDirectory()) {
+          await visit(full);
+        } else if (s.isFile()) {
+          const rel = path.relative(rootForRelative, full).split(path.sep).join("/");
+          out.push(rel);
+        }
+      }
+    };
+    await visit(start);
+    return out;
+  }
+  async stat(p) {
+    try {
+      const s = await stat(this.resolve(p));
+      return {
+        kind: s.isDirectory() ? "directory" : "file",
+        bytes: s.isFile() ? s.size : void 0,
+        modifiedAt: s.mtime
+      };
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Advisory lock via a lockfile. Spins waiting for the lockfile to
+   * disappear, then creates it with exclusive flag. Released by
+   * deleting it. Single-process safe; multi-process semi-safe (the
+   * write is best-effort exclusive — adequate for the corpus's
+   * promote-entry transaction which is rare and short-lived).
+   */
+  async lock(p) {
+    const target = this.resolve(p);
+    const lockDir = path.join(path.dirname(target), ".corpus-locks");
+    await mkdir(lockDir, { recursive: true });
+    const lockFile = path.join(lockDir, path.basename(target) + ".lock");
+    const myToken = `${process.pid}-${randomBytes(4).toString("hex")}`;
+    while (true) {
+      if (!existsSync(lockFile)) {
+        try {
+          await writeFile(lockFile, myToken, { encoding: "utf8", flag: "wx" });
+          const written = await readFile(lockFile, "utf8").catch(() => "");
+          if (written === myToken) break;
+        } catch {
+        }
+      }
+      await new Promise((r) => setTimeout(r, 25));
+    }
+    return {
+      release: async () => {
+        try {
+          await rm(lockFile, { force: true });
+        } catch {
+        }
+      }
+    };
+  }
+  // ── Helpers ────────────────────────────────────────────────────
+  /**
+   * Resolve a workspace-relative path to an absolute host path.
+   * Refuses to climb out of the workspace root (defense against
+   * `../../etc/passwd`-style abuse) — the corpus kit's paths must
+   * stay inside the workspace.
+   */
+  resolve(p) {
+    const normalized = path.posix.normalize("/" + p.replace(/^\/+/, ""));
+    const rel = normalized.slice(1);
+    if (rel.startsWith("..")) {
+      throw new Error(
+        `NodeFsAdapter: path "${p}" escapes the workspace root "${this.root}"`
+      );
+    }
+    return path.join(this.root, rel);
+  }
+};
+
+// src/scaffold/bare.ts
+function titleCase(name) {
+  return name.replace(/[-_]+/g, " ").replace(/\s+/g, " ").trim().replace(/\b\w/g, (c) => c.toUpperCase());
+}
+var ENTRY_KINDS = [
+  "principles",
+  "patterns",
+  "critiques",
+  "examples",
+  "summaries",
+  "timelines"
+];
+function bareManifest(name) {
+  const title = titleCase(name);
+  return `---
+schema: knowledge.workspace/v1
+name: ${name}
+title: ${title}
+description: >-
+  ${title} knowledge corpus (AIP-10). Sources are scraped + content-hashed and
+  immutable; entries are distilled, curated, mutable claims that cite them.
+  This manifest is intentionally domain-agnostic \u2014 tune entityTypes, lints, and
+  metadata.corpus to fit the domain.
+version: 1.0.0
+entityTypes:
+  - { name: Principle, description: "Durable expert rule" }
+  - { name: Example, description: "Concrete source-derived example" }
+  - { name: Pattern, description: "Reusable transferable mechanic" }
+  - { name: Critique, description: "Negative example or failure mode" }
+  - { name: Summary, description: "Compressed source synthesis" }
+  - { name: Timeline, description: "Time-sensitive evolution" }
+sources:
+  retention: forever
+  signing: optional
+  hashAlgo: sha256
+  authorityDefault: secondary
+lints:
+  - { id: require-source-on-examples, kind: require-source, appliesTo: Example, severity: error }
+  - { id: broken-ref-all, kind: broken-ref, appliesTo: "*", severity: error }
+  - { id: orphan-all, kind: orphan, appliesTo: "*", severity: info }
+curation:
+  tone: "neutral, expert, source-backed"
+  depth: medium
+  autoLink: byName
+  conflictResolution: authority
+queryHints:
+  preferRecent: true
+  preferAuthoritative: true
+metadata:
+  corpus:
+    # "flat" \u2192 entries/<kind>/<slug>.md (matches the scaffolded dirs).
+    # Set "dated" for entries/<kind>/<year>/<slug>.md on high-volume corpora.
+    entryLayout: flat
+---
+
+# ${title}
+
+Neutral AIP-10 knowledge workspace.
+
+- \`sources/\` \u2014 scraped source snapshots (immutable provenance: \`captured_at\` + \`content_hash\`)
+- \`entries/<kind>/\` \u2014 distilled, curated claims that cite sources
+- \`collections/\` \u2014 AIP-18 curation collections (candidates, etc.)
+
+Populate with \`corpus import-web\` \u2192 \`corpus distill\` \u2192 \`corpus knowledge\`.
+`;
+}
+var STARTER_SURFACES = {
+  operators: { dir: "operators", aip: "AIP-9 (OPERATOR.md per operator)" },
+  playbooks: { dir: "playbooks", aip: "AIP-12 (PLAYBOOK.md per playbook)" },
+  workflows: { dir: "workflows", aip: "AIP-15 (WORKFLOW.md per workflow)" },
+  routines: { dir: "routines", aip: "AIP-41 (ROUTINE.md per routine)" }
+};
+function buildBareWorkspace(name, withStarters = []) {
+  const files = {
+    "KNOWLEDGE.md": bareManifest(name),
+    "sources/.gitkeep": "",
+    "collections/.gitkeep": ""
+  };
+  for (const kind of ENTRY_KINDS) files[`entries/${kind}/.gitkeep`] = "";
+  for (const s of withStarters) {
+    const surface = STARTER_SURFACES[s];
+    if (!surface) continue;
+    files[`${surface.dir}/.gitkeep`] = "";
+    files[`${surface.dir}/README.md`] = `# ${titleCase(s)}
+
+Opt-in starter surface. Add one file per item: ${surface.aip}.
+`;
+  }
+  return files;
+}
+var __filename$1 = fileURLToPath(import.meta.url);
+var __dirname$1 = path.dirname(__filename$1);
+function findSpecsRoot() {
+  const candidates = [
+    // source-tree (vendored): packages/corpus-cli/src/commands → ts repo's own specs/resources
+    path.resolve(__dirname$1, "../../../../specs/resources"),
+    // dist-tree (vendored): packages/corpus-cli/dist → ts repo's own specs/resources
+    path.resolve(__dirname$1, "../../../specs/resources"),
+    // source-tree (sibling agentproto repo): up to projects/agentproto/agentproto/specs/resources
+    path.resolve(__dirname$1, "../../../../../agentproto/specs/resources"),
+    // dist-tree (sibling agentproto repo): up to projects/agentproto/agentproto/specs/resources
+    path.resolve(__dirname$1, "../../../../agentproto/specs/resources"),
+    // global install: share/agentproto-specs/resources next to the bin
+    path.resolve(__dirname$1, "../share/agentproto-specs/resources")
+  ];
+  for (const c of candidates) {
+    try {
+      readFileSync(path.join(c, "aip-10", "draft", "KNOWLEDGE.schema.json"));
+      return c;
+    } catch {
+    }
+  }
+  throw new Error(
+    "corpus-cli: could not locate AgentProto spec schemas. Re-install or set CORPUS_SPECS_ROOT."
+  );
+}
+var SPECS_ROOT = process.env.CORPUS_SPECS_ROOT || findSpecsRoot();
+function loadSchema(aip, doctype) {
+  return JSON.parse(
+    readFileSync(
+      path.join(SPECS_ROOT, `aip-${aip}`, "draft", `${doctype}.schema.json`),
+      "utf8"
+    )
+  );
+}
+function loadAipSchemaBundle() {
+  return {
+    schemas: {
+      knowledge: loadSchema(10, "KNOWLEDGE"),
+      collection: loadSchema(18, "COLLECTION"),
+      playbook: loadSchema(12, "PLAYBOOK"),
+      operator: loadSchema(9, "OPERATOR"),
+      workflow: loadSchema(15, "WORKFLOW"),
+      routine: loadSchema(41, "ROUTINE")
+    },
+    externals: [loadSchema(16, "IO"), loadSchema(17, "RUNNER")]
+  };
+}
+function resolveWorkspacePath(arg) {
+  if (!arg) return process.cwd();
+  return path.resolve(process.cwd(), arg);
+}
+function fail(msg4, code = 1) {
+  process.stderr.write(`corpus: ${msg4}
+`);
+  return code;
+}
+
+// src/commands/init.ts
+async function runInit(args) {
+  const positionals = [];
+  let listOnly = false;
+  let presetSlug;
+  const withStarters = [];
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === void 0) continue;
+    if (a === "--list" || a === "-l") {
+      listOnly = true;
+    } else if (a === "--preset" || a === "-p") {
+      presetSlug = args[++i];
+    } else if (a.startsWith("--preset=")) {
+      presetSlug = a.slice("--preset=".length);
+    } else if (a === "--with" || a === "-w") {
+      withStarters.push(...splitList(args[++i]));
+    } else if (a.startsWith("--with=")) {
+      withStarters.push(...splitList(a.slice("--with=".length)));
+    } else {
+      positionals.push(a);
+    }
+  }
+  if (listOnly) {
+    return runList();
+  }
+  const [name, pathArg] = positionals;
+  if (!name) {
+    return fail(
+      `init requires a <name> argument.
+  corpus init <name> [path]                  # bare AIP-10 scaffold (default)
+  corpus init <name> [path] --with operators,playbooks
+  corpus init <name> [path] --preset <slug>  # seed a full preset
+Run \`corpus init --list\` for available presets.`,
+      2
+    );
+  }
+  const unknown = withStarters.filter((s) => !(s in STARTER_SURFACES));
+  if (unknown.length) {
+    return fail(
+      `init: unknown --with surface(s): ${unknown.join(", ")}. Known: ${Object.keys(STARTER_SURFACES).join(", ")}.`,
+      2
+    );
+  }
+  const target = resolveWorkspacePath(pathArg);
+  const fs = new NodeFsAdapter({ root: target });
+  if (await fs.exists("KNOWLEDGE.md")) {
+    return fail(
+      `init: refusing to overwrite an existing workspace at ${target}. Delete KNOWLEDGE.md first if you really want to re-init.`,
+      1
+    );
+  }
+  if (presetSlug) {
+    const preset = await loadPreset(presetSlug);
+    if (!preset) {
+      const available = await formatAvailable();
+      return fail(
+        `init: preset "${presetSlug}" not found in any configured package.
+${available}`,
+        2
+      );
+    }
+    let count2 = 0;
+    for (const [rel, content] of Object.entries(preset.files)) {
+      await fs.writeFile(rel, content);
+      count2++;
+    }
+    if (preset.bootstrap) {
+      await preset.bootstrap({
+        workspacePath: "",
+        write: (rel, content) => fs.writeFile(rel, content)
+      });
+    }
+    process.stdout.write(
+      `corpus: initialized "${preset.slug}" preset (${preset.title}) at ${target}
+        ${count2} files written
+Try: corpus validate ${pathArg ?? "."}
+     corpus lint ${pathArg ?? "."}
+`
+    );
+    return 0;
+  }
+  const files = buildBareWorkspace(name, withStarters);
+  let count = 0;
+  for (const [rel, content] of Object.entries(files)) {
+    await fs.writeFile(rel, content);
+    count++;
+  }
+  const withNote = withStarters.length ? ` (+ starters: ${withStarters.join(", ")})` : "";
+  process.stdout.write(
+    `corpus: initialized bare corpus "${name}"${withNote} at ${target}
+        ${count} files written \u2014 neutral KNOWLEDGE.md + AIP-10 structure
+Try: corpus import-web ${pathArg ?? "."} --urls-file urls.txt
+     corpus validate ${pathArg ?? "."}
+`
+  );
+  return 0;
+}
+function splitList(v) {
+  return (v ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+}
+async function runList() {
+  const presets = await discoverPresets();
+  if (presets.size === 0) {
+    process.stdout.write(
+      "corpus init: no presets discovered. Configure corpusPresetPackages[] in ~/.agentproto/config.json or install @agentproto/corpus-presets.\n"
+    );
+    return 0;
+  }
+  for (const entry of presets.values()) {
+    process.stdout.write(`\u2022 ${entry.slug}  (${entry.packageName})
+`);
+    if (entry.description) {
+      process.stdout.write(`    ${entry.description}
+`);
+    }
+  }
+  return 0;
+}
+async function formatAvailable() {
+  const presets = await discoverPresets();
+  if (presets.size === 0) {
+    return "No presets discovered. Configure corpusPresetPackages[] in ~/.agentproto/config.json or install @agentproto/corpus-presets.";
+  }
+  const slugs = [...presets.keys()].sort();
+  return `Available slugs: ${slugs.join(", ")} (run \`corpus init --list\` for details).`;
+}
+async function runValidate(args) {
+  const target = resolveWorkspacePath(args[0]);
+  const fs = new NodeFsAdapter({ root: target });
+  if (!await fs.exists("KNOWLEDGE.md")) {
+    return fail(
+      `validate: no KNOWLEDGE.md at ${target}. Run \`corpus init marketing\` to scaffold one.`,
+      1
+    );
+  }
+  const snapshot = await new CorpusWorkspaceReader({ fs }).read("");
+  const validator = new CorpusValidator({ bundle: loadAipSchemaBundle() });
+  const result = validator.validateWorkspace(snapshot);
+  const counts = countBucket(snapshot);
+  process.stdout.write(
+    `corpus: scanned ${counts.total} files (${counts.summary})
+`
+  );
+  if (result.issues.length === 0) {
+    process.stdout.write("corpus: all files conform to AIP schemas \u2713\n");
+    return 0;
+  }
+  const errors = result.issues.filter((i) => i.severity === "error");
+  const warns = result.issues.filter((i) => i.severity === "warn");
+  const infos = result.issues.filter((i) => i.severity === "info");
+  for (const i of result.issues) {
+    const tag = i.severity === "error" ? "ERROR" : i.severity === "warn" ? "WARN " : "INFO ";
+    process.stdout.write(`  ${tag}  ${i.path}${i.instancePath}: ${i.message}
+`);
+  }
+  process.stdout.write(
+    `corpus: ${errors.length} error${errors.length === 1 ? "" : "s"}, ${warns.length} warning${warns.length === 1 ? "" : "s"}, ${infos.length} info
+`
+  );
+  return result.valid ? 0 : 1;
+}
+function countBucket(s) {
+  const parts = [];
+  if (s.workspace) parts.push("1 workspace");
+  if (s.sources.length) parts.push(`${s.sources.length} sources`);
+  if (s.entries.length) parts.push(`${s.entries.length} entries`);
+  if (s.collections.length) parts.push(`${s.collections.length} collections`);
+  if (s.collectionItems.length)
+    parts.push(`${s.collectionItems.length} items`);
+  if (s.playbooks.length) parts.push(`${s.playbooks.length} playbooks`);
+  if (s.operators.length) parts.push(`${s.operators.length} operators`);
+  if (s.workflows.length) parts.push(`${s.workflows.length} workflows`);
+  if (s.routines.length) parts.push(`${s.routines.length} routines`);
+  if (s.unknown.length) parts.push(`${s.unknown.length} unknown`);
+  const total = (s.workspace ? 1 : 0) + s.sources.length + s.entries.length + s.collections.length + s.collectionItems.length + s.playbooks.length + s.operators.length + s.workflows.length + s.routines.length + s.unknown.length;
+  return { total, summary: parts.join(", ") };
+}
+async function runLint(args) {
+  const target = resolveWorkspacePath(args[0]);
+  const fs = new NodeFsAdapter({ root: target });
+  if (!await fs.exists("KNOWLEDGE.md")) {
+    return fail(
+      `lint: no KNOWLEDGE.md at ${target}. Run \`corpus init marketing\` to scaffold one.`,
+      1
+    );
+  }
+  const snapshot = await new CorpusWorkspaceReader({ fs }).read("");
+  const report = new CorpusLinter({ clock: systemClock }).lint(snapshot);
+  if (report.issues.length === 0) {
+    process.stdout.write("corpus: lint clean \u2713\n");
+    return 0;
+  }
+  for (const i of report.issues) {
+    const tag = i.severity === "error" ? "ERROR" : i.severity === "warn" ? "WARN " : "INFO ";
+    process.stdout.write(`  ${tag}  [${i.lintId}]  ${i.path}: ${i.message}
+`);
+  }
+  process.stdout.write(
+    `corpus: ${report.errorCount} error${report.errorCount === 1 ? "" : "s"}, ${report.warnCount} warning${report.warnCount === 1 ? "" : "s"}, ${report.infoCount} info
+`
+  );
+  return report.errorCount > 0 ? 1 : 0;
+}
+var OsIdentityAdapter = class {
+  cached;
+  constructor(opts) {
+    const user = opts.userOverride ?? process.env.USER ?? process.env.USERNAME ?? safeGetUser() ?? "anonymous";
+    const wsName = path.basename(opts.workspaceRoot) || "default";
+    this.cached = Object.freeze({
+      principal: `ws://users/${slugify(user)}`,
+      identityTree: Object.freeze([
+        `ws://users/${slugify(user)}`,
+        `ws://workspaces/${slugify(wsName)}`
+      ]),
+      displayName: user
+    });
+  }
+  async resolve() {
+    return this.cached;
+  }
+};
+function safeGetUser() {
+  try {
+    return os.userInfo().username;
+  } catch {
+    return void 0;
+  }
+}
+function slugify(s) {
+  return s.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-").slice(0, 64) || "anonymous";
+}
+
+// src/commands/events.ts
+var KNOWN_EVENT_KINDS = /* @__PURE__ */ new Set([
+  "corpus.candidate.discovered",
+  "corpus.candidate.analyzed",
+  "corpus.candidate.approved",
+  "corpus.candidate.rejected",
+  "corpus.entry.promoted",
+  "corpus.entry.deprecated",
+  "corpus.entry.archived",
+  "corpus.gap.opened",
+  "corpus.gap.resolved",
+  "playbook.shadow.registered",
+  "playbook.activated",
+  "playbook.archived"
+]);
+async function runEventsEmit(args) {
+  const positionals = [];
+  let payloadStr;
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--payload") {
+      payloadStr = args[++i];
+    } else if (a.startsWith("--payload=")) {
+      payloadStr = a.slice("--payload=".length);
+    } else if (a.startsWith("--")) {
+      return fail(`events:emit: unknown flag ${a}`, 2);
+    } else {
+      positionals.push(a);
+    }
+  }
+  const [kind, pathArg] = positionals;
+  if (!kind) {
+    return fail(
+      'events:emit requires a <kind> argument. Try `corpus events:emit corpus.entry.promoted --payload \'{"slug":"foo"}\'`.',
+      2
+    );
+  }
+  if (!KNOWN_EVENT_KINDS.has(kind)) {
+    process.stderr.write(
+      `corpus: warning \u2014 "${kind}" is not in the standard event taxonomy. Emitting anyway.
+`
+    );
+  }
+  if (!payloadStr) {
+    return fail(
+      "events:emit requires --payload <json>. Pass at least `--payload '{}'`.",
+      2
+    );
+  }
+  let payload;
+  try {
+    payload = JSON.parse(payloadStr);
+  } catch (e) {
+    return fail(
+      `events:emit: --payload must be valid JSON (${e instanceof Error ? e.message : String(e)})`,
+      2
+    );
+  }
+  if (typeof payload !== "object" || payload === null || Array.isArray(payload)) {
+    return fail("events:emit: --payload must be a JSON object", 2);
+  }
+  const target = resolveWorkspacePath(pathArg);
+  const fs = new NodeFsAdapter({ root: target });
+  if (!await fs.exists("KNOWLEDGE.md")) {
+    return fail(
+      `events:emit: no KNOWLEDGE.md at ${target}. Run \`corpus init marketing\` first.`,
+      1
+    );
+  }
+  const emitter = new CorpusEventEmitter({
+    fs,
+    clock: systemClock,
+    identity: new OsIdentityAdapter({ workspaceRoot: target }),
+    workspaceRoot: ""
+  });
+  const event = await emitter.emit(kind, payload);
+  process.stdout.write(
+    `corpus: emitted ${event.kind} at ${event.at} by ${event.actor}
+`
+  );
+  return 0;
+}
+async function runEventsTail(args) {
+  const target = resolveWorkspacePath(args[0]);
+  const fs = new NodeFsAdapter({ root: target });
+  if (!await fs.exists("_log.md")) {
+    process.stdout.write(
+      `corpus: _log.md does not exist yet at ${target}. Emit an event to create it.
+`
+    );
+    return 0;
+  }
+  const content = await fs.readFile("_log.md");
+  process.stdout.write(content);
+  if (!content.endsWith("\n")) process.stdout.write("\n");
+  return 0;
+}
+
+// src/ports/video-hosts.ts
+var VIDEO_HOSTS = /* @__PURE__ */ new Set([
+  "youtube.com",
+  "www.youtube.com",
+  "m.youtube.com",
+  "music.youtube.com",
+  "youtu.be",
+  "vimeo.com"
+]);
+function isVideoUrl(url, extraHosts) {
+  let host;
+  try {
+    host = new URL(url).hostname;
+  } catch {
+    return false;
+  }
+  const bare = host.replace(/^www\./, "");
+  return VIDEO_HOSTS.has(host) || VIDEO_HOSTS.has(bare) || (extraHosts?.has(host) ?? false) || (extraHosts?.has(bare) ?? false);
+}
+
+// src/ports/browser-fetcher.adapter.ts
+var FETCHED_PAYLOAD = z.object({
+  title: z.string(),
+  text: z.string(),
+  kind: z.enum(["video", "article", "page", "unknown"]).catch("unknown"),
+  language: z.string().optional().catch(void 0),
+  via: z.string().optional().catch(void 0)
+}).loose();
+var MCP_TEXT_BLOCK = z.object({ type: z.literal("text"), text: z.string() }).loose();
+var READABILITY_FN = `() => {
+  const title = document.title || "";
+  const article = document.querySelector("article") || document.querySelector("main");
+  const root = article || document.body;
+  const text = (root?.innerText || "").replace(/\\n{3,}/g, "\\n\\n").trim().slice(0, 200000);
+  const lang = document.documentElement.getAttribute("lang") || undefined;
+  return { title, text, kind: "article", language: lang, via: "readability" };
+}`;
+var BrowserMcpFetcher = class {
+  browser;
+  navigateTool;
+  evaluateTool;
+  constructor(opts) {
+    this.browser = opts.browser;
+    this.navigateTool = opts.navigateToolName ?? "navigate_page";
+    this.evaluateTool = opts.evaluateToolName ?? "evaluate_script";
+  }
+  async fetch(url) {
+    if (isVideoUrl(url)) return null;
+    await this.browser.callTool({
+      name: this.navigateTool,
+      arguments: { url }
+    });
+    const result = await this.browser.callTool({
+      name: this.evaluateTool,
+      arguments: { function: READABILITY_FN }
+    });
+    const extracted = parseEvaluateResult(result);
+    if (!extracted || !extracted.text.trim()) return null;
+    return extracted;
+  }
+};
+function parseEvaluateResult(result) {
+  return coerceFetched(result.structuredContent) ?? coerceFetched(extractText(result.content));
+}
+function coerceFetched(value) {
+  let obj = value;
+  if (typeof obj === "string") {
+    try {
+      obj = JSON.parse(obj);
+    } catch {
+      return null;
+    }
+  }
+  const parsed = FETCHED_PAYLOAD.safeParse(obj);
+  if (!parsed.success) return null;
+  const { title, text, kind, language, via } = parsed.data;
+  return {
+    title,
+    text,
+    kind,
+    ...language ? { language } : {},
+    ...via ? { via } : {}
+  };
+}
+function extractText(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    for (const block of content) {
+      const parsed = MCP_TEXT_BLOCK.safeParse(block);
+      if (parsed.success) return parsed.data.text;
+    }
+  }
+  return null;
+}
+var SCRAPE_PAYLOAD = z.object({
+  title: z.string().optional().catch(void 0),
+  markdown: z.string().optional().catch(void 0),
+  html: z.string().optional().catch(void 0),
+  language: z.string().optional().catch(void 0),
+  tierUsed: z.union([z.string(), z.number()]).optional().catch(void 0)
+}).loose();
+var MCP_TEXT_BLOCK2 = z.object({ type: z.literal("text"), text: z.string() }).loose();
+var ScrapeMcpFetcher = class {
+  client;
+  toolName;
+  constructor(opts) {
+    this.client = opts.client;
+    this.toolName = opts.scrapeToolName ?? "scrape";
+  }
+  async fetch(url) {
+    if (isVideoUrl(url)) return null;
+    let res;
+    try {
+      res = await this.client.callTool({
+        name: this.toolName,
+        arguments: { url }
+      });
+    } catch {
+      return null;
+    }
+    if (res.isError) return null;
+    const payload = extractPayload(res);
+    if (!payload) return null;
+    const text = (payload.markdown?.trim() || stripTags(payload.html)).trim();
+    if (!text) return null;
+    return {
+      title: payload.title?.trim() || url,
+      text,
+      kind: "article",
+      ...payload.language ? { language: payload.language } : {},
+      via: payload.tierUsed ? `scrape:${payload.tierUsed}` : "scrape"
+    };
+  }
+};
+function extractPayload(res) {
+  if (res.structuredContent && typeof res.structuredContent === "object") {
+    const parsed = SCRAPE_PAYLOAD.safeParse(res.structuredContent);
+    if (parsed.success) return parsed.data;
+  }
+  if (Array.isArray(res.content)) {
+    for (const block of res.content) {
+      const text = MCP_TEXT_BLOCK2.safeParse(block);
+      if (!text.success) continue;
+      try {
+        const parsed = SCRAPE_PAYLOAD.safeParse(JSON.parse(text.data.text));
+        if (parsed.success) return parsed.data;
+      } catch {
+        return { markdown: text.data.text };
+      }
+    }
+  }
+  return null;
+}
+function stripTags(html) {
+  if (!html) return "";
+  return html.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+}
+var execFileAsync = promisify(execFile);
+var YTDLP_INFO = z.object({ title: z.string().optional(), language: z.string().optional() }).loose();
+var YtDlpWhisperFetcher = class {
+  stt;
+  download;
+  extraHosts;
+  constructor(opts) {
+    this.stt = opts.stt;
+    this.download = opts.download ?? defaultYtDlpDownloader(opts.ytDlpBin ?? "yt-dlp", {
+      maxDurationSec: opts.maxDurationSec,
+      cookiesFromBrowser: opts.cookiesFromBrowser,
+      cookiesFile: opts.cookiesFile
+    });
+    this.extraHosts = opts.extraVideoHosts ? new Set(opts.extraVideoHosts) : void 0;
+  }
+  async fetch(url) {
+    if (!isVideoUrl(url, this.extraHosts)) return null;
+    let dl;
+    try {
+      dl = await this.download(url);
+    } catch (e) {
+      process.stderr.write(`corpus: download failed for ${url} \u2014 skipped (${msg(e)})
+`);
+      return null;
+    }
+    try {
+      const t = await this.stt.transcribe(dl.audioPath);
+      if (!t.text.trim()) return null;
+      return {
+        title: dl.title || url,
+        text: t.text,
+        kind: "video",
+        ...t.language ?? dl.language ? { language: t.language ?? dl.language } : {},
+        via: "transcription"
+      };
+    } catch (e) {
+      if (isAuthError(e)) throw e;
+      process.stderr.write(
+        `corpus: transcription failed for ${url} \u2014 skipped (${msg(e)})
+`
+      );
+      return null;
+    } finally {
+      await dl.cleanup().catch(() => {
+      });
+    }
+  }
+};
+function msg(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+function isAuthError(e) {
+  const m = msg(e).toLowerCase();
+  return m.includes(" 401") || m.includes(" 403") || m.includes("unauthorized") || m.includes("forbidden") || m.includes("api key") || m.includes("api_key");
+}
+function defaultYtDlpDownloader(bin, opts) {
+  return async (url) => {
+    const dir = await mkdtemp(join(tmpdir(), "corpus-ytdlp-"));
+    const cleanup = () => rm(dir, { recursive: true, force: true });
+    try {
+      const durationGuard = opts?.maxDurationSec && opts.maxDurationSec > 0 ? ["--match-filter", `duration <= ${Math.floor(opts.maxDurationSec)}`] : [];
+      const cookieArgs = opts?.cookiesFromBrowser ? ["--cookies-from-browser", opts.cookiesFromBrowser] : opts?.cookiesFile ? ["--cookies", opts.cookiesFile] : [];
+      await execFileAsync(
+        bin,
+        [
+          "-f",
+          "bestaudio",
+          "-x",
+          "--audio-format",
+          "mp3",
+          "--audio-quality",
+          "64K",
+          "--no-playlist",
+          "--no-progress",
+          ...durationGuard,
+          ...cookieArgs,
+          "--write-info-json",
+          "-o",
+          join(dir, "track.%(ext)s"),
+          url
+        ],
+        { maxBuffer: 16 * 1024 * 1024 }
+      );
+      const files = await readdir(dir);
+      const audio = files.find((f) => f === "track.mp3") ?? files.find((f) => /\.(mp3|m4a|opus|webm|ogg|wav)$/i.test(f));
+      if (!audio) throw new Error("yt-dlp produced no audio file");
+      let title = url;
+      let language;
+      const infoName = files.find((f) => f.endsWith(".info.json"));
+      if (infoName) {
+        try {
+          const info = YTDLP_INFO.parse(
+            JSON.parse(await readFile(join(dir, infoName), "utf-8"))
+          );
+          if (info.title) title = info.title;
+          if (info.language) language = info.language;
+        } catch {
+        }
+      }
+      return {
+        audioPath: join(dir, audio),
+        title,
+        ...language ? { language } : {},
+        cleanup
+      };
+    } catch (e) {
+      await cleanup().catch(() => {
+      });
+      throw e;
+    }
+  };
+}
+var WHISPER_RESPONSE = z.object({ text: z.string().optional(), language: z.string().optional() }).loose();
+var WHISPER_MAX_BYTES = 25 * 1024 * 1024;
+var OpenAiWhisperStt = class {
+  apiKey;
+  model;
+  baseUrl;
+  constructor(opts) {
+    this.apiKey = opts.apiKey;
+    this.model = opts.model ?? "whisper-1";
+    this.baseUrl = (opts.baseUrl ?? "https://api.openai.com/v1").replace(/\/+$/, "");
+  }
+  async transcribe(audioPath) {
+    const bytes = await readFile(audioPath);
+    if (bytes.byteLength > WHISPER_MAX_BYTES) {
+      throw new Error(
+        `audio ${basename(audioPath)} is ${(bytes.byteLength / 1024 / 1024).toFixed(1)} MB \u2014 over Whisper's 25 MB cap. Lower the bitrate or chunk the media.`
+      );
+    }
+    const form = new FormData();
+    form.append("file", new Blob([bytes]), basename(audioPath));
+    form.append("model", this.model);
+    form.append("response_format", "verbose_json");
+    const res = await this.postWithRetry(form);
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(`Whisper STT ${res.status} ${res.statusText}: ${body.slice(0, 200)}`);
+    }
+    const data = WHISPER_RESPONSE.parse(await res.json());
+    const language = normalizeLanguageTag(data.language);
+    return {
+      text: (data.text ?? "").trim(),
+      ...language ? { language } : {}
+    };
+  }
+  /**
+   * POST the audio with bounded retry. Transcribing a long talk fans out
+   * into many segment uploads (see ChunkedStt), so a single transient
+   * network blip ("fetch failed") or a 429 / 5xx must not abort the whole
+   * batch. Network errors and retryable statuses back off and retry;
+   * client errors (401 auth, 400 bad request) return immediately so a real
+   * misconfiguration still surfaces loudly.
+   */
+  async postWithRetry(form, attempts = 4) {
+    const url = `${this.baseUrl}/audio/transcriptions`;
+    let lastErr;
+    for (let i = 0; i < attempts; i++) {
+      try {
+        const res = await fetch(url, {
+          method: "POST",
+          headers: { authorization: `Bearer ${this.apiKey}` },
+          body: form
+        });
+        if (res.status !== 429 && res.status < 500) return res;
+        lastErr = new Error(`Whisper STT ${res.status} ${res.statusText}`);
+      } catch (e) {
+        lastErr = e;
+      }
+      if (i < attempts - 1) await delay(500 * 2 ** i);
+    }
+    throw lastErr instanceof Error ? lastErr : new Error(String(lastErr));
+  }
+};
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var UPLOAD_RESPONSE = z.object({ upload_url: z.string() });
+var AAI_TRANSCRIPT = z.object({
+  id: z.string(),
+  status: z.enum(["queued", "processing", "completed", "error"]),
+  text: z.string().optional(),
+  language_code: z.string().optional(),
+  error: z.string().optional(),
+  utterances: z.array(z.object({ speaker: z.string(), text: z.string() })).nullish()
+}).loose();
+var AssemblyAiStt = class {
+  apiKey;
+  baseUrl;
+  pollIntervalMs;
+  maxWaitMs;
+  sleep;
+  constructor(opts) {
+    this.apiKey = opts.apiKey;
+    this.baseUrl = (opts.baseUrl ?? "https://api.assemblyai.com/v2").replace(/\/+$/, "");
+    this.pollIntervalMs = opts.pollIntervalMs ?? 3e3;
+    this.maxWaitMs = opts.maxWaitMs ?? 15 * 60 * 1e3;
+    this.sleep = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  }
+  async transcribe(audioPath) {
+    const bytes = await readFile(audioPath);
+    const up = await fetch(`${this.baseUrl}/upload`, {
+      method: "POST",
+      headers: { authorization: this.apiKey, "content-type": "application/octet-stream" },
+      body: bytes
+    });
+    if (!up.ok) throw new Error(`AssemblyAI upload ${up.status}: ${(await up.text()).slice(0, 200)}`);
+    const { upload_url } = UPLOAD_RESPONSE.parse(await up.json());
+    const created = await this.post("/transcript", {
+      audio_url: upload_url,
+      speaker_labels: true,
+      language_detection: true
+    });
+    const id = created.id;
+    const deadline = this.maxWaitMs;
+    let waited = 0;
+    let job = created;
+    while (job.status !== "completed" && job.status !== "error") {
+      if (waited >= deadline) throw new Error(`AssemblyAI transcript ${id} timed out after ${deadline} ms`);
+      await this.sleep(this.pollIntervalMs);
+      waited += this.pollIntervalMs;
+      job = await this.get(`/transcript/${id}`);
+    }
+    if (job.status === "error") throw new Error(`AssemblyAI transcript failed: ${job.error ?? "unknown"}`);
+    return {
+      text: formatDiarized(job),
+      ...job.language_code ? { language: job.language_code } : {}
+    };
+  }
+  async post(path4, body) {
+    const r = await fetch(`${this.baseUrl}${path4}`, {
+      method: "POST",
+      headers: { authorization: this.apiKey, "content-type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (!r.ok) throw new Error(`AssemblyAI POST ${path4} ${r.status}: ${(await r.text()).slice(0, 200)}`);
+    return AAI_TRANSCRIPT.parse(await r.json());
+  }
+  async get(path4) {
+    const r = await fetch(`${this.baseUrl}${path4}`, { headers: { authorization: this.apiKey } });
+    if (!r.ok) throw new Error(`AssemblyAI GET ${path4} ${r.status}: ${(await r.text()).slice(0, 200)}`);
+    return AAI_TRANSCRIPT.parse(await r.json());
+  }
+};
+function formatDiarized(job) {
+  if (job.utterances && job.utterances.length > 0) {
+    return job.utterances.map((u) => `Speaker ${u.speaker}: ${u.text.trim()}`).join("\n\n").trim();
+  }
+  return (job.text ?? "").trim();
+}
+var execFileAsync2 = promisify(execFile);
+var DEFAULT_MAX_BYTES = 24 * 1024 * 1024;
+var DEFAULT_SEGMENT_SECONDS = 1200;
+var ChunkedStt = class {
+  base;
+  maxBytes;
+  segmentSeconds;
+  split;
+  constructor(opts) {
+    this.base = opts.base;
+    this.maxBytes = opts.maxBytes ?? DEFAULT_MAX_BYTES;
+    this.segmentSeconds = opts.segmentSeconds ?? DEFAULT_SEGMENT_SECONDS;
+    this.split = opts.split ?? defaultFfmpegSplitter(opts.ffmpegBin ?? "ffmpeg");
+  }
+  async transcribe(audioPath) {
+    const { size } = await stat(audioPath);
+    if (size <= this.maxBytes) return this.base.transcribe(audioPath);
+    const dir = await mkdtemp(join(tmpdir(), "corpus-stt-chunk-"));
+    try {
+      const parts = await this.split(audioPath, this.segmentSeconds, dir);
+      if (parts.length === 0) {
+        return this.base.transcribe(audioPath);
+      }
+      const texts = [];
+      let language;
+      let failed = 0;
+      let firstErr;
+      for (const part of parts) {
+        try {
+          const t = await this.base.transcribe(part);
+          if (t.text.trim()) texts.push(t.text.trim());
+          language ??= t.language;
+        } catch (e) {
+          failed++;
+          firstErr ??= e;
+        }
+      }
+      if (texts.length === 0) {
+        throw firstErr ?? new Error("all audio segments failed transcription");
+      }
+      if (failed > 0) {
+        process.stderr.write(
+          `corpus: ${failed}/${parts.length} audio segments failed \u2014 partial transcript
+`
+        );
+      }
+      return {
+        text: texts.join("\n\n"),
+        ...language ? { language } : {}
+      };
+    } finally {
+      await rm(dir, { recursive: true, force: true }).catch(() => {
+      });
+    }
+  }
+};
+function defaultFfmpegSplitter(bin) {
+  return async (audioPath, segmentSeconds, outDir) => {
+    const ext = extname(audioPath) || ".mp3";
+    await execFileAsync2(
+      bin,
+      [
+        "-hide_banner",
+        "-loglevel",
+        "error",
+        "-i",
+        audioPath,
+        "-f",
+        "segment",
+        "-segment_time",
+        String(segmentSeconds),
+        "-c",
+        "copy",
+        join(outDir, `part%03d${ext}`)
+      ],
+      { maxBuffer: 16 * 1024 * 1024 }
+    );
+    const files = (await readdir(outDir)).filter((f) => f.startsWith("part") && f.endsWith(ext)).sort();
+    return files.map((f) => join(outDir, f));
+  };
+}
+
+// src/ports/http-readability-fetcher.adapter.ts
+var DEFAULT_UA = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0 Safari/537.36";
+var HttpReadabilityFetcher = class {
+  ua;
+  maxChars;
+  constructor(opts = {}) {
+    this.ua = opts.userAgent ?? DEFAULT_UA;
+    this.maxChars = opts.maxChars ?? 2e5;
+  }
+  async fetch(url) {
+    if (isVideoUrl(url)) return null;
+    let res;
+    try {
+      res = await fetch(url, {
+        headers: { "user-agent": this.ua, "accept-language": "en,fr;q=0.8" },
+        redirect: "follow"
+      });
+    } catch {
+      return null;
+    }
+    if (!res.ok) return null;
+    const ct = res.headers.get("content-type") ?? "";
+    if (!ct.includes("text/html") && !ct.includes("application/xhtml")) return null;
+    const html = await res.text();
+    const title = decodeEntities(
+      (html.match(/<title[^>]*>([\s\S]*?)<\/title>/i)?.[1] ?? "").trim()
+    );
+    const lang = html.match(/<html[^>]*\blang=["']?([a-zA-Z-]+)/i)?.[1];
+    const text = extractReadable(html).slice(0, this.maxChars);
+    if (!text.trim()) return null;
+    return {
+      title: title || url,
+      text,
+      kind: "article",
+      ...lang ? { language: lang } : {},
+      via: "readability"
+    };
+  }
+};
+function extractReadable(html) {
+  const region = html.match(/<article[\s\S]*?<\/article>/i)?.[0] ?? html.match(/<main[\s\S]*?<\/main>/i)?.[0] ?? html.match(/<body[\s\S]*?<\/body>/i)?.[0] ?? html;
+  return decodeEntities(
+    region.replace(/<script[\s\S]*?<\/script>/gi, " ").replace(/<style[\s\S]*?<\/style>/gi, " ").replace(/<(nav|header|footer|aside|form)[\s\S]*?<\/\1>/gi, " ").replace(/<[^>]+>/g, " ").replace(/[ \t]+/g, " ").replace(/\n{3,}/g, "\n\n")
+  ).trim();
+}
+function decodeEntities(s) {
+  return s.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&nbsp;/g, " ").replace(/&#(\d+);/g, (_, n) => String.fromCharCode(Number(n)));
+}
+
+// src/ports/composite-fetcher.ts
+var CompositeFetcher = class {
+  children;
+  constructor(children) {
+    this.children = children;
+  }
+  async fetch(url) {
+    for (const child of this.children) {
+      const result = await child.fetch(url);
+      if (result) return result;
+    }
+    return null;
+  }
+};
+
+// src/ports/throttle-fetcher.adapter.ts
+var ThrottleFetcher = class {
+  inner;
+  minIntervalMs;
+  now;
+  sleep;
+  lastStart = 0;
+  started = false;
+  constructor(inner, opts) {
+    this.inner = inner;
+    this.minIntervalMs = Math.max(0, opts.minIntervalMs);
+    this.now = opts.now ?? (() => Date.now());
+    this.sleep = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  }
+  async fetch(url) {
+    if (this.minIntervalMs > 0 && this.started) {
+      const wait = this.minIntervalMs - (this.now() - this.lastStart);
+      if (wait > 0) await this.sleep(wait);
+    }
+    this.started = true;
+    this.lastStart = this.now();
+    return this.inner.fetch(url);
+  }
+};
+var RPC_RESPONSE = z.object({ result: z.unknown().optional(), error: z.unknown().optional() }).loose();
+var CALL_RESULT = z.object({
+  content: z.unknown().optional(),
+  structuredContent: z.unknown().optional(),
+  isError: z.boolean().optional()
+}).loose();
+var PROTOCOL_VERSION = "2025-06-18";
+async function connectBrowserMcp(opts) {
+  const client = new StreamableHttpMcpClient(opts);
+  await client.initialize();
+  return client;
+}
+var StreamableHttpMcpClient = class {
+  id = 0;
+  sessionId;
+  endpoint;
+  headers;
+  protocolVersion;
+  constructor(opts) {
+    this.endpoint = opts.endpoint;
+    this.headers = opts.headers ?? {};
+    this.protocolVersion = opts.protocolVersion ?? PROTOCOL_VERSION;
+  }
+  async initialize() {
+    const res = await this.post({
+      jsonrpc: "2.0",
+      id: ++this.id,
+      method: "initialize",
+      params: {
+        protocolVersion: this.protocolVersion,
+        capabilities: {},
+        clientInfo: { name: "corpus-cli", version: "0.1.0" }
+      }
+    });
+    await this.post(
+      { jsonrpc: "2.0", method: "notifications/initialized", params: {} },
+      { expectResponse: false }
+    );
+    if (res?.error) {
+      throw new Error(`initialize failed: ${JSON.stringify(res.error)}`);
+    }
+  }
+  async callTool(args) {
+    const res = await this.post({
+      jsonrpc: "2.0",
+      id: ++this.id,
+      method: "tools/call",
+      params: { name: args.name, arguments: args.arguments }
+    });
+    if (res?.error) {
+      throw new Error(`tools/call ${args.name} failed: ${JSON.stringify(res.error)}`);
+    }
+    const parsed = CALL_RESULT.safeParse(res?.result ?? {});
+    return parsed.success ? parsed.data : {};
+  }
+  async post(body, opts = {}) {
+    const res = await fetch(this.endpoint, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        accept: "application/json, text/event-stream",
+        ...this.sessionId ? { "mcp-session-id": this.sessionId } : {},
+        ...this.headers
+      },
+      body: JSON.stringify(body)
+    });
+    const sid = res.headers.get("mcp-session-id");
+    if (sid) this.sessionId = sid;
+    if (opts.expectResponse === false) return null;
+    if (!res.ok) {
+      throw new Error(`MCP HTTP ${res.status} ${res.statusText}`);
+    }
+    return parseRpcResponse(await res.text(), res.headers.get("content-type"));
+  }
+};
+function parseRpcResponse(text, contentType) {
+  if (!text.trim()) return null;
+  const isSse = (contentType ?? "").includes("text/event-stream");
+  if (!isSse) {
+    const parsed = RPC_RESPONSE.safeParse(JSON.parse(text));
+    return parsed.success ? parsed.data : null;
+  }
+  let last = null;
+  for (const line of text.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("data:")) continue;
+    const payload = trimmed.slice("data:".length).trim();
+    if (!payload || payload === "[DONE]") continue;
+    try {
+      last = JSON.parse(payload);
+    } catch {
+    }
+  }
+  return last;
+}
+
+// src/commands/import-web.ts
+var SOURCE_URL_FRONTMATTER = z.object({
+  metadata: z.object({
+    corpus: z.object({
+      originalUrl: z.string().optional().catch(void 0),
+      importerSourceUrl: z.string().optional().catch(void 0)
+    }).loose().optional().catch(void 0)
+  }).loose().optional().catch(void 0)
+}).loose();
+function parse(args) {
+  const out = {
+    workspace: void 0,
+    urlsFile: void 0,
+    urls: [],
+    tags: [],
+    lang: void 0,
+    max: void 0,
+    maxDurationSec: void 0,
+    cookiesFromBrowser: void 0,
+    cookiesFile: void 0,
+    throttleMs: 2e3,
+    force: false,
+    diarize: false,
+    browserMcp: process.env.BROWSER_MCP_URL,
+    scrapeMcp: process.env.SCRAPE_MCP_URL,
+    importerId: "web",
+    dryRun: false
+  };
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    const next = () => args[++i];
+    switch (a) {
+      case "--urls-file":
+        out.urlsFile = next();
+        break;
+      case "--url": {
+        const v = next();
+        if (v) out.urls.push(v);
+        break;
+      }
+      case "--tags": {
+        const v = next();
+        if (v) out.tags.push(...v.split(",").map((s) => s.trim()).filter(Boolean));
+        break;
+      }
+      case "--lang":
+        out.lang = next();
+        break;
+      case "--max": {
+        const v = next();
+        if (v) out.max = Number(v);
+        break;
+      }
+      case "--max-duration": {
+        const v = next();
+        if (v) out.maxDurationSec = Number(v);
+        break;
+      }
+      case "--cookies-from-browser":
+        out.cookiesFromBrowser = next();
+        break;
+      case "--cookies":
+        out.cookiesFile = next();
+        break;
+      case "--throttle": {
+        const v = next();
+        if (v) out.throttleMs = Number(v);
+        break;
+      }
+      case "--force":
+        out.force = true;
+        break;
+      case "--diarize":
+        out.diarize = true;
+        break;
+      case "--browser-mcp":
+        out.browserMcp = next();
+        break;
+      case "--scrape-mcp":
+        out.scrapeMcp = next();
+        break;
+      case "--importer-id":
+        out.importerId = next() ?? "web";
+        break;
+      case "--dry-run":
+        out.dryRun = true;
+        break;
+      default:
+        if (!a.startsWith("-") && out.workspace === void 0) out.workspace = a;
+    }
+  }
+  return out;
+}
+async function readUrls(parsed) {
+  const fromFile = [];
+  if (parsed.urlsFile) {
+    const raw = await readFile(parsed.urlsFile, "utf-8");
+    for (const line of raw.split("\n")) {
+      const url = line.trim();
+      const m = url.match(/https?:\/\/\S+/);
+      if (m) fromFile.push(m[0]);
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return [...fromFile, ...parsed.urls].filter((u) => seen.has(u) ? false : seen.add(u));
+}
+async function scanIngestedUrls(workspaceRoot) {
+  const seen = /* @__PURE__ */ new Set();
+  const sourcesDir = join(workspaceRoot, "sources");
+  let entries;
+  try {
+    entries = await readdir(sourcesDir, {
+      recursive: true,
+      withFileTypes: true
+    });
+  } catch {
+    return seen;
+  }
+  for (const e of entries) {
+    if (!e.isFile() || !e.name.endsWith(".md")) continue;
+    try {
+      const raw = await readFile(join(e.parentPath, e.name), "utf-8");
+      const fm = SOURCE_URL_FRONTMATTER.parse(matter2(raw).data);
+      const url = fm.metadata?.corpus?.originalUrl ?? fm.metadata?.corpus?.importerSourceUrl;
+      if (url) seen.add(url);
+    } catch {
+    }
+  }
+  return seen;
+}
+async function runImportWeb(args) {
+  const parsed = parse(args);
+  const target = resolveWorkspacePath(parsed.workspace);
+  const urls = await readUrls(parsed);
+  if (urls.length === 0) {
+    return fail("import-web requires --urls-file <path> and/or one or more --url <u>.", 2);
+  }
+  const done = parsed.force ? /* @__PURE__ */ new Set() : await scanIngestedUrls(target);
+  const todo = urls.filter((u) => !done.has(u));
+  const batch = parsed.max !== void 0 ? todo.slice(0, parsed.max) : todo;
+  const remaining = todo.length - batch.length;
+  const plan = `  workspace: ${target}
+  urls:      ${urls.length} total \xB7 ${done.size && !parsed.force ? `${urls.length - todo.length} already ingested \xB7 ` : ""}${todo.length} to do
+  this run:  ${batch.length}${parsed.max !== void 0 ? ` (--max ${parsed.max})` : ""} \xB7 ${remaining} remaining after
+  video stt: ${parsed.diarize ? "AssemblyAI (speaker-labelled)" : "Whisper"}
+  throttle:  ${parsed.throttleMs} ms between fetches
+`;
+  if (batch.length === 0) {
+    process.stdout.write(`import-web \u2192 ${target}
+  nothing to do \u2014 all ${urls.length} URLs already ingested.
+`);
+    return 0;
+  }
+  if (parsed.dryRun) {
+    process.stdout.write(`import-web (dry run)
+${plan}`);
+    for (const u of batch.slice(0, 20)) process.stdout.write(`    - ${u}
+`);
+    if (batch.length > 20) process.stdout.write(`    \u2026 +${batch.length - 20} more
+`);
+    return 0;
+  }
+  process.stdout.write(`import-web
+${plan}`);
+  const chain = [];
+  let stt;
+  if (parsed.diarize) {
+    const aaiKey = process.env.ASSEMBLYAI_API_KEY;
+    if (aaiKey) stt = new AssemblyAiStt({ apiKey: aaiKey });
+    else
+      process.stderr.write(
+        "corpus: --diarize needs ASSEMBLYAI_API_KEY \u2014 video URLs will be skipped.\n"
+      );
+  } else {
+    const openaiKey = process.env.OPENAI_API_KEY;
+    if (openaiKey)
+      stt = new ChunkedStt({ base: new OpenAiWhisperStt({ apiKey: openaiKey }) });
+    else
+      process.stderr.write(
+        "corpus: OPENAI_API_KEY not set \u2014 video URLs will be skipped (no transcription).\n"
+      );
+  }
+  if (stt)
+    chain.push(
+      new YtDlpWhisperFetcher({
+        stt,
+        ...parsed.maxDurationSec ? { maxDurationSec: parsed.maxDurationSec } : {},
+        ...parsed.cookiesFromBrowser ? { cookiesFromBrowser: parsed.cookiesFromBrowser } : {},
+        ...parsed.cookiesFile ? { cookiesFile: parsed.cookiesFile } : {}
+      })
+    );
+  if (parsed.scrapeMcp) {
+    try {
+      const client = await connectBrowserMcp({ endpoint: parsed.scrapeMcp });
+      chain.push(new ScrapeMcpFetcher({ client }));
+    } catch (e) {
+      return fail(`could not connect to scrape MCP at ${parsed.scrapeMcp}: ${msg2(e)}`, 1);
+    }
+  }
+  if (parsed.browserMcp) {
+    let browser;
+    try {
+      browser = await connectBrowserMcp({ endpoint: parsed.browserMcp });
+      chain.push(new BrowserMcpFetcher({ browser }));
+    } catch (e) {
+      return fail(`could not connect to browser MCP at ${parsed.browserMcp}: ${msg2(e)}`, 1);
+    }
+  }
+  chain.push(new HttpReadabilityFetcher());
+  if (chain.length === 0) {
+    return fail("no fetchers available \u2014 set OPENAI_API_KEY (videos) and/or --browser-mcp.", 2);
+  }
+  const fetcher = new ThrottleFetcher(new CompositeFetcher(chain), {
+    minIntervalMs: parsed.throttleMs
+  });
+  const importer = new WebImporter({ fetcher });
+  const runner = new ImporterRunner({
+    // The fs is rooted AT the workspace, so corpus paths are relative to
+    // it — workspacePath is "" (root), NOT the absolute target (which
+    // would double-nest under the fs root).
+    fs: new NodeFsAdapter({ root: target }),
+    clock: systemClock,
+    identity: new OsIdentityAdapter({ workspaceRoot: target }),
+    workspacePath: ""
+  });
+  let report;
+  try {
+    report = await runner.run(importer, {
+      importerId: parsed.importerId,
+      config: {
+        urls: batch,
+        ...parsed.tags.length ? { tags: parsed.tags } : {},
+        ...parsed.lang ? { language: parsed.lang } : {}
+      }
+    });
+  } catch (e) {
+    return fail(`import failed: ${msg2(e)}`, 1);
+  }
+  process.stdout.write(
+    `import-web \u2192 ${target}
+  batch:      ${report.batchId}
+  archived:   ${report.archivedSlugs.length}
+  duplicates: ${report.duplicateSlugs.length}
+  candidates: ${report.candidateIds.length}
+`
+  );
+  for (const w of report.warnings.slice(0, 20)) process.stdout.write(`  ! ${w}
+`);
+  process.stdout.write(
+    `
+Next: review candidates, then promote them \u2014 promotion pushes chunks into the
+knowledge engine (RAG) via the WriterPort. Import only stages the sources.
+`
+  );
+  return 0;
+}
+function msg2(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+
+// src/ports/anthropic-distiller.ts
+var ANTHROPIC_RESPONSE = z.object({
+  model: z.string().optional(),
+  content: z.array(z.object({ type: z.string(), text: z.string().optional() }).loose()).optional(),
+  usage: z.object({ input_tokens: z.number(), output_tokens: z.number() }).loose().optional()
+}).loose();
+var AnthropicDistiller = class {
+  apiKey;
+  model;
+  baseUrl;
+  maxItems;
+  onUsage;
+  constructor(opts) {
+    this.apiKey = opts.apiKey;
+    this.model = opts.model ?? "claude-sonnet-4-6";
+    this.baseUrl = (opts.baseUrl ?? "https://api.anthropic.com/v1").replace(/\/+$/, "");
+    this.maxItems = opts.maxItems ?? 8;
+    this.onUsage = opts.onUsage;
+  }
+  async distill(input) {
+    const prompt = buildDistillPrompt(input, this.maxItems);
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const res = await fetch(`${this.baseUrl}/messages`, {
+      method: "POST",
+      headers: {
+        "x-api-key": this.apiKey,
+        "anthropic-version": "2023-06-01",
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({
+        model: this.model,
+        max_tokens: 4096,
+        messages: [{ role: "user", content: prompt }]
+      })
+    });
+    if (!res.ok) {
+      throw new Error(`Anthropic distill ${res.status}: ${(await res.text()).slice(0, 200)}`);
+    }
+    const parsed = ANTHROPIC_RESPONSE.safeParse(await res.json());
+    const text = parsed.success ? (parsed.data.content ?? []).find((c) => c.type === "text")?.text ?? "" : "";
+    if (parsed.success && parsed.data.usage && this.onUsage) {
+      this.onUsage({
+        model: parsed.data.model ?? this.model,
+        inputTokens: parsed.data.usage.input_tokens,
+        outputTokens: parsed.data.usage.output_tokens,
+        label: input.title,
+        startedAt,
+        endedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+    return parseItems(text);
+  }
+};
+var CliAgentDistiller = class {
+  engine;
+  model;
+  maxItems;
+  timeoutMs;
+  cwd;
+  constructor(opts) {
+    this.engine = opts.engine;
+    this.model = opts.model;
+    this.maxItems = opts.maxItems ?? 8;
+    this.timeoutMs = opts.timeoutMs ?? 12e4;
+    this.cwd = opts.cwd ?? tmpdir();
+  }
+  async distill(input) {
+    const prompt = buildDistillPrompt(input, this.maxItems);
+    const stdout = await spawnWithStdin({
+      command: this.engine.command,
+      args: this.engine.buildArgs({ ...this.model ? { model: this.model } : {} }),
+      stdin: prompt,
+      cwd: this.cwd,
+      timeoutMs: this.timeoutMs
+    });
+    const text = this.engine.parseOutput(stdout) ?? stdout;
+    return parseItems(text);
+  }
+};
+var CLAUDE_CODE = {
+  id: "claude-code",
+  subscriptionBilled: true,
+  command: "claude",
+  buildArgs: ({ model }) => [
+    "-p",
+    "--output-format",
+    "json",
+    "--strict-mcp-config",
+    ...model ? ["--model", model] : []
+  ],
+  parseOutput: parseClaudeJsonOutput
+};
+var CLI_ENGINES = {
+  [CLAUDE_CODE.id]: CLAUDE_CODE
+};
+var PRICING = [
+  { match: "opus", inPerM: 15, outPerM: 75 },
+  { match: "haiku", inPerM: 1, outPerM: 5 },
+  { match: "sonnet", inPerM: 3, outPerM: 15 }
+];
+function priceFor(model) {
+  const m = model.toLowerCase();
+  return PRICING.find((p) => m.includes(p.match)) ?? { inPerM: 3, outPerM: 15 };
+}
+function costUsd(u) {
+  const { inPerM, outPerM } = priceFor(u.model);
+  const input = u.inputTokens / 1e6 * inPerM;
+  const output = u.outputTokens / 1e6 * outPerM;
+  return { input, output, total: input + output };
+}
+function readLangfuseConfig() {
+  const publicKey = process.env.LANGFUSE_PUBLIC_KEY;
+  const secretKey = process.env.LANGFUSE_SECRET_KEY;
+  if (!publicKey || !secretKey) return void 0;
+  return {
+    baseUrl: (process.env.LANGFUSE_BASE_URL ?? "https://cloud.langfuse.com").replace(/\/+$/, ""),
+    publicKey,
+    secretKey,
+    environment: process.env.LANGFUSE_TRACING_ENVIRONMENT
+  };
+}
+var fmt = (n) => n.toLocaleString("en-US");
+var usd = (n) => `$${n.toFixed(n < 1 ? 4 : 2)}`;
+function createUsageSink(opts) {
+  const records = [];
+  const lf = readLangfuseConfig();
+  async function shipToLangfuse(cfg, traceId) {
+    const auth = Buffer.from(`${cfg.publicKey}:${cfg.secretKey}`).toString("base64");
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const batch = [
+      {
+        id: randomUUID(),
+        type: "trace-create",
+        timestamp: now,
+        body: {
+          id: traceId,
+          name: `corpus-distill: ${opts.runName}`,
+          timestamp: now,
+          ...cfg.environment ? { environment: cfg.environment } : {},
+          metadata: { tool: "corpus-cli", phase: "distill", calls: records.length }
+        }
+      },
+      ...records.map((u) => {
+        const c = costUsd(u);
+        return {
+          id: randomUUID(),
+          type: "generation-create",
+          timestamp: u.endedAt,
+          body: {
+            id: randomUUID(),
+            traceId,
+            type: "GENERATION",
+            name: u.label,
+            model: u.model,
+            startTime: u.startedAt,
+            endTime: u.endedAt,
+            ...cfg.environment ? { environment: cfg.environment } : {},
+            usage: {
+              input: u.inputTokens,
+              output: u.outputTokens,
+              total: u.inputTokens + u.outputTokens,
+              unit: "TOKENS",
+              inputCost: c.input,
+              outputCost: c.output,
+              totalCost: c.total
+            }
+          }
+        };
+      })
+    ];
+    const res = await fetch(`${cfg.baseUrl}/api/public/ingestion`, {
+      method: "POST",
+      headers: { authorization: `Basic ${auth}`, "content-type": "application/json" },
+      body: JSON.stringify({ batch })
+    });
+    if (!res.ok) {
+      throw new Error(`${res.status}: ${(await res.text()).slice(0, 160)}`);
+    }
+    return records.length;
+  }
+  return {
+    record(u) {
+      records.push(u);
+    },
+    async flush() {
+      if (records.length === 0) return;
+      const byModel = /* @__PURE__ */ new Map();
+      let grandTotal = 0;
+      for (const u of records) {
+        const c = costUsd(u);
+        grandTotal += c.total;
+        const m = byModel.get(u.model) ?? { input: 0, output: 0, cost: 0, calls: 0 };
+        m.input += u.inputTokens;
+        m.output += u.outputTokens;
+        m.cost += c.total;
+        m.calls += 1;
+        byModel.set(u.model, m);
+      }
+      process.stderr.write(`
+usage \u2014 ${records.length} metered call(s):
+`);
+      for (const [model, m] of byModel) {
+        process.stderr.write(
+          `  ${model}  ${m.calls} call(s) \xB7 in ${fmt(m.input)} \xB7 out ${fmt(m.output)} \xB7 ~${usd(m.cost)} est.
+`
+        );
+      }
+      process.stderr.write(`  total ~${usd(grandTotal)} est.
+`);
+      if (!lf) {
+        process.stderr.write(
+          "  langfuse: not configured (set LANGFUSE_PUBLIC_KEY / LANGFUSE_SECRET_KEY to export traces).\n"
+        );
+        return;
+      }
+      const traceId = randomUUID();
+      try {
+        const n = await shipToLangfuse(lf, traceId);
+        process.stderr.write(
+          `  langfuse: shipped ${n} generation(s) \u2192 trace ${traceId}${lf.environment ? ` (env: ${lf.environment})` : ""}
+`
+        );
+      } catch (e) {
+        process.stderr.write(
+          `  langfuse: export failed \u2014 ${e instanceof Error ? e.message : String(e)}
+`
+        );
+      }
+    }
+  };
+}
+
+// src/commands/distill.ts
+var SOURCE_FRONTMATTER = z.object({
+  id: z.string().optional().catch(void 0),
+  title: z.string().optional().catch(void 0),
+  tags: z.array(z.string()).optional().catch(void 0),
+  language: z.string().optional().catch(void 0),
+  metadata: z.object({
+    corpus: z.object({
+      access: z.string().optional().catch(void 0),
+      domain: z.string().optional().catch(void 0)
+    }).loose().optional().catch(void 0)
+  }).loose().optional().catch(void 0)
+}).loose();
+var ENTRY_SOURCES_FRONTMATTER = z.object({ sources: z.array(z.string()).optional().catch(void 0) }).loose();
+var DEFAULT_ENGINE = "anthropic-api";
+async function readEntryLayout(target) {
+  try {
+    const raw = await readFile(join(target, "KNOWLEDGE.md"), "utf8");
+    const layout = matter2(raw).data?.metadata;
+    const corpus = layout?.["corpus"];
+    const v = corpus?.["entryLayout"];
+    return v === "flat" || v === "dated" ? v : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var DISTILLER_ENGINES = {
+  [DEFAULT_ENGINE]: {
+    id: DEFAULT_ENGINE,
+    needsApiKey: true,
+    create: ({ apiKey, model, onUsage }) => new AnthropicDistiller({
+      apiKey,
+      ...model ? { model } : {},
+      ...onUsage ? { onUsage } : {}
+    })
+  },
+  ...Object.fromEntries(
+    Object.values(CLI_ENGINES).map((engine) => [
+      engine.id,
+      {
+        id: engine.id,
+        needsApiKey: false,
+        create: ({ model }) => new CliAgentDistiller({ engine, ...model ? { model } : {} })
+      }
+    ])
+  )
+};
+function parse2(args) {
+  const out = {
+    workspace: void 0,
+    sourceId: void 0,
+    max: void 0,
+    throttleMs: 1e3,
+    model: void 0,
+    engine: DEFAULT_ENGINE
+  };
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    const next = () => args[++i];
+    switch (a) {
+      case "--source":
+        out.sourceId = next();
+        break;
+      case "--max": {
+        const v = next();
+        if (v) out.max = Number(v);
+        break;
+      }
+      case "--throttle": {
+        const v = next();
+        if (v) out.throttleMs = Number(v);
+        break;
+      }
+      case "--model":
+        out.model = next();
+        break;
+      case "--engine": {
+        const v = next();
+        if (v) out.engine = v;
+        break;
+      }
+      default:
+        if (!a.startsWith("-") && out.workspace === void 0) out.workspace = a;
+    }
+  }
+  return out;
+}
+async function readSources(root) {
+  const dir = join(root, "sources");
+  let entries;
+  try {
+    entries = await readdir(dir, { recursive: true, withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const e of entries) {
+    if (!e.isFile() || !e.name.endsWith(".md")) continue;
+    const path4 = join(e.parentPath, e.name);
+    try {
+      const parsed = matter2(await readFile(path4, "utf-8"));
+      const fm = SOURCE_FRONTMATTER.parse(parsed.data);
+      if (!fm.id || !parsed.content.trim()) continue;
+      out.push({
+        path: path4,
+        id: fm.id,
+        title: fm.title ?? fm.id,
+        body: parsed.content.trim(),
+        ...fm.tags ? { tags: fm.tags } : {},
+        ...fm.metadata?.corpus?.access ? { access: fm.metadata.corpus.access } : {},
+        ...fm.metadata?.corpus?.domain ? { domain: fm.metadata.corpus.domain } : {}
+      });
+    } catch {
+    }
+  }
+  return out;
+}
+async function scanDistilledSourceIds(root) {
+  const seen = /* @__PURE__ */ new Set();
+  const dir = join(root, "entries");
+  let entries;
+  try {
+    entries = await readdir(dir, { recursive: true, withFileTypes: true });
+  } catch {
+    return seen;
+  }
+  for (const e of entries) {
+    if (!e.isFile() || !e.name.endsWith(".md")) continue;
+    try {
+      const fm = ENTRY_SOURCES_FRONTMATTER.parse(
+        matter2(await readFile(join(e.parentPath, e.name), "utf-8")).data
+      );
+      if (fm.sources) for (const s of fm.sources) seen.add(s);
+    } catch {
+    }
+  }
+  return seen;
+}
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function runDistill(args) {
+  const parsed = parse2(args);
+  const target = resolveWorkspacePath(parsed.workspace);
+  const engine = DISTILLER_ENGINES[parsed.engine];
+  if (!engine) {
+    return fail(
+      `unknown --engine "${parsed.engine}". Valid: ${Object.keys(DISTILLER_ENGINES).join(", ")}.`,
+      2
+    );
+  }
+  const apiKey = process.env.ANTHROPIC_API_KEY;
+  if (engine.needsApiKey && !apiKey) {
+    return fail(`distill engine "${engine.id}" needs ANTHROPIC_API_KEY in the environment.`, 2);
+  }
+  const all = await readSources(target);
+  if (all.length === 0) return fail("no sources found under sources/ \u2014 run import-web first.", 2);
+  const done = await scanDistilledSourceIds(target);
+  const pool = parsed.sourceId ? all.filter((s) => s.id === parsed.sourceId) : all.filter((s) => !done.has(s.id));
+  const batch = parsed.max !== void 0 ? pool.slice(0, parsed.max) : pool;
+  process.stdout.write(
+    `distill \u2192 ${target}
+  engine:   ${engine.id}
+  sources:  ${all.length} total \xB7 ${all.length - pool.length} already distilled \xB7 ${pool.length} to do
+  this run: ${batch.length}${parsed.max !== void 0 ? ` (--max ${parsed.max})` : ""}
+`
+  );
+  if (batch.length === 0) {
+    process.stdout.write("  nothing to do.\n");
+    return 0;
+  }
+  const usage = createUsageSink({ runName: basename(target) });
+  const layout = await readEntryLayout(target);
+  const runner = new DistillRunner({
+    fs: new NodeFsAdapter({ root: target }),
+    clock: systemClock,
+    ...layout ? { layout } : {},
+    distiller: engine.create({
+      ...apiKey ? { apiKey } : {},
+      ...parsed.model ? { model: parsed.model } : {},
+      onUsage: usage.record
+    })
+  });
+  let totalEntries = 0;
+  for (let i = 0; i < batch.length; i++) {
+    const src = batch[i];
+    if (i > 0 && parsed.throttleMs > 0) await sleep(parsed.throttleMs);
+    try {
+      const report = await runner.run(src);
+      totalEntries += report.entryPaths.length;
+      process.stdout.write(`  \u2713 ${src.id} \u2192 ${report.entryPaths.length} entries
+`);
+    } catch (e) {
+      process.stdout.write(`  ! ${src.id} \u2014 ${e instanceof Error ? e.message : String(e)}
+`);
+    }
+  }
+  process.stdout.write(`
+${totalEntries} refined entries written (each with sources:[<id>] provenance).
+`);
+  await usage.flush();
+  return 0;
+}
+async function runKnowledge(args) {
+  let workspace;
+  const tags = [];
+  const kinds = [];
+  let access;
+  let max;
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    const next = () => args[++i];
+    switch (a) {
+      case "--tags": {
+        const v = next();
+        if (v) tags.push(...v.split(",").map((s) => s.trim()).filter(Boolean));
+        break;
+      }
+      case "--kind": {
+        const v = next();
+        if (v && isRefinedKind(v)) kinds.push(v);
+        break;
+      }
+      case "--access":
+        access = next();
+        break;
+      case "--max": {
+        const v = next();
+        if (v) max = Number(v);
+        break;
+      }
+      default:
+        if (!a.startsWith("-") && workspace === void 0) workspace = a;
+    }
+  }
+  const target = resolveWorkspacePath(workspace);
+  if (tags.length === 0 && kinds.length === 0) {
+    return fail("knowledge needs --tags a,b and/or --kind <k>.", 2);
+  }
+  const query = {
+    ...tags.length ? { tags } : {},
+    ...kinds.length ? { kinds } : {},
+    ...max !== void 0 ? { maxResults: max } : {}
+  };
+  const hits = await resolveKnowledge({
+    fs: new NodeFsAdapter({ root: target }),
+    query,
+    ...access ? { allowedAccess: /* @__PURE__ */ new Set([access, "public"]) } : {}
+  });
+  process.stdout.write(
+    `knowledge ${tags.length ? `tags=[${tags.join(",")}] ` : ""}${kinds.length ? `kinds=[${kinds.join(",")}] ` : ""}\u2192 ${hits.length} refined entries
+
+`
+  );
+  for (const h of hits) {
+    process.stdout.write(
+      `  \u2022 [${h.kind}] ${h.title}  (conf ${h.confidence})
+    \u21B3 derivedFrom: ${h.sources.join(", ") || "\u2014"}${h.access ? ` \xB7 access: ${h.access}` : ""}
+    ${h.body.slice(0, 120).replace(/\s+/g, " ")}\u2026
+
+`
+    );
+  }
+  return 0;
+}
+var RPC_RESPONSE2 = z.object({ result: z.unknown().optional(), error: z.unknown().optional() }).loose();
+var RPC_MESSAGE = z.object({
+  id: z.number().optional(),
+  result: z.unknown().optional(),
+  error: z.unknown().optional()
+}).loose();
+var CALL_RESULT2 = z.object({
+  content: z.unknown().optional(),
+  structuredContent: z.unknown().optional(),
+  isError: z.boolean().optional()
+}).loose();
+async function connectMcpHttp(opts) {
+  if (opts.transport === "sse") {
+    const sse = new SseMcpClient(opts);
+    await sse.connect();
+    return sse;
+  }
+  const client = new StreamableHttpMcpClient2(opts);
+  await client.initialize();
+  return client;
+}
+var StreamableHttpMcpClient2 = class {
+  id = 0;
+  sessionId;
+  endpoint;
+  headers;
+  protocolVersion;
+  constructor(opts) {
+    this.endpoint = opts.endpoint;
+    this.headers = opts.headers ?? {};
+    this.protocolVersion = opts.protocolVersion ?? "2025-06-18";
+  }
+  async initialize() {
+    const res = await this.rpc({
+      jsonrpc: "2.0",
+      id: ++this.id,
+      method: "initialize",
+      params: {
+        protocolVersion: this.protocolVersion,
+        capabilities: {},
+        clientInfo: { name: "corpus-cli", version: "0.1.0" }
+      }
+    });
+    await this.rpc({ jsonrpc: "2.0", method: "notifications/initialized", params: {} }, false);
+    if (res?.error) throw new Error(`initialize failed: ${JSON.stringify(res.error)}`);
+  }
+  async callTool(name, args) {
+    const res = await this.rpc({
+      jsonrpc: "2.0",
+      id: ++this.id,
+      method: "tools/call",
+      params: { name, arguments: args }
+    });
+    if (res?.error) throw new Error(`tools/call ${name}: ${JSON.stringify(res.error)}`);
+    const parsed = CALL_RESULT2.safeParse(res?.result ?? {});
+    return parsed.success ? parsed.data : {};
+  }
+  async rpc(body, expectResponse = true) {
+    const res = await fetch(this.endpoint, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        accept: "application/json, text/event-stream",
+        ...this.sessionId ? { "mcp-session-id": this.sessionId } : {},
+        ...this.headers
+      },
+      body: JSON.stringify(body)
+    });
+    const sid = res.headers.get("mcp-session-id");
+    if (sid) this.sessionId = sid;
+    if (!expectResponse) return null;
+    if (!res.ok) throw new Error(`MCP HTTP ${res.status} ${res.statusText}`);
+    return parseRpc(await res.text(), res.headers.get("content-type"));
+  }
+};
+var SseMcpClient = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.base = new URL(opts.endpoint);
+  }
+  id = 0;
+  messagesUrl;
+  pending = /* @__PURE__ */ new Map();
+  readyResolve;
+  ready = new Promise((r) => this.readyResolve = r);
+  base;
+  async connect() {
+    const res = await fetch(this.opts.endpoint, {
+      headers: { accept: "text/event-stream", ...this.opts.headers ?? {} }
+    });
+    if (!res.ok || !res.body) throw new Error(`SSE connect ${res.status} ${res.statusText}`);
+    void this.readLoop(res.body.getReader());
+    await withTimeout(this.ready, 1e4, "SSE endpoint event");
+    const init = await this.send("initialize", {
+      protocolVersion: this.opts.protocolVersion ?? "2025-06-18",
+      capabilities: {},
+      clientInfo: { name: "corpus-cli", version: "0.1.0" }
+    });
+    if (init?.error) throw new Error(`initialize failed: ${JSON.stringify(init.error)}`);
+    await this.post({ jsonrpc: "2.0", method: "notifications/initialized", params: {} });
+  }
+  async callTool(name, args) {
+    const res = await this.send("tools/call", { name, arguments: args });
+    if (res?.error) throw new Error(`tools/call ${name}: ${JSON.stringify(res.error)}`);
+    const parsed = CALL_RESULT2.safeParse(res?.result ?? {});
+    return parsed.success ? parsed.data : {};
+  }
+  async send(method, params) {
+    const id = ++this.id;
+    const wait = new Promise((resolve) => this.pending.set(id, resolve));
+    await this.post({ jsonrpc: "2.0", id, method, params });
+    return withTimeout(wait, 6e4, `${method} response`);
+  }
+  async post(body) {
+    if (!this.messagesUrl) throw new Error("SSE messages endpoint not ready");
+    const res = await fetch(this.messagesUrl, {
+      method: "POST",
+      headers: { "content-type": "application/json", ...this.opts.headers ?? {} },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok && res.status !== 202) throw new Error(`SSE POST ${res.status}`);
+  }
+  async readLoop(reader) {
+    const dec = new TextDecoder();
+    let buf = "";
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buf += dec.decode(value, { stream: true });
+      let nl;
+      while ((nl = buf.indexOf("\n\n")) >= 0) {
+        const raw = buf.slice(0, nl);
+        buf = buf.slice(nl + 2);
+        this.handleEvent(raw);
+      }
+    }
+  }
+  handleEvent(raw) {
+    let event = "message";
+    const data = [];
+    for (const line of raw.split("\n")) {
+      if (line.startsWith("event:")) event = line.slice(6).trim();
+      else if (line.startsWith("data:")) data.push(line.slice(5).trim());
+    }
+    const payload = data.join("\n");
+    if (event === "endpoint") {
+      this.messagesUrl = new URL(payload, this.base).toString();
+      this.readyResolve();
+      return;
+    }
+    if (!payload) return;
+    try {
+      const parsed = RPC_MESSAGE.safeParse(JSON.parse(payload));
+      if (!parsed.success) return;
+      const msg4 = parsed.data;
+      if (typeof msg4.id === "number" && this.pending.has(msg4.id)) {
+        this.pending.get(msg4.id)(msg4);
+        this.pending.delete(msg4.id);
+      }
+    } catch {
+    }
+  }
+};
+function withTimeout(p, ms, what) {
+  return Promise.race([
+    p,
+    new Promise((_, rej) => setTimeout(() => rej(new Error(`timeout waiting for ${what}`)), ms))
+  ]);
+}
+function parseRpc(text, contentType) {
+  if (!text.trim()) return null;
+  if (!(contentType ?? "").includes("text/event-stream")) {
+    const parsed = RPC_RESPONSE2.safeParse(JSON.parse(text));
+    return parsed.success ? parsed.data : null;
+  }
+  let last = null;
+  for (const line of text.split("\n")) {
+    const t = line.trim();
+    if (!t.startsWith("data:")) continue;
+    const p = t.slice(5).trim();
+    if (!p || p === "[DONE]") continue;
+    try {
+      last = JSON.parse(p);
+    } catch {
+    }
+  }
+  return last;
+}
+
+// src/ports/mcp-sink.adapter.ts
+var SINK_CONFIG_SCHEMA = z.object({
+  endpoint: z.string().min(1),
+  tool: z.string().min(1),
+  /** Arg template — substituted per entry. */
+  args: z.record(z.string(), z.unknown()),
+  headers: z.record(z.string(), z.string()).optional(),
+  /** MCP transport: "streamable-http" (default) or "sse". */
+  transport: z.enum(["streamable-http", "sse"]).optional(),
+  /**
+   * If set, calls go through `mcp_imported_call({ alias, toolName, args })`
+   * (the agentproto daemon's imported-MCP proxy) instead of the tool directly.
+   */
+  importedAlias: z.string().optional()
+});
+var McpSink = class {
+  constructor(config, client) {
+    this.config = config;
+    this.client = client;
+  }
+  client;
+  async ensure() {
+    if (!this.client) {
+      this.client = await connectMcpHttp({
+        endpoint: this.config.endpoint,
+        ...this.config.headers ? { headers: this.config.headers } : {},
+        ...this.config.transport ? { transport: this.config.transport } : {}
+      });
+    }
+    return this.client;
+  }
+  async push(item) {
+    let client;
+    try {
+      client = await this.ensure();
+    } catch (e) {
+      return { uri: item.uri, ok: false, error: `connect: ${msg3(e)}` };
+    }
+    const args = template(this.config.args, item);
+    const call = this.config.importedAlias ? { name: "mcp_imported_call", args: { alias: this.config.importedAlias, toolName: this.config.tool, args } } : { name: this.config.tool, args };
+    try {
+      const res = await client.callTool(call.name, call.args);
+      if (res.isError) return { uri: item.uri, ok: false, error: "tool returned isError" };
+      return { uri: item.uri, ok: true };
+    } catch (e) {
+      return { uri: item.uri, ok: false, error: msg3(e) };
+    }
+  }
+};
+var PLACEHOLDER_RE = /\$\{(\w+)\}/g;
+function template(args, item) {
+  const fields = {
+    slug: item.slug,
+    title: item.title,
+    body: item.body,
+    sources: item.sources,
+    tags: item.tags,
+    access: item.access ?? "",
+    uri: item.uri,
+    kind: item.kind,
+    confidence: item.confidence
+  };
+  const out = {};
+  for (const [key, value] of Object.entries(args)) {
+    out[key] = substitute(value, fields);
+  }
+  return out;
+}
+function substitute(value, fields) {
+  if (typeof value === "string") {
+    const whole = value.match(/^\$\{(\w+)\}$/);
+    if (whole && whole[1] in fields) return fields[whole[1]];
+    return value.replace(
+      PLACEHOLDER_RE,
+      (_, k) => k in fields ? stringify(fields[k]) : `\${${k}}`
+    );
+  }
+  if (Array.isArray(value)) return value.map((v) => substitute(v, fields));
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) out[k] = substitute(v, fields);
+    return out;
+  }
+  return value;
+}
+function stringify(v) {
+  if (Array.isArray(v)) return v.join(", ");
+  return v == null ? "" : String(v);
+}
+function msg3(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+
+// src/commands/sync.ts
+async function runSync(args) {
+  let workspace;
+  let configPath;
+  const tags = [];
+  const kinds = [];
+  let throttleMs = 500;
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    const next = () => args[++i];
+    switch (a) {
+      case "--config":
+        configPath = next();
+        break;
+      case "--tags": {
+        const v = next();
+        if (v) tags.push(...v.split(",").map((s) => s.trim()).filter(Boolean));
+        break;
+      }
+      case "--kind": {
+        const v = next();
+        if (v && isRefinedKind(v)) kinds.push(v);
+        break;
+      }
+      case "--throttle": {
+        const v = next();
+        if (v) throttleMs = Number(v);
+        break;
+      }
+      default:
+        if (!a.startsWith("-") && workspace === void 0) workspace = a;
+    }
+  }
+  const target = resolveWorkspacePath(workspace);
+  if (!configPath) return fail("sync needs --config <sink-manifest.json>.", 2);
+  let raw;
+  try {
+    raw = JSON.parse(await readFile(configPath, "utf-8"));
+  } catch (e) {
+    return fail(`could not read sink config: ${e instanceof Error ? e.message : String(e)}`, 2);
+  }
+  const parsedConfig = SINK_CONFIG_SCHEMA.safeParse(raw);
+  if (!parsedConfig.success) {
+    return fail(
+      `invalid sink config (needs endpoint, tool, args): ${parsedConfig.error.issues[0]?.message ?? "schema mismatch"}`,
+      2
+    );
+  }
+  const config = parsedConfig.data;
+  const select = {
+    ...tags.length ? { tags } : {},
+    ...kinds.length ? { kinds } : {}
+  };
+  const report = await new SyncRunner({
+    fs: new NodeFsAdapter({ root: target }),
+    sink: new McpSink(config),
+    select,
+    throttleMs
+  }).run();
+  process.stdout.write(
+    `sync \u2192 ${config.endpoint} (tool: ${config.tool})
+  pushed: ${report.pushed} \xB7 skipped: ${report.skipped} \xB7 failed: ${report.failed}
+`
+  );
+  for (const r of report.results.filter((r2) => !r2.ok).slice(0, 10)) {
+    process.stdout.write(`  ! ${r.uri} \u2014 ${r.error}
+`);
+  }
+  return report.failed > 0 && report.pushed === 0 ? 1 : 0;
+}
+
+// src/version.ts
+var VERSION = "0.1.0-alpha.0";
+
+// src/cli.ts
+var HELP = `corpus \u2014 AIP-10 corpus workspace operator (v${VERSION})
+
+Commands:
+  init <name> [path] [--with a,b] [--preset <slug>]
+                                         Scaffold a corpus \u2014 bare AIP-10 by default
+                                         (--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
+  events:emit <kind> --payload <json> [path]
+                                         Append an event to _log.md
+  events:tail [path]                     Print _log.md
+  import-web [path] --urls-file <f> [--max n --max-duration s --throttle ms --tags t --lang l --force --diarize]
+                                         Import URLs as sources (video\u2192Whisper, article\u2192
+                                         readability). Resumable: skips already-ingested
+                                         URLs, so re-run with --max N to batch through.
+                                         --max-duration: skip videos longer than s seconds
+                                         (no download); omit for no cap (long media is
+                                         segmented under Whisper's 25 MB limit).
+                                         --cookies-from-browser <b>: auth yt-dlp from a
+                                         local browser (chrome/firefox) to dodge YouTube's
+                                         bot-check; --cookies <file> for a cookies.txt.
+                                         --scrape-mcp <url>: delegate article fetching to a
+                                         scrape MCP server (stealth + clean Markdown) for
+                                         walled/JS pages, ahead of plain readability.
+                                         --diarize: AssemblyAI speaker labels (interviews).
+  distill [path] [--source id --max n --throttle ms --model m]
+                                         Distill raw sources \u2192 refined entries
+                                         (principle/pattern/\u2026) with sources:[id] provenance.
+                                         Resumable: skips already-distilled sources.
+  knowledge [path] --tags a,b [--kind k --access scope --max n]
+                                         Preview what a skill's knowledge: binding resolves to
+                                         \u2014 refined entries + their provenance (filesystem).
+  sync [path] --config <sink.json> [--tags a,b --kind k --throttle ms]
+                                         Push refined entries to an external store via a
+                                         config-driven MCP sink (host-agnostic).
+  -h, --help                             Show this help
+  -v, --version                          Show version
+
+Conventions:
+  [path] defaults to the current working directory.
+  All commands target the workspace whose root contains KNOWLEDGE.md
+  (except 'init' which creates one).
+`;
+async function main(argv2) {
+  const [cmd, ...rest] = argv2;
+  if (!cmd || cmd === "-h" || cmd === "--help") {
+    process.stdout.write(HELP);
+    return 0;
+  }
+  if (cmd === "-v" || cmd === "--version") {
+    process.stdout.write(`corpus v${VERSION}
+`);
+    return 0;
+  }
+  switch (cmd) {
+    case "init":
+      return await runInit(rest);
+    case "validate":
+      return await runValidate(rest);
+    case "lint":
+      return await runLint(rest);
+    case "events:emit":
+      return await runEventsEmit(rest);
+    case "events:tail":
+      return await runEventsTail(rest);
+    case "import-web":
+      return await runImportWeb(rest);
+    case "distill":
+      return await runDistill(rest);
+    case "knowledge":
+      return await runKnowledge(rest);
+    case "sync":
+      return await runSync(rest);
+    default:
+      process.stderr.write(`corpus: unknown command "${cmd}". Try --help.
+`);
+      return 2;
+  }
+}
+var argv = process.argv.slice(2);
+main(argv).then((code) => process.exit(code)).catch((err) => {
+  process.stderr.write(
+    `corpus: unhandled error \u2014 ${err instanceof Error ? err.message : String(err)}
+`
+  );
+  process.exit(1);
+});
+//# sourceMappingURL=cli.mjs.map
+//# sourceMappingURL=cli.mjs.map