@indigoai-us/hq-cli 5.345.105 → 5.345.107

package/assets/scaffold/core/scripts/ontology-brief.mjs

@@ -1,93 +0,0 @@
-#!/usr/bin/env node
-// ontology-brief.mjs — render a company brief from the reader's LOCAL tree.
-// Spec: core/knowledge/public/hq-core/ontology-local-spec.md
-//
-// Usage: node core/scripts/ontology-brief.mjs --company <co> [--hq-root <p>] [--days N] [--top N] [--json]
-//
-// Reads ontology/entities/, every ontology/facts/@*/ and signals/{type}/ +
-// signals/@*/{type}/ present locally. Sync pull only delivers what the reader
-// may read, so the brief shows exactly their visible facts and signals.
-// Writes nothing. Prints markdown (default) or JSON. Exit 0 with an empty brief
-// ("no local ontology") when nothing is there.
-import fs from "node:fs";
-import path from "node:path";
-
-const TYPES = ["decision", "commitment", "risk", "question", "action_item", "key_point", "participant_contribution", "summary"];
-const args = process.argv.slice(2);
-const opt = { days: 14, top: 10, json: false };
-for (let i = 0; i < args.length; i++) {
-  const k = args[i];
-  if (k === "--company") opt.company = args[++i];
-  else if (k === "--hq-root") opt.root = args[++i];
-  else if (k === "--days") opt.days = Number(args[++i]);
-  else if (k === "--top") opt.top = Number(args[++i]);
-  else if (k === "--json") opt.json = true;
-  else { console.error(`ontology-brief: unknown flag ${k}`); process.exit(2); }
-}
-if (!opt.company) { console.error("usage: ontology-brief.mjs --company <co> [--days N] [--top N] [--json]"); process.exit(2); }
-opt.root = opt.root || process.env.HQ_ROOT || path.resolve(path.dirname(new URL(import.meta.url).pathname), "../..");
-const C = path.join(opt.root, "companies", opt.company);
-if (!fs.existsSync(C)) { console.error(`ontology-brief: no company ${opt.company}`); process.exit(2); }
-
-function fm(file) {
-  const t = fs.readFileSync(file, "utf8");
-  const m = t.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
-  const out = { _body: (m ? m[2] : t).trim() };
-  if (m) for (const line of m[1].split("\n")) {
-    const mm = line.match(/^([A-Za-z_]+):\s*(.*)$/);
-    if (mm) out[mm[1]] = mm[2].trim().replace(/^"(.*)"$/, "$1");
-  }
-  return out;
-}
-const walk = (dir, pred) => {
-  if (!fs.existsSync(dir)) return [];
-  const out = [];
-  for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
-    const p = path.join(dir, e.name);
-    if (e.isDirectory()) { if (!e.name.startsWith("_")) out.push(...walk(p, pred)); }
-    else if (pred(p)) out.push(p);
-  }
-  return out;
-};
-
-const entities = walk(path.join(C, "ontology", "entities"), p => p.endsWith(".md")).map(f => fm(f));
-const cutoff = Date.now() - opt.days * 86400e3;
-const signals = walk(path.join(C, "signals"), p => p.endsWith(".md") && !p.includes(`${path.sep}_`))
-  .map(f => ({ ...fm(f), _scope: f.includes(`${path.sep}signals${path.sep}@`) ? "scoped" : "company" }))
-  .filter(s => TYPES.includes(s.type));
-const recent = signals.filter(s => !s.created_at || Date.parse(s.created_at) >= cutoff)
-  .sort((a, b) => (b.created_at || "").localeCompare(a.created_at || ""));
-const facts = new Map(); // slug -> [{scope, line}]
-for (const f of walk(path.join(C, "ontology", "facts"), p => p.endsWith(".md"))) {
-  const d = fm(f); const scope = f.includes(`${path.sep}@company${path.sep}`) ? "company" : "scoped";
-  const slug = d.entity || path.basename(f, ".md");
-  for (const line of d._body.split("\n").filter(l => l.startsWith("- "))) {
-    if (!facts.has(slug)) facts.set(slug, []);
-    facts.get(slug).push({ scope, line: line.slice(2) });
-  }
-}
-const hot = entities.map(e => ({ ...e, _facts: facts.get(e.slug) || [] }))
-  .sort((a, b) => (b._facts.length - a._facts.length) || ((+b.signal_count || 0) - (+a.signal_count || 0)))
-  .slice(0, opt.top);
-
-if (opt.json) {
-  console.log(JSON.stringify({ company: opt.company, entities: entities.length, signals: signals.length,
-    recent: recent.slice(0, opt.top * 2).map(s => ({ type: s.type, scope: s._scope, text: s.canonical_content || s._body })),
-    hot: hot.map(e => ({ name: e.canonical_name, type: e.type, facts: e._facts })) }));
-  process.exit(0);
-}
-if (!entities.length && !signals.length) { console.log(`# ${opt.company} — no local ontology yet\n\nNothing under ontology/ or signals/ that you can see.`); process.exit(0); }
-const out = [`# ${opt.company} — company brief (local)`, "", `${entities.length} entities · ${signals.length} signals you can see · last ${opt.days} days`, "", "## Recent Signals"];
-for (const t of TYPES) {
-  const rows = recent.filter(s => s.type === t).slice(0, 5);
-  if (!rows.length) continue;
-  out.push("", `### ${t.replace("_", " ")}`);
-  for (const s of rows) out.push(`- ${s.canonical_content || s._body} _(${s._scope})_`);
-}
-out.push("", "## Entities");
-for (const e of hot) {
-  out.push("", `### ${e.canonical_name} — ${e.type}`);
-  if (!e._facts.length) out.push("- no facts you can see");
-  for (const f of e._facts.slice(0, 6)) out.push(`- ${f.line} _(${f.scope})_`);
-}
-console.log(out.join("\n"));

