@fenglimg/fabric-cli 2.2.0-rc.3 → 2.2.0-rc.8

package/dist/store-66NK2FTQ.js

@@ -1,443 +0,0 @@
-#!/usr/bin/env node
-import {
-  regenerateBindingsSnapshot
-} from "./chunk-H3FE6VIK.js";
-import "./chunk-EOT63RDH.js";
-import {
-  getProjectTranslator
-} from "./chunk-2CY4BMTH.js";
-import {
-  assertStoreMountable,
-  storeAdd,
-  storeBind,
-  storeCreate,
-  storeExplain,
-  storeGitRemote,
-  storeList,
-  storeRemove,
-  storeSwitchWrite
-} from "./chunk-5ZUMLCD5.js";
-import {
-  loadGlobalConfig
-} from "./chunk-XCBVSGCS.js";
-
-// src/commands/store.ts
-import { defineCommand } from "citty";
-
-// src/store/store-migrate.ts
-import { execFileSync } from "child_process";
-import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "fs";
-import { basename, join } from "path";
-import {
-  STORE_KNOWLEDGE_TYPE_DIRS,
-  STORE_LAYOUT,
-  STORE_PENDING_DIR,
-  buildStoreResolveInput,
-  createStoreResolver,
-  formatKnowledgeId,
-  parseKnowledgeId,
-  resolveGlobalRoot,
-  storeRelativePath
-} from "@fenglimg/fabric-shared";
-function resolveTargetStore(layer, projectRoot, globalRoot) {
-  const input = buildStoreResolveInput(projectRoot, globalRoot);
-  if (input === null) {
-    return null;
-  }
-  const scope = layer === "personal" ? "personal" : "team";
-  const { target } = createStoreResolver().resolveWriteTarget(input, scope);
-  if (target === null) {
-    return null;
-  }
-  const alias = loadGlobalConfig(globalRoot)?.stores.find((s) => s.store_uuid === target.store_uuid)?.alias ?? target.store_uuid;
-  return {
-    uuid: target.store_uuid,
-    alias,
-    dir: join(globalRoot, storeRelativePath(target.store_uuid))
-  };
-}
-function listMd(dir) {
-  if (!existsSync(dir)) {
-    return [];
-  }
-  return readdirSync(dir).filter((name) => name.endsWith(".md")).sort();
-}
-function readId(content) {
-  const match = content.match(/^id:\s*(\S+)\s*$/mu);
-  return match ? match[1] : null;
-}
-function slugSuffix(fileName, oldId) {
-  const stem = fileName.replace(/\.md$/u, "");
-  if (oldId !== null && stem.startsWith(`${oldId}--`)) {
-    return stem.slice(oldId.length);
-  }
-  return "";
-}
-function buildStoreIdIndex(storeDir) {
-  const existing = /* @__PURE__ */ new Set();
-  const maxCounter = /* @__PURE__ */ new Map();
-  for (const type of STORE_KNOWLEDGE_TYPE_DIRS) {
-    const dir = join(storeDir, STORE_LAYOUT.knowledgeDir, type);
-    for (const file of listMd(dir)) {
-      const content = readFileSync(join(dir, file), "utf8");
-      const id = readId(content) ?? file.replace(/\.md$/u, "").split("--")[0];
-      const parsed = parseKnowledgeId(id);
-      if (parsed === null) {
-        continue;
-      }
-      existing.add(id);
-      const key = id.slice(0, id.lastIndexOf("-"));
-      maxCounter.set(key, Math.max(maxCounter.get(key) ?? 0, parsed.counter));
-    }
-  }
-  return { existing, maxCounter };
-}
-function nextId(index, layer, type) {
-  const probe = formatKnowledgeId(layer, type, 1);
-  const key = probe.slice(0, probe.lastIndexOf("-"));
-  let counter = (index.maxCounter.get(key) ?? 0) + 1;
-  let id = formatKnowledgeId(layer, type, counter);
-  while (index.existing.has(id)) {
-    counter += 1;
-    id = formatKnowledgeId(layer, type, counter);
-  }
-  index.existing.add(id);
-  index.maxCounter.set(key, counter);
-  return id;
-}
-function typeDirToKnowledgeType(typeDir) {
-  return STORE_KNOWLEDGE_TYPE_DIRS.includes(typeDir) ? typeDir : null;
-}
-function migrateProjectKnowledge(projectRoot, options = {}) {
-  const dryRun = options.dryRun ?? false;
-  const globalRoot = options.globalRoot ?? resolveGlobalRoot();
-  const runGit = options.git ?? true;
-  const items = [];
-  const skips = [];
-  const remap = {};
-  const targets = {};
-  const sourceRoots = {
-    team: join(projectRoot, ".fabric", "knowledge"),
-    personal: join(globalRoot, "knowledge")
-  };
-  const layerState = {};
-  for (const layer of ["team", "personal"]) {
-    if (!existsSync(sourceRoots[layer])) {
-      continue;
-    }
-    const target = resolveTargetStore(layer, projectRoot, globalRoot);
-    if (target === null) {
-      continue;
-    }
-    targets[layer] = { uuid: target.uuid, dir: target.dir };
-    layerState[layer] = { target, index: buildStoreIdIndex(target.dir) };
-  }
-  for (const layer of ["team", "personal"]) {
-    const root = sourceRoots[layer];
-    if (!existsSync(root)) {
-      continue;
-    }
-    const state = layerState[layer];
-    for (const typeDir of STORE_KNOWLEDGE_TYPE_DIRS) {
-      const dir = join(root, typeDir);
-      for (const file of listMd(dir)) {
-        const source = join(dir, file);
-        if (state === void 0) {
-          skips.push({
-            source,
-            reason: `no ${layer} write-target store \u2014 run \`fabric install --global\` then \`fabric store bind <alias>\`${layer === "team" ? " + `fabric store switch-write <alias>`" : ""}`
-          });
-          continue;
-        }
-        const content = readFileSync(source, "utf8");
-        const oldId = readId(content);
-        const knowledgeType = typeDirToKnowledgeType(typeDir);
-        let newId = null;
-        if (oldId !== null && state.index.existing.has(oldId) && knowledgeType !== null) {
-          const parsed = parseKnowledgeId(oldId);
-          const idLayer = parsed?.layer ?? layer;
-          newId = nextId(state.index, idLayer, knowledgeType);
-          remap[oldId] = newId;
-        } else if (oldId !== null) {
-          state.index.existing.add(oldId);
-          const parsed = parseKnowledgeId(oldId);
-          if (parsed !== null) {
-            const key = oldId.slice(0, oldId.lastIndexOf("-"));
-            state.index.maxCounter.set(
-              key,
-              Math.max(state.index.maxCounter.get(key) ?? 0, parsed.counter)
-            );
-          }
-        }
-        const effectiveId = newId ?? oldId;
-        const targetName = newId !== null && effectiveId !== null ? `${effectiveId}${slugSuffix(file, oldId)}.md` : file;
-        const targetFile = join(state.target.dir, STORE_LAYOUT.knowledgeDir, typeDir, targetName);
-        items.push({
-          source,
-          layer,
-          type: typeDir,
-          oldId,
-          newId,
-          target: targetFile,
-          storeUuid: state.target.uuid,
-          alias: state.target.alias
-        });
-      }
-    }
-    const pendingRoot = join(root, STORE_PENDING_DIR);
-    for (const sub of [".", "decisions", "guidelines", "pitfalls", "models", "processes"]) {
-      const dir = sub === "." ? pendingRoot : join(pendingRoot, sub);
-      for (const file of listMd(dir)) {
-        const source = join(dir, file);
-        if (state === void 0) {
-          skips.push({ source, reason: `no ${layer} write-target store` });
-          continue;
-        }
-        const rel = sub === "." ? file : join(sub, file);
-        const targetFile = join(
-          state.target.dir,
-          STORE_LAYOUT.knowledgeDir,
-          STORE_PENDING_DIR,
-          rel
-        );
-        if (existsSync(targetFile)) {
-          skips.push({ source, reason: `pending already present in store: ${basename(targetFile)}` });
-          continue;
-        }
-        items.push({
-          source,
-          layer,
-          type: STORE_PENDING_DIR,
-          oldId: null,
-          newId: null,
-          target: targetFile,
-          storeUuid: state.target.uuid,
-          alias: state.target.alias
-        });
-      }
-    }
-  }
-  if (dryRun || items.length === 0) {
-    return { dryRun, committed: false, items, skips, remap, targets };
-  }
-  for (const item of items) {
-    let content = readFileSync(item.source, "utf8");
-    if (item.newId !== null && item.oldId !== null) {
-      content = content.replace(/^id:\s*\S+\s*$/mu, `id: ${item.newId}`);
-    }
-    content = rewriteRelated(content, remap);
-    mkdirSync(join(item.target, ".."), { recursive: true });
-    writeFileSync(item.target, content, "utf8");
-  }
-  for (const item of items) {
-    rmSync(item.source, { force: true });
-  }
-  let committed = false;
-  if (runGit) {
-    for (const [layer, info] of Object.entries(targets)) {
-      const moved = items.filter((i) => i.layer === layer).length;
-      if (moved === 0) {
-        continue;
-      }
-      committed = gitCommitStore(info.dir, moved) || committed;
-    }
-  }
-  return { dryRun, committed, items, skips, remap, targets };
-}
-function rewriteRelated(content, remap) {
-  if (Object.keys(remap).length === 0) {
-    return content;
-  }
-  return content.replace(/^related:\s*\[(.*)\]\s*$/mu, (line, inner) => {
-    const rewritten = inner.split(",").map((token) => {
-      const trimmed = token.trim();
-      return remap[trimmed] ?? trimmed;
-    }).join(", ");
-    return `related: [${rewritten}]`;
-  });
-}
-function gitCommitStore(storeDir, count) {
-  if (!existsSync(join(storeDir, ".git"))) {
-    return false;
-  }
-  try {
-    execFileSync("git", ["add", "-A"], { cwd: storeDir, stdio: ["ignore", "ignore", "pipe"] });
-    execFileSync(
-      "git",
-      ["commit", "-m", `chore(migrate): import ${count} entries from project dual-root`],
-      { cwd: storeDir, stdio: ["ignore", "ignore", "pipe"] }
-    );
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// src/commands/store.ts
-var listCommand = defineCommand({
-  meta: { name: "list", description: "List mounted knowledge stores" },
-  run() {
-    const t = getProjectTranslator();
-    const stores = storeList();
-    if (stores.length === 0) {
-      console.log(t("cli.store.none-mounted"));
-      return;
-    }
-    const localOnly = t("cli.shared.local-only");
-    for (const store of stores) {
-      const realRemote = storeGitRemote(store.store_uuid);
-      console.log(`${store.alias}	${store.store_uuid}	${realRemote ?? localOnly}`);
-    }
-  }
-});
-var addCommand = defineCommand({
-  meta: { name: "add", description: "Mount a knowledge store into the global registry" },
-  args: {
-    uuid: { type: "string", required: true, description: "Intrinsic store UUID" },
-    alias: { type: "string", required: true, description: "Local alias for this store" },
-    remote: { type: "string", description: "Git remote locator (omit for local-only)" }
-  },
-  run({ args }) {
-    assertStoreMountable(args.uuid);
-    const store = args.remote === void 0 ? { store_uuid: args.uuid, alias: args.alias } : { store_uuid: args.uuid, alias: args.alias, remote: args.remote };
-    const next = storeAdd(store);
-    const t = getProjectTranslator();
-    console.log(
-      t("cli.store.mounted", {
-        alias: args.alias,
-        count: String(next.stores.length)
-      })
-    );
-  }
-});
-var createCommand = defineCommand({
-  meta: { name: "create", description: "Create a brand-new local knowledge store and mount it" },
-  args: {
-    alias: { type: "string", required: true, description: "Local alias for the new store" },
-    remote: { type: "string", description: "Git remote to associate (push target; optional)" }
-  },
-  run({ args }) {
-    const result = storeCreate(args.alias, (/* @__PURE__ */ new Date()).toISOString(), {
-      ...args.remote === void 0 ? {} : { remote: args.remote }
-    });
-    const t = getProjectTranslator();
-    console.log(
-      t("cli.store.created", { alias: args.alias, uuid: result.store_uuid, dir: result.storeDir }) + (args.remote === void 0 ? `
-${t("cli.store.created-local-hint")}` : "")
-    );
-  }
-});
-var removeCommand = defineCommand({
-  meta: { name: "remove", description: "Detach a store from the registry (does NOT delete it)" },
-  args: {
-    alias: { type: "positional", required: true, description: "Alias to detach" }
-  },
-  run({ args }) {
-    const { detached } = storeRemove(args.alias);
-    const t = getProjectTranslator();
-    console.log(
-      detached === null ? t("cli.store.no-alias", { alias: args.alias }) : t("cli.store.detached", { alias: args.alias })
-    );
-  }
-});
-var explainCommand = defineCommand({
-  meta: { name: "explain", description: "Explain how a store alias resolves" },
-  args: {
-    alias: { type: "positional", required: true, description: "Alias to explain" }
-  },
-  run({ args }) {
-    const explanation = storeExplain(args.alias);
-    console.log(
-      explanation === null ? getProjectTranslator()("cli.store.no-alias", { alias: args.alias }) : JSON.stringify(explanation, null, 2)
-    );
-  }
-});
-var bindCommand = defineCommand({
-  meta: { name: "bind", description: "Declare a required store on this project's config" },
-  args: {
-    id: { type: "positional", required: true, description: "Store alias/UUID to require" },
-    remote: { type: "string", description: "Suggested remote for clone onboarding" }
-  },
-  run({ args }) {
-    const entry = args.remote === void 0 ? { id: args.id } : { id: args.id, suggested_remote: args.remote };
-    const projectRoot = process.cwd();
-    const next = storeBind(projectRoot, entry);
-    console.log(
-      getProjectTranslator(projectRoot)("cli.store.bound", {
-        id: args.id,
-        count: String(next.required_stores?.length ?? 0)
-      })
-    );
-    regenerateBindingsSnapshot(projectRoot, { now: (/* @__PURE__ */ new Date()).toISOString() });
-  }
-});
-var switchWriteCommand = defineCommand({
-  meta: { name: "switch-write", description: "Set the active write store for non-personal scopes" },
-  args: {
-    alias: { type: "positional", required: true, description: "Alias of the store to write to" }
-  },
-  run({ args }) {
-    const projectRoot = process.cwd();
-    storeSwitchWrite(projectRoot, args.alias);
-    console.log(getProjectTranslator(projectRoot)("cli.store.switch-write", { alias: args.alias }));
-  }
-});
-var migrateCommand = defineCommand({
-  meta: {
-    name: "migrate",
-    description: "Move project-local (dual-root) knowledge into the resolved write-target stores"
-  },
-  args: {
-    "dry-run": {
-      type: "boolean",
-      description: "Preview the move without writing anything"
-    }
-  },
-  run({ args }) {
-    const projectRoot = process.cwd();
-    const t = getProjectTranslator(projectRoot);
-    const dryRun = args["dry-run"] === true;
-    const report = migrateProjectKnowledge(projectRoot, { dryRun });
-    if (report.items.length === 0 && report.skips.length === 0) {
-      console.log(t("cli.store.migrate.none"));
-      return;
-    }
-    console.log(
-      dryRun ? t("cli.store.migrate.dry-run-header") : t("cli.store.migrate.applied-header", { count: String(report.items.length) })
-    );
-    for (const item of report.items) {
-      const id = item.newId ?? item.oldId ?? "(draft)";
-      console.log(`  ${item.layer}/${item.type}  ${id}  \u2192  ${item.alias}`);
-      if (item.newId !== null && item.oldId !== null) {
-        console.log(
-          t("cli.store.migrate.remap-note", { oldId: item.oldId, newId: item.newId })
-        );
-      }
-    }
-    if (report.skips.length > 0) {
-      console.log(t("cli.store.migrate.skips-header", { count: String(report.skips.length) }));
-      for (const skip of report.skips) {
-        console.log(`  ${skip.source}: ${skip.reason}`);
-      }
-    }
-    if (report.committed) {
-      console.log(t("cli.store.migrate.committed"));
-    }
-  }
-});
-var store_default = defineCommand({
-  meta: { name: "store", description: "Manage mounted Fabric knowledge stores" },
-  subCommands: {
-    list: listCommand,
-    create: createCommand,
-    add: addCommand,
-    remove: removeCommand,
-    explain: explainCommand,
-    bind: bindCommand,
-    "switch-write": switchWriteCommand,
-    migrate: migrateCommand
-  }
-});
-export {
-  store_default as default
-};

package/templates/hooks/configs/cursor-hooks.json

@@ -1,30 +0,0 @@
-{
-  "version": 1,
-  "hooks": {
-    "stop": [
-      { "command": ".cursor/hooks/fabric-hint.cjs" }
-    ],
-    "sessionStart": [
-      { "command": ".cursor/hooks/knowledge-hint-broad.cjs" }
-    ],
-    "preToolUse": [
-      {
-        "matcher": "Edit|Write|MultiEdit",
-        "command": ".cursor/hooks/knowledge-hint-narrow.cjs"
-      },
-      {
-        "matcher": "Edit|Write|MultiEdit",
-        "command": ".cursor/hooks/cite-policy-evict.cjs"
-      }
-    ],
-    "postToolUse": [
-      {
-        "matcher": "Edit|Write|MultiEdit",
-        "command": ".cursor/hooks/post-tooluse-mutation.cjs"
-      }
-    ],
-    "sessionEnd": [
-      { "command": ".cursor/hooks/session-end-marker.cjs" }
-    ]
-  }
-}

package/templates/hooks/lib/cite-contract-reminder.cjs

@@ -1,179 +0,0 @@
-// v2.0.0-rc.24 TASK-05: L1 Stop hook soft reminder for missing cite contract.
-//
-// Reads `.fabric/agents.meta.json` to build a stable_id → knowledge_type lookup
-// map, then scans summarised assistant turns (cite_ids + cite_tags +
-// cite_commitments parallel arrays produced by lib/cite-line-parser.cjs) for
-// turns that cited a decision-class or pitfall-class id with [applied] tag
-// but no operator commitment and no skip:<reason>. (v2.1.0-rc.1 ADJ-P4-1:
-// legacy [recalled] is remapped to [applied] by the parser upstream.)
-//
-// Emits one reminder line per offending id (deduplicated across the turn
-// summary). Non-blocking — caller writes the lines to stderr; failure to
-// load the meta file or absence of offenders means zero output.
-//
-// Reminder template (rc.24 lock B2 / L1 enforcement layer):
-//   ⚠ KB: <id> cited as [applied] but missing contract; add → edit:<glob>
-//     or → skip:<reason> next turn
-//
-// Type filter rationale: only `decision` and `pitfall` types are contract-
-// required per rc.24 design lock B6 (idTypeMap routing). `model`,
-// `guideline`, `process` use reference-cite or LLM-judge (deferred to rc.25+)
-// and are intentionally skipped here to avoid false-positive nudges.
-//
-// agents.meta.json schema note: `description.knowledge_type` values are
-// SINGULAR (`decision`, `pitfall`, `model`, `guideline`, `process`) per
-// packages/shared/src/schemas/agents-meta.ts. The reminder filter normalises
-// any plural input defensively but the canonical contract is singular.
-//
-// Reading happens once per hook invocation (caller passes the projectRoot;
-// the lib does the fs read internally). The map is small (<200 entries in
-// typical corpora) so caching beyond the per-invocation scope is unnecessary.
-
-const { existsSync, readFileSync } = require("node:fs");
-const { join } = require("node:path");
-
-const FABRIC_DIR = ".fabric";
-const AGENTS_META_FILE = "agents.meta.json";
-
-// Knowledge types that require contract commitments on [applied] cites.
-// Matches the singular form persisted by `withDerivedAgentsMetaNodeDefaults`
-// in packages/shared/src/schemas/agents-meta.ts. We accept both singular
-// and plural defensively so a future schema change to plurals doesn't
-// silently break the filter.
-const CONTRACT_REQUIRED_TYPES = new Set([
-  "decision",
-  "decisions",
-  "pitfall",
-  "pitfalls",
-]);
-
-/**
- * Build a Map<stable_id, knowledge_type> from <projectRoot>/.fabric/agents.meta.json.
- *
- * Never throws — missing file, malformed JSON, missing nodes key, etc. all
- * yield an empty Map. The caller's downstream filter then becomes a no-op
- * (no id resolves → no reminders).
- *
- * @param {string} projectRoot - workspace root
- * @returns {Map<string, string>} stable_id → knowledge_type (singular)
- */
-function readKnowledgeTypeMap(projectRoot) {
-  const out = new Map();
-  if (typeof projectRoot !== "string" || projectRoot.length === 0) return out;
-
-  const metaPath = join(projectRoot, FABRIC_DIR, AGENTS_META_FILE);
-  if (!existsSync(metaPath)) return out;
-
-  let raw;
-  try {
-    raw = readFileSync(metaPath, "utf8");
-  } catch {
-    return out;
-  }
-
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    return out;
-  }
-
-  if (parsed === null || typeof parsed !== "object") return out;
-  const nodes = parsed.nodes;
-  if (nodes === null || typeof nodes !== "object") return out;
-
-  for (const [id, node] of Object.entries(nodes)) {
-    if (node === null || typeof node !== "object") continue;
-    const description = node.description;
-    if (description === null || typeof description !== "object") continue;
-    const kt = description.knowledge_type;
-    if (typeof kt !== "string" || kt.length === 0) continue;
-    out.set(id, kt);
-  }
-
-  return out;
-}
-
-/**
- * Scan parsed assistant turns for cites that should have a contract but
- * don't, returning the reminder lines to emit.
- *
- * Filter (all must hold for a given index i within a turn):
- *   1. cite_tags includes "applied" (turn-level — applies to the cited id)
- *   2. cite_commitments[i].operators is empty AND cite_commitments[i].skip_reason is null
- *   3. idTypeMap.get(cite_ids[i]) is in {decision, pitfall}
- *
- * v2.1.0-rc.1 (ADJ-P4-1, full remap): the gate is the rc.37 NEW-1 `applied`
- * tag. Legacy [recalled] cites are remapped to [applied] by the parser before
- * they reach here, so gating on "applied" covers both old and new authoring.
- *
- * Tag-level filter clarification: rc.20 cite_tags is parallel to ALL parsed
- * lines (including sentinels), but for the contract-missing reminder we use
- * the turn-level semantic — if the assistant tagged the cite as [applied],
- * the operator-or-skip contract applies. Per TASK-04 invariant, cite_ids and
- * cite_commitments are parallel index-aligned arrays (length-N each).
- *
- * Sentinel turns (cite_ids=[], cite_tags=["none"]) contribute no offenders
- * because the cite_ids loop has zero iterations.
- *
- * Offenders are deduplicated by id across the entire turn array; multiple
- * turns citing the same id yield ONE reminder line.
- *
- * @param {Object} args
- * @param {Array<{cite_ids: string[], cite_tags: string[], cite_commitments: Array<{operators: Array<unknown>, skip_reason: string|null}>}>} args.assistant_turns
- * @param {Map<string, string>} args.idTypeMap
- * @returns {string[]} reminder lines (empty when no offenders)
- */
-function formatContractMissingReminders({ assistant_turns, idTypeMap }) {
-  if (!Array.isArray(assistant_turns) || assistant_turns.length === 0) return [];
-  if (!(idTypeMap instanceof Map) || idTypeMap.size === 0) return [];
-
-  const offenders = new Set();
-
-  for (const turn of assistant_turns) {
-    if (turn === null || typeof turn !== "object") continue;
-    const citeIds = Array.isArray(turn.cite_ids) ? turn.cite_ids : [];
-    const citeTags = Array.isArray(turn.cite_tags) ? turn.cite_tags : [];
-    const commitments = Array.isArray(turn.cite_commitments) ? turn.cite_commitments : [];
-
-    // Turn-level: the [applied] tag must appear in the turn's tag set
-    // (v2.1.0-rc.1 ADJ-P4-1: legacy [recalled] is remapped to [applied]).
-    if (!citeTags.includes("applied")) continue;
-
-    // Iterate by cite_ids.length — sentinel entries don't have ids so they
-    // contribute zero iterations even if cite_tags carries "none".
-    for (let i = 0; i < citeIds.length; i += 1) {
-      const id = citeIds[i];
-      if (typeof id !== "string" || id.length === 0) continue;
-
-      const type = idTypeMap.get(id);
-      if (!CONTRACT_REQUIRED_TYPES.has(type)) continue;
-
-      const commitment = commitments[i];
-      if (commitment === null || typeof commitment !== "object") continue;
-      const operators = Array.isArray(commitment.operators) ? commitment.operators : [];
-      const skipReason = commitment.skip_reason;
-      const hasContract = operators.length > 0 || (typeof skipReason === "string" && skipReason.length > 0);
-      if (hasContract) continue;
-
-      offenders.add(id);
-    }
-  }
-
-  if (offenders.size === 0) return [];
-
-  // Stable order: insertion order is the order ids first appeared across turns.
-  const reminders = [];
-  for (const id of offenders) {
-    reminders.push(
-      `⚠ KB: ${id} cited as [applied] but missing contract; add \`→ edit:<glob>\` or \`→ skip:<reason>\` next turn`,
-    );
-  }
-  return reminders;
-}
-
-module.exports = {
-  readKnowledgeTypeMap,
-  formatContractMissingReminders,
-  CONTRACT_REQUIRED_TYPES,
-};