@fenglimg/fabric-cli 2.1.0-rc.2 → 2.2.0-rc.10

package/templates/hooks/fabric-hint.cjs

@@ -1,7 +1,13 @@
 #!/usr/bin/env node
-const { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } = require("node:fs");
+const { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } = require("node:fs");
 const { dirname, join } = require("node:path");
 
+// W1-01 (ISS-012): Stop / SessionStart hooks append to shared, non-session-scoped
+// ledgers (events.jsonl, metrics.jsonl). Under multi-window concurrency a bare
+// appendFileSync can interleave a partial write; route through the advisory-lock
+// primitive (drop-on-contention, best-effort — matches injection-log).
+const { appendLockedLine } = require("./lib/injection-log.cjs");
+
 // v2.0.0-rc.7 T5: session-digest writer. Best-effort (never blocks Stop hook
 // on failure — see contract in lib/session-digest-writer.cjs).
 let sessionDigestWriter = null;
@@ -38,23 +44,6 @@ try {
   citeLineParser = null;
 }
 
-// v2.0.0-rc.24 TASK-05: L1 enforcement layer — soft Stop hook reminder for
-// [recalled] cites of decision/pitfall types that arrived without operator
-// contract or skip:<reason>. Reads .fabric/agents.meta.json (via
-// lib/cite-contract-reminder.cjs#readKnowledgeTypeMap) to type-route cite
-// ids per B6 lock; emits one
-//   ⚠ KB: <id> cited as [recalled] but missing contract; add → edit:<glob>
-//     or → skip:<reason> next turn
-// line to stderr per offending id. Non-blocking, never throws.
-let citeContractReminder = null;
-try {
-  citeContractReminder = require("./lib/cite-contract-reminder.cjs");
-} catch {
-  // Helper module missing — soft reminder simply doesn't fire. Audit-side
-  // doctor (TASK-08) still catches contract violations at the next run.
-  citeContractReminder = null;
-}
-
 // v2.0.0-rc.37 NEW-30: shared client-protocol adapter. Guarded require (this
 // hook runs in arbitrary user repos); detectClient delegates the 3-tier
 // detection to the lib, falling back to env-only when the lib is absent.
@@ -65,6 +54,17 @@ try {
   clientAdapter = null;
 }
 
+// v2.2 dual-sink (Goal A / D4): human-output gate for the archive nudge. The Stop
+// archive nudge is SOFT (additionalContext, never decision:block — D3) and the
+// human systemMessage is gated by nudge_mode. Optional require — absent → human
+// always emits (legacy posture).
+let nudgePolicy = null;
+try {
+  nudgePolicy = require("./lib/nudge-policy.cjs");
+} catch {
+  nudgePolicy = null;
+}
+
 // v2.0.0-rc.37 NEW-16: shared config + sidecar I/O for the per-signal dismiss
 // feature (config-level durable opt-out + session-scoped sidecar). Guarded
 // require (house style); dismiss simply doesn't fire if the lib is absent.
@@ -92,16 +92,115 @@ try {
   bindingsSnapshotReader = null;
 }
 
