@fenglimg/fabric-cli 2.0.1 → 2.1.0-rc.2

package/dist/sync-BJCWDPNC.js

@@ -0,0 +1,245 @@
+#!/usr/bin/env node
+import {
+  regenerateBindingsSnapshot
+} from "./chunk-WU6GAPKH.js";
+import "./chunk-L4Q55UC4.js";
+import "./chunk-LFIKMVY7.js";
+import {
+  loadGlobalConfig,
+  resolveGlobalRoot
+} from "./chunk-RYAFBNES.js";
+
+// src/commands/sync.ts
+import { defineCommand } from "citty";
+
+// src/sync/run-sync.ts
+import { execFileSync } from "child_process";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { join } from "path";
+import { GLOBAL_STATE_DIR, storeRelativePath } from "@fenglimg/fabric-shared";
+
+// src/sync/state-machine.ts
+function syncTransition(state, event) {
+  switch (state) {
+    case "pending":
+      if (event === "rebase_clean") return "synced";
+      if (event === "rebase_conflict") return "conflict";
+      if (event === "network_unavailable") return "offline";
+      break;
+    case "conflict":
+      if (event === "user_continue") return "synced";
+      if (event === "user_abort") return "aborted";
+      break;
+    case "offline":
+      if (event === "retry" || event === "rebase_clean") return "synced";
+      if (event === "rebase_conflict") return "conflict";
+      if (event === "network_unavailable") return "offline";
+      break;
+    case "synced":
+    case "aborted":
+      break;
+  }
+  throw new Error(`invalid sync transition: '${state}' --${event}-->`);
+}
+function planSync(stores) {
+  return { stores: stores.map((s) => ({ ...s, state: "pending" })) };
+}
+function applySyncEvent(session, alias, event) {
+  return {
+    stores: session.stores.map(
+      (s) => s.alias === alias ? { ...s, state: syncTransition(s.state, event) } : s
+    )
+  };
+}
+function continueSync(session) {
+  const conflicted = session.stores.find((s) => s.state === "conflict");
+  if (conflicted === void 0) {
+    throw new Error("`sync --continue` with no conflicted store to resume");
+  }
+  return applySyncEvent(session, conflicted.alias, "user_continue");
+}
+function abortSync(session) {
+  const conflicted = session.stores.find((s) => s.state === "conflict");
+  if (conflicted === void 0) {
+    throw new Error("`sync --abort` with no conflicted store to abort");
+  }
+  return applySyncEvent(session, conflicted.alias, "user_abort");
+}
+function isSyncSettled(session) {
+  return session.stores.every((s) => s.state !== "pending" && s.state !== "conflict");
+}
+function deferredPushStores(session) {
+  return session.stores.filter((s) => s.state === "offline");
+}
+
+// src/sync/run-sync.ts
+var NO_GLOBAL_CONFIG = "no global Fabric config \u2014 run `fabric install --global <url>` first";
+var NO_SESSION = "no sync in progress \u2014 run `fabric sync` first";
+var NO_CONFLICT = "no conflicted store to resume \u2014 sync is not paused";
+function syncSessionPath(globalRoot) {
+  return join(globalRoot, GLOBAL_STATE_DIR, "sync-session.json");
+}
+function loadSession(globalRoot) {
+  const path = syncSessionPath(globalRoot);
+  if (!existsSync(path)) {
+    return null;
+  }
+  return JSON.parse(readFileSync(path, "utf8"));
+}
+function saveSession(globalRoot, session) {
+  const path = syncSessionPath(globalRoot);
+  mkdirSync(join(path, ".."), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(session, null, 2)}
+`, "utf8");
+}
+function clearSession(globalRoot) {
+  rmSync(syncSessionPath(globalRoot), { force: true });
+}
+function defaultPull(storeDir) {
+  try {
+    execFileSync("git", ["pull", "--rebase"], {
+      cwd: storeDir,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    return "clean";
+  } catch (error) {
+    const detail = `${gitErrText(error, "stdout")}${gitErrText(error, "stderr")}`;
+    if (/CONFLICT|could not apply|needs merge|rebase --continue/i.test(detail)) {
+      return "conflict";
+    }
+    if (/could not resolve host|could not read from remote|unable to access|connection|network is unreachable|timed out/i.test(
+      detail
+    )) {
+      return "offline";
+    }
+    throw error;
+  }
+}
+function gitErrText(error, key) {
+  const value = error[key];
+  return typeof value === "string" || Buffer.isBuffer(value) ? String(value) : "";
+}
+function defaultRebaseContinue(storeDir) {
+  execFileSync("git", ["rebase", "--continue"], { cwd: storeDir, stdio: "ignore" });
+}
+function defaultRebaseAbort(storeDir) {
+  execFileSync("git", ["rebase", "--abort"], { cwd: storeDir, stdio: "ignore" });
+}
+var OUTCOME_EVENT = {
+  clean: "rebase_clean",
+  conflict: "rebase_conflict",
+  offline: "network_unavailable"
+};
+function walkPending(session, storeDirOf, pull) {
+  let next = session;
+  for (const store of session.stores) {
+    if (store.state !== "pending") {
+      continue;
+    }
+    const outcome = pull(storeDirOf(store));
+    next = applySyncEvent(next, store.alias, OUTCOME_EVENT[outcome]);
+    if (outcome === "conflict") {
+      break;
+    }
+  }
+  return next;
+}
+function finalize(session, options, globalRoot) {
+  const settled = isSyncSettled(session);
+  let snapshotWritten = false;
+  if (settled) {
+    clearSession(globalRoot);
+    const snapshot = regenerateBindingsSnapshot(options.projectRoot, {
+      globalRoot,
+      now: options.now,
+      ...options.writeScope === void 0 ? {} : { writeScope: options.writeScope }
+    });
+    snapshotWritten = snapshot !== null;
+  } else {
+    saveSession(globalRoot, session);
+  }
+  return { session, settled, deferred: deferredPushStores(session), snapshotWritten };
+}
+function runStartSync(options) {
+  const globalRoot = options.globalRoot ?? resolveGlobalRoot();
+  const config = loadGlobalConfig(globalRoot);
+  if (config === null) {
+    throw new Error(NO_GLOBAL_CONFIG);
+  }
+  const syncable = config.stores.filter((store) => store.remote !== void 0);
+  const session = planSync(
+    syncable.map((store) => ({ alias: store.alias, store_uuid: store.store_uuid }))
+  );
+  const storeDirOf = (status) => join(globalRoot, storeRelativePath(status.store_uuid));
+  const walked = walkPending(session, storeDirOf, options.pull ?? defaultPull);
+  return finalize(walked, options, globalRoot);
+}
+function runContinueSync(options) {
+  const globalRoot = options.globalRoot ?? resolveGlobalRoot();
+  const session = loadSession(globalRoot);
+  if (session === null) {
+    throw new Error(NO_SESSION);
+  }
+  const conflicted = session.stores.find((store) => store.state === "conflict");
+  if (conflicted === void 0) {
+    throw new Error(NO_CONFLICT);
+  }
+  const storeDirOf = (status) => join(globalRoot, storeRelativePath(status.store_uuid));
+  (options.rebaseContinue ?? defaultRebaseContinue)(storeDirOf(conflicted));
+  const resumed = walkPending(continueSync(session), storeDirOf, options.pull ?? defaultPull);
+  return finalize(resumed, options, globalRoot);
+}
+function runAbortSync(options) {
+  const globalRoot = options.globalRoot ?? resolveGlobalRoot();
+  const session = loadSession(globalRoot);
+  if (session === null) {
+    throw new Error(NO_SESSION);
+  }
+  const conflicted = session.stores.find((store) => store.state === "conflict");
+  if (conflicted === void 0) {
+    throw new Error(NO_CONFLICT);
+  }
+  const storeDirOf = (status) => join(globalRoot, storeRelativePath(status.store_uuid));
+  (options.rebaseAbort ?? defaultRebaseAbort)(storeDirOf(conflicted));
+  const resumed = walkPending(abortSync(session), storeDirOf, options.pull ?? defaultPull);
+  return finalize(resumed, options, globalRoot);
+}
+
+// src/commands/sync.ts
+function report(result) {
+  for (const store of result.session.stores) {
+    console.log(`${store.alias}	${store.state}`);
+  }
+  if (result.deferred.length > 0) {
+    console.log(
+      `${result.deferred.length} store(s) offline \u2014 push deferred; re-run \`fabric sync\` when online`
+    );
+  }
+  if (!result.settled) {
+    console.log(
+      "sync paused on a conflict \u2014 resolve it, then run `fabric sync --continue` (or `--abort`)"
+    );
+  }
+}
+var sync_default = defineCommand({
+  meta: { name: "sync", description: "Pull --rebase + push every mounted store; resume conflicts" },
+  args: {
+    continue: { type: "boolean", description: "Resume after resolving a rebase conflict" },
+    abort: { type: "boolean", description: "Abort the conflicted store's rebase" }
+  },
+  run({ args }) {
+    const options = { projectRoot: process.cwd(), now: (/* @__PURE__ */ new Date()).toISOString() };
+    if (args.continue === true) {
+      report(runContinueSync(options));
+      return;
+    }
+    if (args.abort === true) {
+      report(runAbortSync(options));
+      return;
+    }
+    report(runStartSync(options));
+  }
+});
+export {
+  sync_default as default
+};