package/assets/scaffold/core/scripts/ontology-candidate.sh

@@ -1,100 +0,0 @@
-#!/usr/bin/env bash
-# ontology-candidate.sh — write one signal or entity candidate for the ontology
-# worker to garden. Deterministic, no model call. Spec:
-# core/knowledge/public/hq-core/ontology-local-spec.md
-#
-# Usage:
-#   ontology-candidate.sh write --company <co> --kind signal|entity --type <t> \
-#     --audience <company|email[,email...]> --source-ref <ref> \
-#     (--body-file <path> | --body <text>) [--created-by <email>]
-#   ontology-candidate.sh key <company|email[,email...]>   # print the audience key
-#
-# Exit 0: written, already present (no-op), or capture disabled for the company.
-# Exit 2: bad usage, unknown type, or empty body.
-set -euo pipefail
-
-root="${HQ_ROOT:-$(cd "$(dirname "$0")/../.." && pwd)}"
-here="$(cd "$(dirname "$0")" && pwd)"
-
-SIGNAL_TYPES="action_item commitment decision risk question key_point participant_contribution summary"
-ENTITY_TYPES="person project company concept"
-
-die() { echo "ontology-candidate: $*" >&2; exit 2; }
-
-sha() { if command -v sha256sum >/dev/null 2>&1; then sha256sum | awk '{print $1}'; else shasum -a 256 | awk '{print $1}'; fi; }
-
-normalize_audience() { # stdout: sorted, lowercased, trimmed, comma-joined
-  # Emails are lowercased; person/agent uids (prs_…, agt_…) keep their case.
-  printf '%s' "$1" | tr ',' '\n' | sed 's/^[[:space:]]*//;s/[[:space:]]*$//' \
-    | awk '/@/ { print tolower($0); next } { print }' \
-    | grep -v '^$' | LC_ALL=C sort -u | paste -sd, -
-}
-
-audience_key() {
-  local a; a="$(printf '%s' "$1" | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')"
-  [ -n "$a" ] || die "empty audience"
-  if [ "$(printf '%s' "$a" | tr '[:upper:]' '[:lower:]')" = "company" ]; then echo company; return; fi
-  printf '%s' "$(normalize_audience "$a")" | sha | cut -c1-16
-}
-
-cmd="${1:-}"; shift || true
-case "$cmd" in
-  key) audience_key "${1:-}"; exit 0 ;;
-  write) ;;
-  *) die "usage: ontology-candidate.sh write|key ..." ;;
-esac
-
-co="" kind="" type="" audience="" ref="" body="" body_file="" by="${HQ_USER_EMAIL:-}"
-while [ $# -gt 0 ]; do
-  case "$1" in
-    --company) co="$2"; shift 2 ;;
-    --kind) kind="$2"; shift 2 ;;
-    --type) type="$2"; shift 2 ;;
-    --audience) audience="$2"; shift 2 ;;
-    --source-ref) ref="$2"; shift 2 ;;
-    --body) body="$2"; shift 2 ;;
-    --body-file) body_file="$2"; shift 2 ;;
-    --created-by) by="$2"; shift 2 ;;
-    *) die "unknown flag $1" ;;
-  esac
-done
-[ -n "$co" ] && [ -n "$kind" ] && [ -n "$type" ] && [ -n "$audience" ] && [ -n "$ref" ] || die "missing required flag"
-[ -n "$body_file" ] && { [ -f "$body_file" ] || die "no body file $body_file"; body="$(cat "$body_file")"; }
-body="$(printf '%s' "$body" | tr '\n' ' ' | sed 's/[[:space:]]\{1,\}/ /g;s/^ //;s/ $//')"
-[ -n "$body" ] || die "empty body"
-
-case "$kind" in
-  signal) allowed="$SIGNAL_TYPES"; flag=signals_capture; store=signals ;;
-  entity) allowed="$ENTITY_TYPES"; flag=ontology_capture; store=ontology ;;
-  *) die "kind must be signal or entity" ;;
-esac
-case " $allowed " in *" $type "*) ;; *) die "unknown $kind type '$type' (allowed: $allowed)" ;; esac
-
-enabled="$(HQ_ROOT="$root" bash "$here/knowledge-prefs.sh" get "$co" "$flag")" || exit 2
-if [ "$enabled" != "true" ]; then echo "disabled for $co ($flag=false)"; exit 0; fi
-
-key="$(audience_key "$audience")"
-norm_body="$(printf '%s' "$body" | tr '[:upper:]' '[:lower:]')"
-id="$(printf '%s\n%s\n%s\n%s' "$kind" "$type" "$key" "$norm_body" | sha)"
-
-dir="$root/companies/$co/$store/_candidates/$(date -u +%Y-%m-%d)"
-# Idempotent across days: the same candidate already written (pending or done) is a no-op.
-if [ -n "$(find "$root/companies/$co/$store/_candidates" -name "$id.md" -print -quit 2>/dev/null)" ]; then
-  echo "exists $id"; exit 0
-fi
-mkdir -p "$dir"
-{
-  echo "---"
-  echo "kind: $kind"
-  echo "type: $type"
-  echo "audience_key: $key"
-  if [ "$key" != "company" ]; then
-    echo "audience: [$(normalize_audience "$audience" | sed 's/,/, /g')]"
-  fi
-  echo "source_ref: \"$ref\""
-  [ -n "$by" ] && echo "created_by: $by"
-  echo "created_at: $(date -u +%Y-%m-%dT%H:%M:%SZ)"
-  echo "---"
-  echo "$body"
-} > "$dir/$id.md.tmp" && mv "$dir/$id.md.tmp" "$dir/$id.md"
-echo "wrote $store/_candidates/$(basename "$dir")/$id.md"