-// Read the project's own `project_id` (the snapshot key) from its config.
-function readProjectId(cwd) {
+// Read the workspace binding id (snapshot key) from project config. Standard
+// repos default to project_id; worktrees can set workspace_binding_id to isolate
+// hook/runtime state without changing project identity.
+function readWorkspaceBindingId(cwd) {
   try {
     const parsed = JSON.parse(readFileSync(join(cwd, ".fabric", "fabric-config.json"), "utf8"));
+    if (typeof parsed.workspace_binding_id === "string") return parsed.workspace_binding_id;
     return typeof parsed.project_id === "string" ? parsed.project_id : null;
   } catch {
     return null;
   }
 }
 
+function readSnapshotKnowledgeStats(projectRoot, now) {
+  const nowMs = now instanceof Date ? now.getTime() : Number(now) || Date.now();
+  const empty = { pendingCount: 0, oldestPendingAgeMs: null, canonicalCount: 0 };
+  if (bindingsSnapshotReader === null) {
+    return null;
+  }
+  const bindingId = readWorkspaceBindingId(projectRoot);
+  if (bindingId === null) {
+    return null;
+  }
+  try {
+    const snapshot = bindingsSnapshotReader.readBindingsSnapshot(bindingId);
+    // No snapshot file → empty corpus (KT-DEC-0007), preserving prior behavior.
+    if (!snapshot) {
+      return empty;
+    }
+    // LIVE recount off the snapshot's resolved store dirs. The cached
+    // knowledge_stats projection is frozen at snapshot-write time, so once the
+    // pending queue is reviewed (or store content syncs out-of-band) it goes
+    // stale — that is the phantom review-backlog this hook used to report
+    // (KT-PIT-0017). The authoritative count is the live *.md walk under the
+    // resolved store dirs.
+    const live = bindingsSnapshotReader.liveKnowledgeStats(snapshot);
+    // #3: a snapshot predating knowledge_store_dirs makes liveKnowledgeStats
+    // return null — counts are undeterminable and the cached projection is
+    // unreliable. Return `undefined` (a marker distinct from the `null` that
+    // lib/binding-absent returns, which readPendingStats uses as its legacy-
+    // fallback signal) so countCanonicalNodes maps it to "unknown" and the
+    // underseed signal SKIPS rather than false-firing on a stale corpus (snapshot
+    // self-heals on the next install/sync). Distinguished from the missing-
+    // snapshot case above, which stays `empty` (genuine fresh-project zero).
+    if (live === null) {
+      return undefined;
+    }
+    const pendingCount =
+      Number.isFinite(live.pendingCount) && live.pendingCount > 0 ? Math.floor(live.pendingCount) : 0;
+    const canonicalCount =
+      Number.isFinite(live.canonicalCount) && live.canonicalCount > 0
+        ? Math.floor(live.canonicalCount)
+        : 0;
+    const oldestPendingAgeMs =
+      pendingCount > 0 &&
+      Number.isFinite(live.oldestPendingMtimeMs) &&
+      live.oldestPendingMtimeMs > 0
+        ? Math.max(0, nowMs - live.oldestPendingMtimeMs)
+        : null;
+    return { pendingCount, oldestPendingAgeMs, canonicalCount };
+  } catch {
+    return empty;
+  }
+}
+
+function readLegacyPendingStats(projectRoot, now) {
+  const nowMs = now instanceof Date ? now.getTime() : Number(now) || Date.now();
+  const baseDir = join(projectRoot, FABRIC_DIR, PENDING_DIR);
+
+  let count = 0;
+  let oldestMtime = null;
+
+  if (!existsSync(baseDir)) {
+    return { count: 0, oldestAgeMs: null };
+  }
+
+  for (const type of PENDING_TYPES) {
+    const typeDir = join(baseDir, type);
+    if (!existsSync(typeDir)) continue;
+
+    let entries;
+    try {
+      entries = readdirSync(typeDir);
+    } catch {
+      continue;
+    }
+
+    for (const entry of entries) {
+      if (!entry.endsWith(".md")) continue;
+      const filePath = join(typeDir, entry);
+      let mtime;
+      try {
+        mtime = statSync(filePath).mtimeMs;
+      } catch {
+        continue;
+      }
+      count += 1;
+      if (oldestMtime === null || mtime < oldestMtime) {
+        oldestMtime = mtime;
+      }
+    }
+  }
+
+  return {
+    count,
+    oldestAgeMs: count > 0 && oldestMtime !== null ? nowMs - oldestMtime : 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.
@@ -119,6 +218,59 @@ const EVENT_LEDGER_FILE = "events.jsonl";
 const METRICS_LEDGER_FILE = "metrics.jsonl";
 const EVENT_TYPE_PROPOSED = "knowledge_proposed";
 const EVENT_TYPE_INIT_SCAN_COMPLETED = "init_scan_completed";
+
+// v2.2 dual-sink (Goal A / D6): deterministic high-value probe for the archive
+// nudge value-gate. Mirrors packages/server/src/services/archive-scan.ts
+// (hasHighValueSignal) — the hook replicates the SAME deterministic ledger probe
+// rather than running the semantic archive-scan, staying within the Hook⊥MCP
+// boundary (the hook reads events.jsonl mechanically; it never judges relevance).
+// Keep these two literal sets in sync with archive-scan.ts.
+const ARCHIVE_HIGH_VALUE_EVENT_TYPES = new Set([
+  "knowledge_context_planned",
+  "edit_paths_recorded",
+  "edit_intent_checked",
+]);
+const ARCHIVE_NORMATIVE_KEYWORDS = [
+  "以后",
+  "always",
+  "never",
+  "from now on",
+  "下次",
+  "记一下",
+  "永远不要",
+];
+
+// v2.2 dual-sink (Goal A / D6): does the ledger carry a high-value archive signal
+// since the watermark (last knowledge_proposed)? True iff any HIGH_VALUE event
+// fired past the watermark, OR the latest assistant_turn carries a normative
+// keyword. Deterministic — no semantic judgement. Used to VALUE-GATE the archive
+// nudge so the check cadence (edits/hours) is decoupled from the nudge cadence
+// (D6): a workspace that crossed the edit threshold but produced no high-value
+// signal stays quiet. watermarkTs null (never archived) → treat all events as
+// past-watermark (a never-archived repo with any edit signal is worth nudging).
+function hasHighValueArchiveSignal(events, watermarkTs) {
+  if (!Array.isArray(events)) return false;
+  const wm = typeof watermarkTs === "number" ? watermarkTs : 0;
+  let latestTurn = null;
+  for (const e of events) {
+    if (!e || typeof e.ts !== "number" || e.ts <= wm) continue;
+    if (typeof e.event_type === "string" && ARCHIVE_HIGH_VALUE_EVENT_TYPES.has(e.event_type)) {
+      return true;
+    }
+    if (e.event_type === "assistant_turn_observed") {
+      if (latestTurn === null || (typeof latestTurn.ts === "number" && e.ts > latestTurn.ts)) {
+        latestTurn = e;
+      }
+    }
+  }
+  if (latestTurn !== null) {
+    const haystack = JSON.stringify(latestTurn).toLowerCase();
+    for (const kw of ARCHIVE_NORMATIVE_KEYWORDS) {
+      if (haystack.includes(kw.toLowerCase())) return true;
+    }
+  }
+  return false;
+}
 // v2.0.0-rc.7 T10: doctor_run event drives Signal D (maintenance hint).
 const EVENT_TYPE_DOCTOR_RUN = "doctor_run";
 // v2.0.0-rc.20 TASK-03: per-turn cite-policy observation event. Emitted by
@@ -261,92 +413,40 @@ function readLedger(projectRoot) {
 }
 
 /**
- * Walk <projectRoot>/.fabric/knowledge/pending/<type>/*.md across all
- * PENDING_TYPES subdirs, collecting count and oldest mtime.
+ * Read pending counts from the CLI-generated resolved-bindings snapshot.
  *
  * Returns { count, oldestAgeMs } where:
  *   - count: total .md file count across all type subdirs
  *   - oldestAgeMs: (nowMs - oldestMtimeMs) when count>0, else null
  *
- * ENOENT / unreadable subdir / unstat-able file → silently skipped
- * (preserves the hook's never-block-on-failure invariant).
+ * Store-only cutover: hooks never walk project-local knowledge or store
+ * trees. Missing snapshot stats degrade to zero (KT-DEC-0007).
  */
 function readPendingStats(projectRoot, now) {
-  const nowMs = now instanceof Date ? now.getTime() : Number(now) || Date.now();
-  const baseDir = join(projectRoot, FABRIC_DIR, PENDING_DIR);
-
-  let count = 0;
-  let oldestMtime = null;
-
-  if (!existsSync(baseDir)) {
-    return { count: 0, oldestAgeMs: null };
+  const stats = readSnapshotKnowledgeStats(projectRoot, now);
+  // `!= null` (loose) also catches the `undefined` old-snapshot marker (#3) →
+  // fall through to the legacy reader (which degrades to 0 → no phantom review
+  // nudge), rather than dereferencing pendingCount on a non-object.
+  if (stats != null) {
+    return { count: stats.pendingCount, oldestAgeMs: stats.oldestPendingAgeMs };
   }
-
-  for (const type of PENDING_TYPES) {
-    const typeDir = join(baseDir, type);
-    if (!existsSync(typeDir)) continue;
-
-    let entries;
-    try {
-      entries = readdirSync(typeDir);
-    } catch {
-      continue;
-    }
-
-    for (const entry of entries) {
-      if (!entry.endsWith(".md")) continue;
-      const filePath = join(typeDir, entry);
-      let mtime;
-      try {
-        mtime = statSync(filePath).mtimeMs;
-      } catch {
-        continue;
-      }
-      count += 1;
-      if (oldestMtime === null || mtime < oldestMtime) {
-        oldestMtime = mtime;
-      }
-    }
-  }
-
-  return {
-    count,
-    oldestAgeMs: count > 0 && oldestMtime !== null ? nowMs - oldestMtime : null,
-  };
+  return readLegacyPendingStats(projectRoot, now);
 }
 
 /**
- * Count canonical knowledge entries across the five canonical type subdirs
- * (decisions / pitfalls / guidelines / models / processes). Pending entries
- * are NOT counted — they are proposals, not seeded knowledge.
- *
- * Returns the integer count. ENOENT / unreadable subdir → silently treated as
- * zero (preserves never-block-on-failure invariant). Filters on `.md` suffix
- * only; the more-precise canonical filename pattern check is owned by
- * doctor.ts (the hook is a coarse signal, not a lint).
+ * Count canonical knowledge entries from the CLI-generated resolved-bindings
+ * snapshot. Store-only: hooks never walk project-local knowledge or store
+ * trees — a missing snapshot degrades to zero (KT-DEC-0007).
  */
 function countCanonicalNodes(projectRoot) {
-  const knowledgeRoot = join(projectRoot, FABRIC_DIR, "knowledge");
-  if (!existsSync(knowledgeRoot)) {
-    return 0;
-  }
-  let count = 0;
-  for (const type of KNOWLEDGE_CANONICAL_TYPES) {
-    const typeDir = join(knowledgeRoot, type);
-    if (!existsSync(typeDir)) continue;
-    let entries;
-    try {
-      entries = readdirSync(typeDir);
-    } catch {
-      continue;
-    }
-    for (const entry of entries) {
-      if (entry.endsWith(".md")) {
-        count += 1;
-      }
-    }
-  }
-  return count;
+  const stats = readSnapshotKnowledgeStats(projectRoot);
+  // #3: `undefined` = snapshot EXISTS but predates knowledge_store_dirs →
+  // undeterminable → return null so decide()'s underseed signal SKIPS rather than
+  // false-firing on a stale corpus. `null` = no reader / not bound → degrade to 0
+  // (KT-DEC-0007, preserved). The `empty` object (missing snapshot) → canonical 0,
+  // still firing correctly for a genuinely fresh corpus.
+  if (stats === undefined) return null;
+  return stats === null ? 0 : stats.canonicalCount;
 }
 
 /**
@@ -405,6 +505,81 @@ function countEditsSince(projectRoot, anchorTs) {
   return count;
 }
 
+// ---------------------------------------------------------------------------
+// Observability grill (a + Q4): session-activity status breadcrumb.
+//
+// A no-signal Stop used to return SILENT — the human only ever heard from
+// Fabric when there was a nudge to act on, never a "here is what I did" recap,
+// which reads as "Fabric does nothing in the background". These two helpers add
+// a HUMAN-ONLY trust anchor (the AI gets no activity recap — flow ⊥ observation,
+// D5) plus the nudge_mode tier-guidance line (so the human-channel volume knob
+// is discoverable). Cadence is gated by nudge_mode at emit time.
+// ---------------------------------------------------------------------------
+
+// Session-scoped tally. Counts ONLY events that carry session_id, filtered to
+// the current session — knowledge_context_planned / knowledge_proposed lack
+// session_id and are intentionally excluded (a cross-session count would
+// mislead). Exported for unit tests.
+function tallySessionActivity(events, sessionId) {
+  let edits = 0;
+  let consumed = 0;
+  if (!Array.isArray(events) || typeof sessionId !== "string" || sessionId.length === 0) {
+    return { edits, consumed };
+  }
+  for (const ev of events) {
+    if (!ev || ev.session_id !== sessionId) continue;
+    if (ev.event_type === "file_mutated") edits += 1;
+    else if (ev.event_type === "knowledge_consumed") consumed += 1;
+  }
+  return { edits, consumed };
+}
+
+// Emit the human-facing session status breadcrumb when no actionable signal
+// fired. Human sink ONLY. Cadence by nudge_mode: silent → never; minimal/normal
+// → once per session; verbose → every turn. Folds in the tier-guidance line on
+// the first status of the session so the volume knob is discoverable. Never
+// throws — the caller wraps it, but every branch degrades silently anyway.
+function emitSessionStatus(cwd, events, stdinPayload, nowMs, pendingStats, out) {
+  if (nudgePolicy === null || clientAdapter === null) return;
+  if (typeof clientAdapter.emitDualSink !== "function") return;
+  const sessionId = resolveHookSessionId(stdinPayload);
+  if (typeof sessionId !== "string" || sessionId.length === 0) return;
+
+  const mode =
+    typeof nudgePolicy.readNudgeMode === "function" ? nudgePolicy.readNudgeMode(cwd) : "normal";
+  if (mode === "silent") return; // human channel globally muted
+
+  const tally = tallySessionActivity(events, sessionId);
+  const pending = pendingStats && typeof pendingStats.total === "number" ? pendingStats.total : 0;
+  // Nothing happened yet this session AND no backlog → no trust anchor to show.
+  if (tally.edits === 0 && tally.consumed === 0 && pending === 0) return;
+
+  // Cadence gate: normal/minimal show once per session; verbose every turn.
+  const cache = readShownCache(cwd, sessionId);
+  const firstThisSession = cache._status === undefined;
+  if (mode !== "verbose" && !firstThisSession) return;
+
+  const variant = readFabricLanguage(cwd);
+  const line1 = renderBanner("statusLine", variant, {
+    edits: tally.edits,
+    consumed: tally.consumed,
+    pending,
+  });
+  // Tier guidance only on the first status of the session (don't repeat it on
+  // every verbose turn).
+  const human = firstThisSession
+    ? `${line1}\n${renderBanner("statusTier", variant, { mode })}`
+    : line1;
+
+  clientAdapter.emitDualSink(
+    { human, ai: null },
+    { client: clientAdapter.detectClient(__dirname), eventName: "Stop", streams: { stdout: out } },
+  );
+
+  cache._status = nowMs;
+  writeShownCache(cwd, cache, sessionId);
+}
+
 /**
  * v2.0.0-rc.8 (TASK-002): detect whether a fabric-import skill run is
  * currently in flight, used to gate Signal B (review hint) so the Stop
@@ -783,6 +958,11 @@ function decide(events, now, pendingStats, underseedStats, editCounterStats, thr
       reason,
       signal: "archive",
       recommended_skill: "fabric-archive",
+      // v2.1 NEW-N-3: surface the firing sub-signal's numbers for the
+      // hook_signal_emitted ledger row main() writes. Dual trigger (24h OR
+      // N-edits): report the hours pair when it fired, else the edit-count pair.
+      threshold: triggerByHours ? archiveHintHours : editStats.threshold,
+      actual_value: triggerByHours ? hoursElapsed : editStats.editsSinceLastProposed,
     };
   }
 
@@ -819,6 +999,10 @@ function decide(events, now, pendingStats, underseedStats, editCounterStats, thr
       reason,
       signal: "review",
       recommended_skill: "fabric-review",
+      // v2.1 NEW-N-3: dual trigger (pending-count OR oldest-age). Report the
+      // count pair when it fired, else the oldest-age-in-days pair.
+      threshold: triggerByPendingCount ? reviewHintPendingCount : reviewHintPendingAgeDays,
+      actual_value: triggerByPendingCount ? stats.count : stats.oldestAgeMs / MS_PER_DAY,
     };
   }
 
@@ -847,6 +1031,10 @@ function decide(events, now, pendingStats, underseedStats, editCounterStats, thr
     lastInitScanTs === null ? null : (nowMs - lastInitScanTs) / MS_PER_HOUR;
   const hoursSinceProposed = hoursElapsed; // reuse archive-signal calc above
   const triggerUnderseed =
+    // #3: null = undeterminable canonical count (old snapshot) → skip. Guard
+    // first because `null < threshold` coerces to true in JS and would else
+    // false-fire the underseed nudge on a stale corpus.
+    underseed.nodeCount != null &&
     underseed.nodeCount < underseed.threshold &&
     hoursSinceInit !== null &&
     hoursSinceInit >= UNDERSEED_POST_INIT_QUIET_HOURS &&
@@ -869,6 +1057,10 @@ function decide(events, now, pendingStats, underseedStats, editCounterStats, thr
       reason,
       signal: "import",
       recommended_skill: "fabric-import",
+      // v2.1 NEW-N-3: underseed corpus trigger — node-count vs threshold. The
+      // "import" signal collapses to schema signal_type "other" in main().
+      threshold: underseed.threshold,
+      actual_value: underseed.nodeCount,
     };
   }
 
@@ -965,8 +1157,34 @@ function readUnderseedThreshold(projectRoot) {
   return DEFAULT_UNDERSEED_NODE_THRESHOLD;
 }
 
-function readShownCache(projectRoot) {
-  const cachePath = join(projectRoot, SHOWN_CACHE_FILE);
+// F13 (ISS-20260531-038): the reminder cooldown sidecars were process-global
+// (one file per project, no session key), so in concurrent multi-window sessions
+// one window firing a nudge wrote the cooldown and silenced that nudge in EVERY
+// other window. Scope the sidecar filename by sessionId — mirrors the already-
+// session-scoped dismiss sidecar (sessionDismissFileName). Backward-compatible:
+// a null/absent sessionId falls back to the legacy non-scoped path (upgrade +
+// pre-session-id callers), so existing on-disk state and tests are unaffected;
+// the Stop hook always passes the real session_id from its stdin payload.
+function resolveHookSessionId(payload) {
+  return payload && typeof payload.session_id === "string" && payload.session_id.length > 0
+    ? payload.session_id
+    : null;
+}
+
+function sessionScopedCacheFile(baseRelPath, sessionId) {
+  if (sessionId === undefined || sessionId === null || String(sessionId).length === 0) {
+    return baseRelPath;
+  }
+  const safe = String(sessionId).replace(/[^A-Za-z0-9_.-]/g, "-");
+  const lastSlash = baseRelPath.lastIndexOf("/");
+  const dot = baseRelPath.lastIndexOf(".");
+  return dot > lastSlash
+    ? `${baseRelPath.slice(0, dot)}-${safe}${baseRelPath.slice(dot)}`
+    : `${baseRelPath}-${safe}`;
+}
+
+function readShownCache(projectRoot, sessionId) {
+  const cachePath = join(projectRoot, sessionScopedCacheFile(SHOWN_CACHE_FILE, sessionId));
   if (!existsSync(cachePath)) return {};
   try {
     const parsed = JSON.parse(readFileSync(cachePath, "utf8"));
@@ -976,11 +1194,17 @@ function readShownCache(projectRoot) {
   }
 }
 
-function writeShownCache(projectRoot, cache) {
-  const cachePath = join(projectRoot, SHOWN_CACHE_FILE);
+function writeShownCache(projectRoot, cache, sessionId) {
+  const cachePath = join(projectRoot, sessionScopedCacheFile(SHOWN_CACHE_FILE, sessionId));
   try {
-    mkdirSync(dirname(cachePath), { recursive: true });
-    writeFileSync(cachePath, JSON.stringify(cache));
+    // ISS-016: atomic tmp+rename so a crash never leaves a truncated shown-cache.
+    // Falls back to a plain write only if the shared lib failed to load.
+    if (stateStore && typeof stateStore.atomicWrite === "function") {
+      stateStore.atomicWrite(cachePath, JSON.stringify(cache));
+    } else {
+      mkdirSync(dirname(cachePath), { recursive: true });
+      writeFileSync(cachePath, JSON.stringify(cache));
+    }
   } catch {
     // Silent — cache failure must never block the hook.
   }
@@ -1098,8 +1322,8 @@ function findLastDoctorRunTs(events) {
  * v2.0.0-rc.7 T10: read the Signal-D cooldown sidecar timestamp (epoch ms).
  * Missing file / parse failure → null (allow signal to fire).
  */
-function readMaintenanceLastEmit(projectRoot) {
-  const p = join(projectRoot, MAINTENANCE_HINT_LAST_EMIT_FILE);
+function readMaintenanceLastEmit(projectRoot, sessionId) {
+  const p = join(projectRoot, sessionScopedCacheFile(MAINTENANCE_HINT_LAST_EMIT_FILE, sessionId));
   if (!existsSync(p)) return null;
   try {
     const raw = readFileSync(p, "utf8").trim();
@@ -1114,11 +1338,16 @@ function readMaintenanceLastEmit(projectRoot) {
   return null;
 }
 
-function writeMaintenanceLastEmit(projectRoot, nowMs) {
-  const p = join(projectRoot, MAINTENANCE_HINT_LAST_EMIT_FILE);
+function writeMaintenanceLastEmit(projectRoot, nowMs, sessionId) {
+  const p = join(projectRoot, sessionScopedCacheFile(MAINTENANCE_HINT_LAST_EMIT_FILE, sessionId));
   try {
-    mkdirSync(dirname(p), { recursive: true });
-    writeFileSync(p, new Date(nowMs).toISOString());
+    // ISS-016: atomic tmp+rename (see writeShownCache).
+    if (stateStore && typeof stateStore.atomicWrite === "function") {
+      stateStore.atomicWrite(p, new Date(nowMs).toISOString());
+    } else {
+      mkdirSync(dirname(p), { recursive: true });
+      writeFileSync(p, new Date(nowMs).toISOString());
+    }
   } catch {
     // Silent — sidecar failure must never block the hook.
   }
@@ -1207,9 +1436,159 @@ function evaluateMaintenanceSignal(events, now, canonicalCount, lastEmitMs, thre
     signal: "maintenance",
     // CLI recommendation rather than Skill — doctor is a CLI surface.
     recommended_skill: null,
+    // v2.1 NEW-N-3: staleness trigger. threshold=days; actual=ageDays. When
+    // lint was NEVER run ageDays is null — main() skips the signal emit rather
+    // than fabricate a number (honest gap over fake telemetry).
+    threshold: days,
+    actual_value: ageDays,
   };
 }
 
+// lifecycle-refactor W3-A2 (§7 graph generation signal): after a successful
+// archive the Stop hook REQUESTS edge extraction by emitting one
+// graph_edge_candidate_requested{stable_id, store?}. The hook never PRODUCES
+// edges (that is the archive/import skill's or doctor co-occurrence's job,
+// KT-DEC-0007) — it only flags "this entry just landed; someone should extract
+// its `related` edges". FROZEN-safe: O(1) tail scan, best-effort silent, single
+// advisory-locked appendLockedLine (same primitive the rest of this hook uses).
+//
+// HONEST stable_id sourcing — the deliberate limitation: pending entries (the
+// fabric-archive → extractKnowledge path) carry NO canonical stable_id (id is
+// late-bound at fab_review approve), so their knowledge_proposed event omits
+// stable_id (or sets the `pending:<key>` sentinel). A graph edge between
+// id-less pending drafts is meaningless, so we DO NOT fabricate one. We emit
+// ONLY when the most-recent knowledge_proposed event carries a real
+// K[TP]-XXX-NNNN stable_id (the approve/promote path) — i.e. an entry that
+// actually has a canonical node to attach edges to. When the latest proposed
+// is id-less we honestly skip; the request will fire on the approve event that
+// allocates the id. A session-scoped sidecar de-dupes so repeated Stop fires in
+// one session don't re-request the same id.
+const STABLE_ID_RE = /^K[TP]-[A-Z]{3}-\d{4}$/;
+const GRAPH_EDGE_REQUESTED_SIDECAR = ".fabric/.cache/graph-edge-requested";
+
+function emitGraphEdgeCandidateBestEffort(cwd, events, sessionId) {
+  try {
+    if (!Array.isArray(events) || events.length === 0) return;
+    const fabricDir = join(cwd, FABRIC_DIR);
+    if (!existsSync(fabricDir)) return;
+
+    // O(1)-amortized tail scan for the newest knowledge_proposed carrying a
+    // real (non-sentinel) stable_id. Stop at the first knowledge_proposed we
+    // see — if the latest archive is id-less, we honestly skip rather than
+    // reaching back to an older approved entry (that older entry's edges were
+    // already requested when IT landed).
+    let stableId = null;
+    let store;
+    for (let i = events.length - 1; i >= 0; i -= 1) {
+      const ev = events[i];
+      if (!ev || ev.event_type !== EVENT_TYPE_PROPOSED) continue;
+      const candidate = typeof ev.stable_id === "string" ? ev.stable_id : null;
+      if (candidate && STABLE_ID_RE.test(candidate)) {
+        stableId = candidate;
+        if (typeof ev.store === "string" && ev.store.length > 0) store = ev.store;
+      }
+      // First knowledge_proposed encountered (newest) decides; do not walk past
+      // it to an older one.
+      break;
+    }
+    if (stableId === null) return;
+
+    // Session-scoped de-dup: skip if we already requested edges for this exact
+    // stable_id this session. Sidecar is a single line holding the last id.
+    const sidecarPath = join(cwd, sessionScopedCacheFile(GRAPH_EDGE_REQUESTED_SIDECAR, sessionId));
+    try {
+      if (existsSync(sidecarPath)) {
+        const prev = readFileSync(sidecarPath, "utf8").trim();
+        if (prev === stableId) return;
+      }
+    } catch {
+      // unreadable sidecar → fall through and (re)emit; de-dup is best-effort.
+    }
+
+    let idSuffix;
+    try {
+      idSuffix = require("node:crypto").randomUUID();
+    } catch {
+      idSuffix = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+    }
+    const event = {
+      kind: "fabric-event",
+      id: `event:${idSuffix}`,
+      ts: Date.now(),
+      schema_version: 1,
+      event_type: "graph_edge_candidate_requested",
+      stable_id: stableId,
+    };
+    if (store !== undefined) event.store = store;
+    if (typeof sessionId === "string" && sessionId.length > 0) event.session_id = sessionId;
+    appendLockedLine(join(fabricDir, EVENT_LEDGER_FILE), JSON.stringify(event) + "\n");
+
+    // Record the de-dup marker (best-effort; atomic when state-store lib loaded).
+    try {
+      if (stateStore && typeof stateStore.atomicWrite === "function") {
+        stateStore.atomicWrite(sidecarPath, stableId);
+      } else {
+        mkdirSync(dirname(sidecarPath), { recursive: true });
+        writeFileSync(sidecarPath, stableId);
+      }
+    } catch {
+      // de-dup marker write failed — at worst we re-request next Stop; harmless.
+    }
+  } catch {
+    // best-effort §7 signal — never block the Stop hook (KT-DEC-0007).
+  }
+}
+
+// v2.1 NEW-N-3 (ADJ-NEWN-3): hook_signal_emitted instrumentation. Writes ONE
+// best-effort ledger row at the point a nudge is actually delivered (post-
+// cooldown), so the join key measures nudge-trigger logic (which signal fired,
+// at what threshold vs. actual). Emitted at delivery rather than at
+// threshold-cross so it inherits the cooldown gate — a fired-but-cooled signal
+// does not spam the ledger every session. Skips silently when threshold /
+// actual_value are not finite numbers (e.g. maintenance "never run" → null
+// age). Never blocks the hook (KT-DEC-0007).
+const SIGNAL_TYPE_ENUM = new Set(["archive", "review", "maintenance", "other"]);
+function emitSignalFiredEvent(cwd, sessionId, result) {
+  try {
+    if (!result || typeof result.signal !== "string") return;
+    const threshold = result.threshold;
+    const actualValue = result.actual_value;
+    if (
+      typeof threshold !== "number" ||
+      !Number.isFinite(threshold) ||
+      typeof actualValue !== "number" ||
+      !Number.isFinite(actualValue)
+    ) {
+      return;
+    }
+    const fabricDir = join(cwd, FABRIC_DIR);
+    if (!existsSync(fabricDir)) return;
+    // "import" / any non-canonical signal collapses to schema's catch-all "other".
+    const signalType = SIGNAL_TYPE_ENUM.has(result.signal) ? result.signal : "other";
+    let idSuffix;
+    try {
+      idSuffix = require("node:crypto").randomUUID();
+    } catch {
+      idSuffix = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+    }
+    const event = {
+      kind: "fabric-event",
+      id: `event:${idSuffix}`,
+      ts: Date.now(),
+      schema_version: 1,
+      event_type: "hook_signal_emitted",
+      signal_type: signalType,
+      threshold,
+      actual_value: actualValue,
+      fired: true,
+    };
+    if (typeof sessionId === "string" && sessionId.length > 0) event.session_id = sessionId;
+    appendLockedLine(join(fabricDir, EVENT_LEDGER_FILE), JSON.stringify(event) + "\n");
+  } catch {
+    // best-effort telemetry — never block the hook
+  }
+}
+
 /**
  * v2.0.0-rc.7 T5: best-effort sync stdin reader for the Stop hook.
  *
@@ -1304,14 +1683,13 @@ function parseKbLine(raw) {
  *      "codex". Covers the dominant deployment shape (hook script lives
  *      under the client's per-repo dir).
  *
- * Returns `undefined` when neither signal fires (e.g. Cursor — deferred to
- * rc.21 — or a custom deployment). The Zod schema marks `client` optional,
- * so omitting it leaves the event valid.
+ * Returns `undefined` when neither signal fires (a custom deployment). The
+ * Zod schema marks `client` optional, so omitting it leaves the event valid.
  */
 function detectClient() {
   // Delegate the full 3-tier detection (env → CLAUDE_PROJECT_DIR → path
-  // heuristic, incl. .cursor) to the shared adapter. __dirname is passed so
-  // the path heuristic reflects THIS hook's location.
+  // heuristic) to the shared adapter. __dirname is passed so the path
+  // heuristic reflects THIS hook's location.
   if (clientAdapter && typeof clientAdapter.detectClient === "function") {
     return clientAdapter.detectClient(__dirname);
   }
@@ -1319,7 +1697,7 @@ function detectClient() {
   const envClient = process.env.FABRIC_HINT_CLIENT;
   if (typeof envClient === "string" && envClient.length > 0) {
     const normalised = envClient.trim().toLowerCase();
-    if (normalised === "cc" || normalised === "codex" || normalised === "cursor") {
+    if (normalised === "cc" || normalised === "codex") {
       return normalised;
     }
   }
@@ -1414,7 +1792,7 @@ function extractAndWriteAssistantTurnsBestEffort(cwd, stdinPayload) {
           timestamp: new Date().toISOString(),
         };
         if (client !== undefined) event.client = client;
-        appendFileSync(ledgerPath, JSON.stringify(event) + "\n", "utf8");
+        appendLockedLine(ledgerPath, JSON.stringify(event) + "\n");
       } catch {
         // Per-turn failure must not abort the remaining turns; the Stop hook
         // contract is "never block on hook failure". Best-effort continues.
@@ -1439,7 +1817,7 @@ function extractAndWriteAssistantTurnsBestEffort(cwd, stdinPayload) {
           counters: { [counterKey]: emptyShellCount },
         };
         const metricsPath = join(fabricDir, METRICS_LEDGER_FILE);
-        appendFileSync(metricsPath, JSON.stringify(metricsRow) + "\n", "utf8");
+        appendLockedLine(metricsPath, JSON.stringify(metricsRow) + "\n");
       } catch {
         // metrics fold is observability-only; never block the hook on failure.
       }
@@ -1658,50 +2036,6 @@ function summarizeTranscript(transcriptPath) {
   return out;
 }
 
-/**
- * v2.0.0-rc.24 TASK-05: emit soft L1 reminder to stderr when assistant turns
- * cited a decision/pitfall id with [recalled] but no operator contract and no
- * skip:<reason>. Reads agents.meta.json once per invocation; aggregated per
- * turn (one line per offending id). Non-blocking — never throws, always
- * returns the array of emitted reminder strings (for unit tests + callers
- * that want to observe what was written).
- *
- * The reminder writes go to stderr (the hook contract: stdout is structured
- * banner JSON consumed by the harness; stderr is free-text system message
- * that surfaces back to the model on the next turn in cc / codex / cursor).
- */
-function emitCiteContractRemindersBestEffort(cwd, stdinPayload, stderr) {
-  if (citeContractReminder === null) return [];
-  if (stdinPayload === null || typeof stdinPayload !== "object") return [];
-  try {
-    const transcript = summarizeTranscript(stdinPayload.transcript_path);
-    const turns = transcript.assistant_turns;
-    if (!Array.isArray(turns) || turns.length === 0) return [];
-
-    const idTypeMap = citeContractReminder.readKnowledgeTypeMap(cwd);
-    if (!(idTypeMap instanceof Map) || idTypeMap.size === 0) return [];
-
-    const reminders = citeContractReminder.formatContractMissingReminders({
-      assistant_turns: turns,
-      idTypeMap,
-    });
-    if (!Array.isArray(reminders) || reminders.length === 0) return [];
-
-    const sink = stderr || process.stderr;
-    for (const line of reminders) {
-      try {
-        sink.write(line + "\n");
-      } catch {
-        // Sink write failure must not abort emission of remaining reminders.
-      }
-    }
-    return reminders;
-  } catch {
-    // Outer guard — never throw. Hook continues silently.
-    return [];
-  }
-}
-
 /**
  * v2.0.0-rc.7 T5: writeSessionDigestBestEffort — non-blocking digest fan-out.
  * Called from main() before the existing decide() flow. Failure is silently
@@ -1755,17 +2089,18 @@ function main(env, stdio) {
     // the hook's other I/O).
     extractAndWriteAssistantTurnsBestEffort(cwd, stdinPayload);
 
-    // v2.0.0-rc.24 TASK-05: L1 soft reminder layer. Surfaces ⚠ KB:<id> lines
-    // to stderr when decision/pitfall cites arrived with [recalled] tag but
-    // empty contract. Non-blocking, never throws; doctor (TASK-08) catches
-    // any contract violation the model ignored.
-    emitCiteContractRemindersBestEffort(
-      cwd,
-      stdinPayload,
-      stdio && stdio.stderr,
-    );
-
     const events = readLedger(cwd);
+
+    // lifecycle-refactor W3-A2 (§7): request graph-edge extraction for a freshly
+    // archived canonical entry. Runs UNCONDITIONALLY here (before the nudge
+    // cooldown/dismiss early-returns) so the §7 signal is independent of whether
+    // a reminder banner is shown this Stop. Best-effort, never throws.
+    try {
+      emitGraphEdgeCandidateBestEffort(cwd, events, resolveHookSessionId(stdinPayload));
+    } catch {
+      // never block the Stop hook
+    }
+
     let pendingStats;
     try {
       pendingStats = readPendingStats(cwd, now);
@@ -1898,7 +2233,7 @@ function main(env, stdio) {
     // for the prompt to be actionable.
     if (result === null) {
       try {
-        const lastEmit = readMaintenanceLastEmit(cwd);
+        const lastEmit = readMaintenanceLastEmit(cwd, resolveHookSessionId(stdinPayload));
         result = evaluateMaintenanceSignal(
           events,
           now,
@@ -1911,7 +2246,38 @@ function main(env, stdio) {
       }
     }
 
-    if (result === null) return;
+    if (result === null) {
+      // Observability grill (a): no actionable signal — instead of returning
+      // silently (which made Fabric feel inert in the background), surface a
+      // session-activity status breadcrumb to the human sink (gated by
+      // nudge_mode). Best-effort: never block the Stop hook on it.
+      try {
+        emitSessionStatus(cwd, events, stdinPayload, nowMs, pendingStats, out);
+      } catch {
+        // status breadcrumb is decorative — never throw
+      }
+      return;
+    }
+
+    // v2.2 dual-sink (Goal A / D6): VALUE-GATE the archive nudge. Signal A's
+    // edit/hours trigger is the CHECK cadence; the nudge only fires when a
+    // deterministic high-value signal accrued since the last archive (decouples
+    // check frequency from disturb frequency). Boundary-correct: replicates
+    // archive-scan's ledger probe (no semantic judgement). Other signals
+    // (review/import/maintenance) are unaffected.
+    if (result.signal === "archive") {
+      let watermarkTs = null;
+      for (let i = events.length - 1; i >= 0; i -= 1) {
+        const ev = events[i];
+        if (ev && ev.event_type === EVENT_TYPE_PROPOSED && typeof ev.ts === "number") {
+          watermarkTs = ev.ts;
+          break;
+        }
+      }
+      if (!hasHighValueArchiveSignal(events, watermarkTs)) {
+        return; // no high-value candidate → stay quiet (D6 value-gate)
+      }
+    }
 
     // v2.0.0-rc.37 NEW-16: per-signal dismiss. A chosen signal whose type the
     // user dismissed (config-durable or session sidecar) exits silently —
@@ -1933,10 +2299,10 @@ function main(env, stdio) {
     // 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 bindingId = readWorkspaceBindingId(cwd);
+        if (bindingId) {
           const label = bindingsSnapshotReader.formatStoreLabels(
-            bindingsSnapshotReader.readBindingsSnapshot(projectId),
+            bindingsSnapshotReader.readBindingsSnapshot(bindingId),
           );
           if (label) {
             result.reason = `${result.reason}\n${label}`;
@@ -1951,8 +2317,11 @@ function main(env, stdio) {
     // see MAINTENANCE_HINT_LAST_EMIT_FILE). The A/B/C shared cooldown cache
     // uses hours, so we branch here to avoid mixing semantics.
     if (result.signal === "maintenance") {
+      emitSignalFiredEvent(cwd, sessionId, result);
+      delete result.threshold;
+      delete result.actual_value;
       out.write(JSON.stringify(result));
-      writeMaintenanceLastEmit(cwd, nowMs);
+      writeMaintenanceLastEmit(cwd, nowMs, resolveHookSessionId(stdinPayload));
       return;
     }
 
@@ -1960,7 +2329,7 @@ function main(env, stdio) {
     // archive_hint_cooldown_hours (default 12h) regardless of state drift.
     // Pure reminder-noise reduction; the underlying trigger logic is unchanged.
     const cooldownMs = readCooldownHours(cwd) * MS_PER_HOUR;
-    const cache = readShownCache(cwd);
+    const cache = readShownCache(cwd, resolveHookSessionId(stdinPayload));
     const lastShown = cache[result.signal];
     // rc.34 TASK-01 + review-fix (Gemini P1): future-stamped lastShown
     // (backward clock skew) bypasses cooldown — sidecar treated as expired.
@@ -1972,9 +2341,30 @@ function main(env, stdio) {
       return; // Still in cooldown — silent.
     }
 
-    out.write(JSON.stringify(result));
+    emitSignalFiredEvent(cwd, sessionId, result);
+    const reasonText = typeof result.reason === "string" ? result.reason : "";
+    delete result.threshold;
+    delete result.actual_value;
+    // v2.2 dual-sink (Goal A / D3): the archive nudge is SOFT — emitted as
+    // additionalContext(AI) + systemMessage(human), NEVER decision:block. The
+    // human channel is gated by nudge_mode (D4/D5); the AI channel always carries
+    // it (flow ⊥ observation). Missing it is backstopped by the SessionEnd marker
+    // + cross-session debt (D3). Review/import keep the decision:block contract
+    // (out of Goal A scope; KT-DEC-0007 nudge semantics unchanged for them).
+    if (result.signal === "archive" && clientAdapter && typeof clientAdapter.emitDualSink === "function") {
+      const humanGate =
+        nudgePolicy !== null
+          ? nudgePolicy.resolveHumanSink(cwd, "stop", { highValue: true })
+          : { emitHuman: true };
+      clientAdapter.emitDualSink(
+        { human: humanGate.emitHuman ? reasonText : null, ai: reasonText },
+        { client: clientAdapter.detectClient(__dirname), eventName: "Stop", streams: { stdout: out } },
+      );
+    } else {
+      out.write(JSON.stringify(result));
+    }
     cache[result.signal] = nowMs;
-    writeShownCache(cwd, cache);
+    writeShownCache(cwd, cache, resolveHookSessionId(stdinPayload));
   } catch {
     // Silent — never block on hook failure.
   }
@@ -1986,6 +2376,8 @@ module.exports = {
   readPendingStats,
   countCanonicalNodes,
   countEditsSince,
+  // observability grill (a): session-activity tally for the human status line.
+  tallySessionActivity,
   // rc.7 T4: top-edited-directories aggregator + banner overview formatter.
   getTopEditedDirectories,
   formatActivityOverview,
@@ -2025,10 +2417,9 @@ module.exports = {
   parseKbLine,
   detectClient,
   extractAndWriteAssistantTurnsBestEffort,
-  // v2.0.0-rc.24 TASK-05: L1 soft reminder helpers (exported for unit testing
-  // of the contract-missing emission contract). The lib module itself is
-  // also exported indirectly via the reminder helper.
-  emitCiteContractRemindersBestEffort,
+  // lifecycle-refactor W3-A2 (§7): graph-edge-candidate request emitter
+  // (exported for unit testing of the honest stable_id-gating + de-dup).
+  emitGraphEdgeCandidateBestEffort,
   CONSTANTS: {
     FABRIC_DIR,
     EVENT_LEDGER_FILE,
@@ -2066,6 +2457,8 @@ module.exports = {
     // v2.0.0-rc.8 (TASK-002): in-flight import gate for Signal B.
     IMPORT_STATE_FILE_REL,
     IMPORT_IN_FLIGHT_MAX_AGE_HOURS,
+    // lifecycle-refactor W3-A2 (§7): graph-edge-request de-dup sidecar.
+    GRAPH_EDGE_REQUESTED_SIDECAR,
   },
 };