package/dist/{uninstall-MH7ZIB6M.js → uninstall-TAXSUSKH.js}

@@ -7,11 +7,7 @@ import {
   HOOK_SCRIPT_DESTINATIONS,
   SKILL_DESTINATIONS,
   fabricAgentsSnapshotPath
-} from "./chunk-D25XJ4BC.js";
-import {
-  detectClientSupports,
-  resolveClients
-} from "./chunk-MF3OTILQ.js";
+} from "./chunk-F46ORPOA.js";
 import {
   paint
 } from "./chunk-WWNXR34K.js";
@@ -19,6 +15,10 @@ import {
   createDebugLogger,
   resolveDevMode
 } from "./chunk-COI5VDFU.js";
+import {
+  detectClientSupports,
+  resolveClients
+} from "./chunk-MF3OTILQ.js";
 import {
   t
 } from "./chunk-PWLW3B57.js";
@@ -46,6 +46,9 @@ async function uninstallFabricReviewSkill(projectRoot) {
 async function uninstallFabricImportSkill(projectRoot) {
   return removeSkill("skill-import", SKILL_DESTINATIONS.fabricImport, projectRoot);
 }
+async function uninstallFabricSyncSkill(projectRoot) {
+  return removeSkill("skill-sync", SKILL_DESTINATIONS.fabricSync, projectRoot);
+}
 async function removeSkill(step, rels, projectRoot) {
   const results = [];
   for (const rel of rels) {
@@ -301,6 +304,12 @@ async function uninstallBootstrapStage(projectRoot, _opts = {}) {
     projectRoot,
     () => removeArchiveHintHook(projectRoot)
   );
+  await runAndCollect(
+    results,
+    "skill-sync",
+    projectRoot,
+    () => uninstallFabricSyncSkill(projectRoot)
+  );
   await runAndCollect(
     results,
     "skill-import",

package/dist/whoami-B6AEMSEV.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+import {
+  whoami
+} from "./chunk-T5RPGCCM.js";
+import "./chunk-LFIKMVY7.js";
+import "./chunk-RYAFBNES.js";
+
+// src/commands/whoami.ts
+import { defineCommand } from "citty";
+var whoami_default = defineCommand({
+  meta: { name: "whoami", description: "Show this machine's Fabric uid and mounted stores" },
+  run() {
+    const info = whoami();
+    if (info === null) {
+      console.log("no global Fabric config \u2014 run `fabric install --global <url>` first");
+      return;
+    }
+    console.log(`uid: ${info.uid}`);
+    if (info.stores.length === 0) {
+      console.log("stores: (none mounted)");
+      return;
+    }
+    console.log("stores:");
+    for (const store of info.stores) {
+      console.log(`  ${store.alias}	${store.store_uuid}${store.local_only ? "	(local-only)" : ""}`);
+    }
+  }
+});
+export {
+  whoami_default as default
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fenglimg/fabric-cli",
-  "version": "2.0.1",
+  "version": "2.1.0-rc.2",
   "description": "Fabric CLI — installs the MCP server + skills + hooks for Claude Code, Cursor, and Codex CLI; runs doctor / knowledge maintenance.",
   "license": "MIT",
   "author": "wangzhichao <fenglimg90@gmail.com>",
@@ -45,8 +45,8 @@
     "tree-sitter-javascript": "^0.25.0",
     "tree-sitter-typescript": "^0.23.2",
     "web-tree-sitter": "^0.26.8",
-    "@fenglimg/fabric-server": "2.0.1",
-    "@fenglimg/fabric-shared": "2.0.1"
+    "@fenglimg/fabric-server": "2.1.0-rc.2",
+    "@fenglimg/fabric-shared": "2.1.0-rc.2"
   },
   "devDependencies": {
     "@types/node": "^22.15.0",

package/templates/hooks/fabric-hint.cjs

@@ -81,6 +81,27 @@ try {
   stateStore = null;
 }
 
+// v2.1.0-rc.1 P4 (F4/S63): hook-side reader for the CLI pre-generated
+// resolved-bindings snapshot. The Stop hint surfaces the read-set stores
+// (per-store, NOT aggregated into one pile) without re-resolving / walking
+// store trees. Best-effort — a missing lib/snapshot omits the store line.
+let bindingsSnapshotReader = null;
+try {
+  bindingsSnapshotReader = require("./lib/bindings-snapshot-reader.cjs");
+} catch {
+  bindingsSnapshotReader = null;
+}
+
+// Read the project's own `project_id` (the snapshot key) from its config.
+function readProjectId(cwd) {
+  try {
+    const parsed = JSON.parse(readFileSync(join(cwd, ".fabric", "fabric-config.json"), "utf8"));
+    return typeof parsed.project_id === "string" ? parsed.project_id : null;
+  } catch {
+    return null;
+  }
+}
+
 // CONSTANTS — duplicated from packages/server/src/services/_shared.ts.
 // DRY violation accepted: this hook script runs in user repos WITHOUT
 // node_modules access, so it cannot import from @fenglimg/fabric-server.
@@ -1907,6 +1928,25 @@ function main(env, stdio) {
       result.reason = `${result.reason}\n${renderDismissOption(result.signal, variant)}`;
     }
 
+    // v2.1.0-rc.1 P4 (F4/S63): surface the read-set stores on the Stop hint so
+    // backlog/maintenance nudges are read per-store, not as one undifferentiated
+    // pile. Best-effort; missing snapshot / single-store omits the line.
+    if (bindingsSnapshotReader !== null && typeof result.reason === "string") {
+      try {
+        const projectId = readProjectId(cwd);
+        if (projectId) {
+          const label = bindingsSnapshotReader.formatStoreLabels(
+            bindingsSnapshotReader.readBindingsSnapshot(projectId),
+          );
+          if (label) {
+            result.reason = `${result.reason}\n${label}`;
+          }
+        }
+      } catch {
+        // store label is decorative provenance — never crash the hook
+      }
+    }
+
     // v2.0.0-rc.7 T10: Signal D uses its own cooldown sidecar (day-based,
     // see MAINTENANCE_HINT_LAST_EMIT_FILE). The A/B/C shared cooldown cache
     // uses hours, so we branch here to avoid mixing semantics.

package/templates/hooks/knowledge-hint-broad.cjs

@@ -68,6 +68,28 @@ const { readTextState, writeTextState } = require("./lib/state-store.cjs");
 // v2.0.0-rc.37 NEW-30: shared client detection (replaces the inline
 // CLAUDE_PROJECT_DIR single-bit check below).
 const { isClaudeCode } = require("./lib/client-adapter.cjs");
+// v2.1.0-rc.1 P4 (F4/S63): hook-side reader for the CLI pre-generated
+// resolved-bindings snapshot. The hook NEVER re-resolves stores or walks store
+// trees — it only echoes the read-set the CLI already computed. Best-effort.
+let bindingsSnapshotReader = null;
+try {
+  bindingsSnapshotReader = require("./lib/bindings-snapshot-reader.cjs");
+} catch {
+  // Lib missing (old install) — store labels degrade to silent absence.
+}
+
+// Read the project's own `project_id` from `.fabric/fabric-config.json` (the
+// snapshot key). Reading the PROJECT config is not a store-tree read — it is how
+// the hook learns which snapshot to fetch. Returns null on any failure.
+function readProjectId(cwd) {
+  try {
+    const raw = readFileSync(join(cwd, ".fabric", "fabric-config.json"), "utf8");
+    const parsed = JSON.parse(raw);
+    return typeof parsed.project_id === "string" ? parsed.project_id : null;
+  } catch {
+    return null;
+  }
+}
 
 // -----------------------------------------------------------------------------
 // rc.12: SessionStart broad-menu is now unconditionally emitted on every
@@ -735,6 +757,24 @@ function main(env, stdio) {
 
     if (lines.length === 0) return; // nothing to say — silent exit
 
+    // v2.1.0-rc.1 P4 (F4/S63): append a per-store read-set label from the
+    // CLI-pre-generated bindings snapshot so the session opens aware of which
+    // stores it reads and where writes land. Best-effort, never blocks: a
+    // missing snapshot / single-store setup just omits the line.
+    if (bindingsSnapshotReader !== null) {
+      try {
+        const projectId = readProjectId(cwd);
+        if (projectId) {
+          const label = bindingsSnapshotReader.formatStoreLabels(
+            bindingsSnapshotReader.readBindingsSnapshot(projectId),
+          );
+          if (label) lines.push(label);
+        }
+      } catch {
+        // store labels are decorative provenance — never crash the hook
+      }
+    }
+
     // v2.0.0-rc.37 NEW-23: SessionStart 索引末尾"下一步"引导。Tail line that
     // tells the AI what to do with the broad index it just received. Without
     // this, the model often parses the index and moves on without ever calling

package/templates/hooks/knowledge-hint-narrow.cjs

@@ -85,6 +85,26 @@ const { resolveOpaqueSummaries } = require("./lib/summary-fallback.cjs");
 // cache (skips a redundant CLI cold-start spawn when the same path-set is
 // re-edited within a session and the knowledge graph hasn't changed).
 const { readJsonState, writeJsonState } = require("./lib/state-store.cjs");
+// v2.1.0-rc.1 P4 (F4/S63): hook-side reader for the CLI pre-generated
+// resolved-bindings snapshot. Store-aware hint surfaces the write-target store
+// for the edited file WITHOUT re-resolving or walking store trees. Best-effort.
+let bindingsSnapshotReader = null;
+try {
+  bindingsSnapshotReader = require("./lib/bindings-snapshot-reader.cjs");
+} catch {
+  // Lib missing (old install) — store labels degrade to silent absence.
+}
+
+// Read the project's own `project_id` (the snapshot key) from its config. Not a
+// store-tree read — it is how the hook learns which snapshot to fetch.
+function readProjectId(cwd) {
+  try {
+    const parsed = JSON.parse(readFileSync(join(cwd, ".fabric", "fabric-config.json"), "utf8"));
+    return typeof parsed.project_id === "string" ? parsed.project_id : null;
+  } catch {
+    return null;
+  }
+}
 
 // -----------------------------------------------------------------------------
 // CONSTANTS
@@ -1466,6 +1486,25 @@ function main(env, stdio) {
     const lines = renderSummary({ ...cliPayload, entries: resolvedEntries }, summaryMaxLen);
     if (lines.length === 0) return;
 
+    // v2.1.0-rc.1 P4 (F4/S63): store-aware hint — append the write-target store
+    // so the edit-time hint says WHERE a derived knowledge entry would land.
+    // Best-effort; missing snapshot / single-store setup omits the line.
+    if (bindingsSnapshotReader !== null) {
+      try {
+        const projectId = readProjectId(cwd);
+        if (projectId) {
+          const snapshot = bindingsSnapshotReader.readBindingsSnapshot(projectId);
+          const writeAlias =
+            snapshot && snapshot.write_target && snapshot.write_target.alias;
+          if (writeAlias) {
+            lines.push(`[fabric] writes here land in store '${writeAlias}'`);
+          }
+        }
+      } catch {
+        // store label is decorative provenance — never crash the hook
+      }
+    }
+
     // Stderr: human-facing breadcrumb + legacy contract.
     for (const line of lines) {
       err.write(`${line}\n`);

package/templates/hooks/lib/bindings-snapshot-reader.cjs

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+// v2.1.0-rc.1 P4 — hook-side resolved-bindings snapshot reader (F4/S63/S65).
+//
+// Hooks are a REMINDER layer (KT-DEC-0007) and must never block. They are also
+// FORBIDDEN from re-resolving stores or walking `.fabric` store trees directly
+// — a hook reads ONLY the CLI-pre-generated snapshot at
+// `~/.fabric/state/bindings/<project_id>_resolved.json` (written by P3
+// install/sync/bind). This keeps the resolver logic in one place (the CLI) and
+// keeps hooks a thin, store-unaware-by-construction projection. Missing /
+// unreadable / malformed snapshot → null (harmless degrade; the hook proceeds
+// without store labels). Zero-dep CJS so it inline-loads at hook runtime.
+
+const { existsSync, readFileSync } = require("node:fs");
+const { join } = require("node:path");
+const { homedir } = require("node:os");
+
+// `~/.fabric` (FABRIC_HOME override mirrors the CLI's resolveGlobalRoot).
+function resolveGlobalRoot() {
+  return join(process.env.FABRIC_HOME || homedir(), ".fabric");
+}
+
+function bindingsSnapshotPath(projectId, globalRoot) {
+  return join(
+    globalRoot || resolveGlobalRoot(),
+    "state",
+    "bindings",
+    projectId + "_resolved.json",
+  );
+}
+
+// Read + shallow-validate the snapshot. Returns the parsed object, or null when
+// absent / unreadable / not the expected shape. NEVER throws.
+function readBindingsSnapshot(projectId, globalRoot) {
+  if (typeof projectId !== "string" || projectId.length === 0) {
+    return null;
+  }
+  const path = bindingsSnapshotPath(projectId, globalRoot);
+  if (!existsSync(path)) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (
+      parsed &&
+      typeof parsed === "object" &&
+      parsed.read_set &&
+      Array.isArray(parsed.read_set.stores)
+    ) {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+// Render a compact, per-store label line for a SessionStart / Stop hook from a
+// snapshot. Empty string when there is nothing to show (degrade silently). The
+// label is provenance only — it never re-resolves; it just echoes the read-set
+// the CLI already computed, with the write-target flagged (F4 store labels).
+function formatStoreLabels(snapshot) {
+  if (!snapshot || !snapshot.read_set || !Array.isArray(snapshot.read_set.stores)) {
+    return "";
+  }
+  const writeAlias = snapshot.write_target && snapshot.write_target.alias;
+  const parts = snapshot.read_set.stores.map((store) => {
+    const tag = store.alias === writeAlias ? " (write)" : store.writable ? "" : " (ro)";
+    return store.alias + tag;
+  });
+  if (parts.length === 0) {
+    return "";
+  }
+  return "[fabric] read-set stores: " + parts.join(", ");
+}
+
+module.exports = {
+  resolveGlobalRoot,
+  bindingsSnapshotPath,
+  readBindingsSnapshot,
+  formatStoreLabels,
+};

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

@@ -3,15 +3,16 @@
 // 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 [recalled] tag
-// but no operator commitment and no skip:<reason>.
+// 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 [recalled] but missing contract; add → edit:<glob>
+//   ⚠ 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-
@@ -34,7 +35,7 @@ const { join } = require("node:path");
 const FABRIC_DIR = ".fabric";
 const AGENTS_META_FILE = "agents.meta.json";
 
-// Knowledge types that require contract commitments on [recalled] cites.
+// 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
@@ -98,13 +99,17 @@ function readKnowledgeTypeMap(projectRoot) {
  * don't, returning the reminder lines to emit.
  *
  * Filter (all must hold for a given index i within a turn):
- *   1. cite_tags includes "recalled" (turn-level — applies to the cited id)
+ *   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 [recalled],
+ * 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).
  *
@@ -131,8 +136,9 @@ function formatContractMissingReminders({ assistant_turns, idTypeMap }) {
     const citeTags = Array.isArray(turn.cite_tags) ? turn.cite_tags : [];
     const commitments = Array.isArray(turn.cite_commitments) ? turn.cite_commitments : [];
 
-    // Turn-level: the [recalled] tag must appear in the turn's tag set.
-    if (!citeTags.includes("recalled")) continue;
+    // 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".
@@ -160,7 +166,7 @@ function formatContractMissingReminders({ assistant_turns, idTypeMap }) {
   const reminders = [];
   for (const id of offenders) {
     reminders.push(
-      `⚠ KB: ${id} cited as [recalled] but missing contract; add \`→ edit:<glob>\` or \`→ skip:<reason>\` next turn`,
+      `⚠ KB: ${id} cited as [applied] but missing contract; add \`→ edit:<glob>\` or \`→ skip:<reason>\` next turn`,
     );
   }
   return reminders;