package/assets/scaffold/core/scripts/ontology-garden.mjs

@@ -1,327 +0,0 @@
-#!/usr/bin/env node
-// ontology-garden.mjs — promote signal and entity candidates into a company's
-// local ontology and signal stores. Deterministic: no model call, no network.
-// Spec: core/knowledge/public/hq-core/ontology-local-spec.md
-//
-// Usage: node core/scripts/ontology-garden.mjs --company <co> [--hq-root <path>] [--dry-run] [--json]
-//
-// What it does, in order:
-//   1. Entity candidates  -> ontology/entities/{type}/{slug}.md (identity only).
-//      Stopword names and a name already held by an entity of another type are
-//      rejected to ontology/_rejected/{date}.jsonl.
-//   2. Signal candidates  -> signals/{type}/{sha}.md (audience company) or
-//      signals/@{key}/{type}/{sha}.md (scoped), plus signals/@{key}/_audience.yaml
-//      and signals/_index/{date}.json.
-//   3. Facts              -> for each promoted signal, every known entity whose
-//      name or alias appears in it gets a line in
-//      ontology/facts/@{key}/{type}/{slug}.md (never in the entity file).
-//      Company-audience signals bump the entity's signal_count.
-//   4. Processed candidates move to _candidates/_done/{date}/; .last-run is
-//      bumped only when at least one candidate was processed.
-// A second run over the same input changes nothing.
-import fs from "node:fs";
-import path from "node:path";
-
-const STOPWORDS = new Set([
-  "for", "calls", "call", "context", "summary", "reason", "the", "a", "an", "and",
-  "or", "this", "that", "it", "we", "they", "you", "i", "notes", "meeting", "update",
-  "question", "decision", "risk", "todo", "none", "n/a", "unknown",
-]);
-const SIGNAL_TYPES = new Set(["action_item", "commitment", "decision", "risk", "question",
-  "key_point", "participant_contribution", "summary"]);
-const ENTITY_TYPES = new Set(["person", "project", "company", "concept"]);
-
-function parseArgs(argv) {
-  const a = { dryRun: false, json: false };
-  for (let i = 0; i < argv.length; i++) {
-    const k = argv[i];
-    if (k === "--company") a.company = argv[++i];
-    else if (k === "--hq-root") a.root = argv[++i];
-    else if (k === "--dry-run") a.dryRun = true;
-    else if (k === "--json") a.json = true;
-    else { console.error(`ontology-garden: unknown flag ${k}`); process.exit(2); }
-  }
-  if (!a.company) { console.error("usage: ontology-garden.mjs --company <co> [--hq-root <p>] [--dry-run] [--json]"); process.exit(2); }
-  a.root = a.root || process.env.HQ_ROOT || path.resolve(path.dirname(new URL(import.meta.url).pathname), "../..");
-  return a;
-}
-
-// Minimal frontmatter reader for the flat key: value shape the writers emit.
-function readDoc(file) {
-  const text = fs.readFileSync(file, "utf8");
-  const m = text.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
-  if (!m) return { fm: {}, body: text.trim() };
-  const fm = {};
-  for (const line of m[1].split("\n")) {
-    const mm = line.match(/^([A-Za-z_]+):\s*(.*)$/);
-    if (!mm) continue;
-    let v = mm[2].trim();
-    if (v.startsWith("[") && v.endsWith("]")) v = v.slice(1, -1).split(",").map(s => s.trim().replace(/^["']|["']$/g, "")).filter(Boolean);
-    else v = v.replace(/^["']|["']$/g, "");
-    fm[mm[1]] = v;
-  }
-  return { fm, body: m[2].trim() };
-}
-
-function writeDoc(file, fm, body, dry) {
-  if (dry) return;
-  const lines = ["---"];
-  for (const [k, v] of Object.entries(fm)) {
-    if (v === undefined || v === null || v === "") continue;
-    lines.push(`${k}: ${Array.isArray(v) ? `[${v.join(", ")}]` : v}`);
-  }
-  lines.push("---", body, "");
-  fs.mkdirSync(path.dirname(file), { recursive: true });
-  const tmp = `${file}.tmp`;
-  fs.writeFileSync(tmp, lines.join("\n"));
-  fs.renameSync(tmp, file);
-}
-
-const slugify = s => s.toLowerCase().normalize("NFKD").replace(/[^\p{L}\p{N}]+/gu, "-").replace(/^-+|-+$/g, "").slice(0, 80);
-const today = () => new Date().toISOString().slice(0, 10);
-const now = () => new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
-const yyyyMm = () => new Date().toISOString().slice(0, 7);
-
-// ── Fact-file compaction ─────────────────────────────────────────────
-// Fact pages append one line per signal-mention of an entity (see step 3
-// below). Without a bound a hot entity accumulates every mention it has
-// ever received, so the page becomes a flat log. Compaction keeps the
-// most recent N lines inline and rolls the older ones into a dated,
-// append-only archive next to the fact file. `signal_count` on the
-// entity itself is unaffected — it is the true total.
-const BACKREF_COMPACT_THRESHOLD = Number(process.env.HQ_ONTOLOGY_BACKREF_THRESHOLD || 50);
-const BACKREF_KEEP_INLINE = Number(process.env.HQ_ONTOLOGY_BACKREF_KEEP_INLINE || 25);
-const SUMMARY_MARKER = "<!-- backref-archive -->";
-
-function isBackrefLine(line) { return /^- \[[a-z_]+\] .+ \(signal [0-9a-f]{12}\)\s*$/.test(line); }
-function isSummaryLine(line) { return line.includes(SUMMARY_MARKER); }
-
-function readArchiveIndex(file) {
-  if (!fs.existsSync(file)) return { version: 1, signalIds: [] };
-  try {
-    const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
-    if (parsed && Array.isArray(parsed.signalIds)) {
-      return { version: 1, signalIds: parsed.signalIds.filter(s => typeof s === "string") };
-    }
-  } catch (err) {
-    console.warn(`ontology-garden: archive index unreadable at ${file}: ${err.message || err}; skipping compaction`);
-  }
-  // Present but unreadable: never compact on top of it, or the rewrite would
-  // drop every archived id it lists.
-  return { version: 1, signalIds: [], unreadable: true };
-}
-
-// Compact `body` when its backref-line count exceeds the threshold.
-// Returns { body, archivedLines, archivedIds, changed }.
-function compactFactBody(body, { slug, archivedTotalBefore, dry }) {
-  const lines = body.split("\n").map(l => l.trimEnd()).filter(l => l.length > 0);
-  const backrefLines = lines.filter(isBackrefLine);
-  const other = lines.filter(l => !isBackrefLine(l) && !isSummaryLine(l));
-  if (backrefLines.length <= BACKREF_COMPACT_THRESHOLD) {
-    return { body, archivedLines: [], archivedIds: [], changed: false };
-  }
-  const archiveCount = backrefLines.length - BACKREF_KEEP_INLINE;
-  const archivedLines = backrefLines.slice(0, archiveCount);
-  const inlineLines = backrefLines.slice(archiveCount);
-  const archivedIds = archivedLines
-    .map(l => (l.match(/\(signal ([0-9a-f]{12})\)$/) || [])[1])
-    .filter(Boolean);
-  const archivedTotal = archivedTotalBefore + archivedLines.length;
-  const stamp = yyyyMm();
-  const summary = `- ${SUMMARY_MARKER} _${archivedTotal} older mention${archivedTotal === 1 ? "" : "s"} archived in [history](./${slug}.history/${stamp}.md)_`;
-  const nextBody = [summary, ...other, ...inlineLines].join("\n");
-  return { body: nextBody, archivedLines, archivedIds, changed: true, stamp };
-}
-
-function appendArchiveFile(file, isoDate, lines, dry) {
-  if (dry) return;
-  const batch = `\n<!-- archived ${isoDate} -->\n${lines.join("\n")}\n`;
-  const prev = fs.existsSync(file) ? fs.readFileSync(file, "utf8").replace(/\s+$/, "") : "";
-  const next = prev ? `${prev}\n${batch}` : `# Back-reference archive\n${batch}`;
-  fs.mkdirSync(path.dirname(file), { recursive: true });
-  const tmp = `${file}.tmp`;
-  fs.writeFileSync(tmp, next);
-  fs.renameSync(tmp, file);
-}
-
-function listCandidates(dir) {
-  if (!fs.existsSync(dir)) return [];
-  const out = [];
-  for (const d of fs.readdirSync(dir).sort()) {
-    if (d === "_done") continue;
-    const full = path.join(dir, d);
-    if (!fs.statSync(full).isDirectory()) continue;
-    for (const f of fs.readdirSync(full).sort()) if (f.endsWith(".md")) out.push(path.join(full, f));
-  }
-  return out;
-}
-
-function main() {
-  const a = parseArgs(process.argv.slice(2));
-  const backrefThreshold = Number(process.env.HQ_ONTOLOGY_BACKREF_THRESHOLD || 50);
-  const backrefKeepInline = Number(process.env.HQ_ONTOLOGY_BACKREF_KEEP_INLINE || 25);
-  if (!(backrefThreshold > backrefKeepInline)) {
-    console.error(`ontology-garden: BACKREF_THRESHOLD (${backrefThreshold}) must be greater than BACKREF_KEEP_INLINE (${backrefKeepInline})`);
-    process.exit(1);
-  }
-  const co = path.join(a.root, "companies", a.company);
-  if (!fs.existsSync(co)) { console.error(`ontology-garden: no company ${a.company}`); process.exit(2); }
-  const ont = path.join(co, "ontology"), sig = path.join(co, "signals");
-  const report = { company: a.company, entities_created: 0, entities_updated: 0, signals_promoted: 0,
-    facts_written: 0, rejected: 0, candidates_processed: 0, dry_run: a.dryRun };
-  const rejected = [];
-  const moves = [];
-
-  // Load the current entity index: slug -> {type, file, fm, names[]}
-  const entities = new Map();
-  const nameIndex = new Map(); // lowercased name/alias -> slug
-  const entDir = path.join(ont, "entities");
-  if (fs.existsSync(entDir)) for (const t of fs.readdirSync(entDir)) {
-    const td = path.join(entDir, t);
-    if (!fs.statSync(td).isDirectory()) continue;
-    for (const f of fs.readdirSync(td)) {
-      if (!f.endsWith(".md")) continue;
-      const file = path.join(td, f); const { fm } = readDoc(file);
-      const slug = fm.slug || f.replace(/\.md$/, "");
-      const names = [fm.canonical_name, ...(Array.isArray(fm.aliases) ? fm.aliases : [])].filter(Boolean);
-      entities.set(slug, { type: fm.type || t, file, fm, names });
-      for (const n of names) nameIndex.set(n.toLowerCase(), slug);
-    }
-  }
-
-  // 1. Entity candidates
-  for (const file of listCandidates(path.join(ont, "_candidates"))) {
-    const { fm, body } = readDoc(file);
-    const name = body.split("\n")[0].trim();
-    const type = fm.type;
-    const reject = reason => { rejected.push({ at: now(), name, type, reason, candidate: path.relative(co, file) }); report.rejected++; };
-    if (!ENTITY_TYPES.has(type)) reject("unknown-type");
-    else if (!name || STOPWORDS.has(name.toLowerCase()) || name.length < 2) reject("stopword");
-    else {
-      const slug = slugify(name);
-      const held = nameIndex.get(name.toLowerCase());
-      const existing = entities.get(held || slug);
-      if (existing && existing.type !== type) reject(`type-conflict:${existing.type}`);
-      else if (existing) {
-        const aliases = new Set(Array.isArray(existing.fm.aliases) ? existing.fm.aliases : []);
-        if (name !== existing.fm.canonical_name && !aliases.has(name)) {
-          aliases.add(name); existing.fm.aliases = [...aliases]; existing.fm.last_updated = now();
-          writeDoc(existing.file, existing.fm, "", a.dryRun); report.entities_updated++;
-          nameIndex.set(name.toLowerCase(), held || slug);
-        }
-      } else {
-        const efile = path.join(ont, "entities", type, `${slug}.md`);
-        const efm = { type, canonical_name: name, slug, aliases: [], signal_count: 0,
-          first_seen: fm.created_at || now(), last_updated: now(), enriched_by: "ontology-worker" };
-        writeDoc(efile, efm, "", a.dryRun);
-        entities.set(slug, { type, file: efile, fm: efm, names: [name] });
-        nameIndex.set(name.toLowerCase(), slug);
-        report.entities_created++;
-      }
-    }
-    moves.push(file); report.candidates_processed++;
-  }
-
-  // 2 + 3. Signal candidates -> signals + facts
-  const index = [];
-  for (const file of listCandidates(path.join(sig, "_candidates"))) {
-    const { fm, body } = readDoc(file);
-    const type = fm.type; const key = fm.audience_key;
-    moves.push(file); report.candidates_processed++;
-    if (!SIGNAL_TYPES.has(type) || !key || !body) {
-      rejected.push({ at: now(), type, reason: !key ? "missing-audience" : "invalid", candidate: path.relative(co, file) }); report.rejected++;
-      continue;
-    }
-    if (key !== "company" && !(Array.isArray(fm.audience) && fm.audience.length)) {
-      rejected.push({ at: now(), type, reason: "scoped-without-principals", candidate: path.relative(co, file) }); report.rejected++;
-      continue;
-    }
-    const id = path.basename(file, ".md");
-    const scopeDir = key === "company" ? sig : path.join(sig, `@${key}`);
-    const out = path.join(scopeDir, type, `${id}.md`);
-    if (!fs.existsSync(out)) {
-      writeDoc(out, { signal_id: id, type, canonical_content: JSON.stringify(body.split("\n")[0]), audience_key: key,
-        source_ref: JSON.stringify(fm.source_ref || ""), created_at: fm.created_at || now() }, body, a.dryRun);
-      report.signals_promoted++;
-      index.push({ signal_id: id, type, audience_key: key, path: path.relative(co, out) });
-      if (key !== "company") {
-        const audFile = path.join(scopeDir, "_audience.yaml");
-        if (!fs.existsSync(audFile) && !a.dryRun) {
-          fs.mkdirSync(scopeDir, { recursive: true });
-          fs.writeFileSync(audFile, `audience_key: ${key}\nprincipals: [${fm.audience.join(", ")}]\n`);
-        }
-      }
-      // Facts: every known entity named in the signal.
-      const lower = body.toLowerCase();
-      const hit = new Set();
-      for (const [n, slug] of nameIndex) {
-        if (n.length < 3) continue;
-        const re = new RegExp(`(^|[^\\p{L}\\p{N}])${n.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}($|[^\\p{L}\\p{N}])`, "u");
-        if (re.test(lower)) hit.add(slug);
-      }
-      for (const slug of hit) {
-        const e = entities.get(slug);
-        const ffile = path.join(ont, "facts", `@${key}`, e.type, `${slug}.md`);
-        const sid12 = id.slice(0, 12);
-        const line = `- [${type}] ${body.split("\n")[0]} (signal ${sid12})`;
-        const prev = fs.existsSync(ffile) ? readDoc(ffile) : { fm: { entity: slug, type: e.type, audience_key: key }, body: "" };
-        const idxFile = path.join(path.dirname(ffile), `${slug}.history`, "_index.json");
-        const archiveIndex = readArchiveIndex(idxFile);
-        const alreadyArchived = archiveIndex.signalIds.includes(sid12);
-        if (!prev.body.includes(`signal ${sid12}`) && !alreadyArchived) {
-          let nextBody = [prev.body, line].filter(Boolean).join("\n");
-          const compact = compactFactBody(nextBody, {
-            slug,
-            archivedTotalBefore: archiveIndex.signalIds.length,
-            dry: a.dryRun,
-          });
-          if (compact.changed && !archiveIndex.unreadable) {
-            const archiveFile = path.join(path.dirname(ffile), `${slug}.history`, `${compact.stamp}.md`);
-            appendArchiveFile(archiveFile, today(), compact.archivedLines, a.dryRun);
-            if (!a.dryRun) {
-              const nextIdx = { version: 1, signalIds: [...archiveIndex.signalIds, ...compact.archivedIds] };
-              fs.mkdirSync(path.dirname(idxFile), { recursive: true });
-              fs.writeFileSync(idxFile, JSON.stringify(nextIdx) + "\n");
-            }
-            nextBody = compact.body;
-          }
-          writeDoc(ffile, prev.fm, nextBody, a.dryRun);
-          report.facts_written++;
-        }
-        if (key === "company") {
-          e.fm.signal_count = String((parseInt(e.fm.signal_count || "0", 10) || 0) + 1);
-          e.fm.last_updated = now();
-          writeDoc(e.file, e.fm, "", a.dryRun);
-        }
-      }
-    }
-  }
-
-  if (!a.dryRun) {
-    if (index.length) {
-      const f = path.join(sig, "_index", `${today()}.json`);
-      const prev = fs.existsSync(f) ? JSON.parse(fs.readFileSync(f, "utf8")) : [];
-      fs.mkdirSync(path.dirname(f), { recursive: true });
-      fs.writeFileSync(f, JSON.stringify([...prev, ...index], null, 2) + "\n");
-    }
-    if (rejected.length) {
-      const f = path.join(ont, "_rejected", `${today()}.jsonl`);
-      fs.mkdirSync(path.dirname(f), { recursive: true });
-      fs.appendFileSync(f, rejected.map(r => JSON.stringify(r)).join("\n") + "\n");
-    }
-    for (const file of moves) {
-      const rel = path.relative(path.dirname(path.dirname(file)), file); // {date}/{sha}.md
-      const dest = path.join(path.dirname(path.dirname(file)), "_done", rel);
-      fs.mkdirSync(path.dirname(dest), { recursive: true });
-      fs.renameSync(file, dest);
-    }
-    if (report.candidates_processed > 0) {
-      fs.mkdirSync(ont, { recursive: true });
-      fs.writeFileSync(path.join(ont, ".last-run"), `${Date.now()}\n`);
-    }
-  }
-  if (a.json) console.log(JSON.stringify(report));
-  else console.log(`garden ${a.company}: +${report.entities_created} entities, ~${report.entities_updated} updated, +${report.signals_promoted} signals, +${report.facts_written} facts, ${report.rejected} rejected, ${report.candidates_processed} candidates${a.dryRun ? " (dry run)" : ""}`);
-}
-
-main();