@fenglimg/fabric-server 2.0.0-rc.26 → 2.0.0-rc.27

package/dist/{chunk-RHWIDD6A.js → chunk-NZSGNQKE.js}

@@ -184,6 +184,46 @@ var EVENT_LEDGER_DEFAULT_RETENTION_DAYS = 30;
 var EVENT_LEDGER_SIZE_WARN_BYTES = 50 * 1024 * 1024;
 var EVENT_LEDGER_ARCHIVE_DIR = ".fabric/events.archive";
 var warnedOversize = false;
+var knownEventTypesCache = null;
+function getKnownEventTypes() {
+  if (knownEventTypesCache !== null) return knownEventTypesCache;
+  const set = /* @__PURE__ */ new Set();
+  for (const opt of eventLedgerEventSchema.options) {
+    const shape = opt.shape;
+    if (shape && typeof shape.event_type?.value === "string") {
+      set.add(shape.event_type.value);
+    }
+  }
+  knownEventTypesCache = set;
+  return set;
+}
+function classifyRejection(line, index) {
+  let parsed;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  if (parsed === null || typeof parsed !== "object") return null;
+  if ("schema_version" in parsed && parsed.schema_version !== 1 && (typeof parsed.schema_version === "number" || parsed.schema_version === null)) {
+    return {
+      kind: "schema_version_unsupported",
+      line_index: index,
+      schema_version: parsed.schema_version,
+      snippet_first_120: line.slice(0, 120)
+    };
+  }
+  const known = getKnownEventTypes();
+  if (typeof parsed.event_type === "string" && !known.has(parsed.event_type)) {
+    return {
+      kind: "event_type_unknown",
+      line_index: index,
+      event_type: parsed.event_type,
+      snippet_first_120: line.slice(0, 120)
+    };
+  }
+  return null;
+}
 async function appendEventLedgerEvent(projectRoot, event) {
   const eventPath = getEventLedgerPath(projectRoot);
   const nextEvent = eventLedgerEventSchema.parse({
@@ -238,8 +278,20 @@ async function readEventLedger(projectRoot, options = {}) {
       snippet_first_120: partialLine.slice(0, 120)
     });
   }
-  const events = lines.map((line) => line.trim()).filter((line) => line.length > 0).map((line, index) => parseEventLedgerLine(line, index)).filter((entry) => entry !== null).filter((entry) => options.event_type === void 0 || entry.event_type === options.event_type).filter((entry) => options.since === void 0 || entry.ts >= options.since).filter((entry) => options.correlation_id === void 0 || entry.correlation_id === options.correlation_id).filter((entry) => options.session_id === void 0 || entry.session_id === options.session_id);
-  return { events, warnings };
+  const trimmed = lines.map((line) => line.trim()).filter((line) => line.length > 0);
+  const events = [];
+  for (let i = 0; i < trimmed.length; i++) {
+    const line = trimmed[i];
+    const parsed = parseEventLedgerLine(line, i);
+    if (parsed !== null) {
+      events.push(parsed);
+      continue;
+    }
+    const rejection = classifyRejection(line, i);
+    if (rejection !== null) warnings.push(rejection);
+  }
+  const filtered = events.filter((entry) => options.event_type === void 0 || entry.event_type === options.event_type).filter((entry) => options.since === void 0 || entry.ts >= options.since).filter((entry) => options.correlation_id === void 0 || entry.correlation_id === options.correlation_id).filter((entry) => options.session_id === void 0 || entry.session_id === options.session_id);
+  return { events: filtered, warnings };
 }
 async function truncateLedgerToLastNewline(path2) {
   const raw = await readFile2(path2);
@@ -951,16 +1003,18 @@ function extractRuleDescription(source) {
   }
   const heading = /^#\s+(.+?)\s*$/mu.exec(source);
   const summary = heading?.[1]?.trim();
-  if (summary === void 0 || summary.length === 0) {
+  const knowledge = frontmatter !== null ? extractKnowledgeFieldsFromFrontmatter(frontmatter[1]) : void 0;
+  const isStructurallyAKnowledgeEntry = summary !== void 0 && summary.length > 0 ? true : knowledge !== void 0 && (knowledge.id !== void 0 || knowledge.knowledge_type !== void 0 || knowledge.tags !== void 0 && knowledge.tags.length > 0);
+  if (!isStructurallyAKnowledgeEntry) {
     return void 0;
   }
-  const knowledge = frontmatter !== null ? extractKnowledgeFieldsFromFrontmatter(frontmatter[1]) : void 0;
+  const synthesizedSummary = summary !== void 0 && summary.length > 0 ? summary : knowledge?.id ?? (knowledge?.tags !== void 0 && knowledge.tags.length > 0 ? `(unnamed; tags: ${knowledge.tags.join(", ")})` : "(unnamed knowledge entry)");
   return {
-    summary,
+    summary: synthesizedSummary,
     intent_clues: [],
     tech_stack: [],
     impact: [],
-    must_read_if: summary,
+    must_read_if: synthesizedSummary,
     // v2.0-rc.22: when frontmatter is present, merge its knowledge fields;
     // when fully absent (no `---` block), all knowledge fields stay
     // undefined, matching the original heading-only fallback contract.
@@ -1757,6 +1811,10 @@ async function runDoctorReport(target) {
     createKnowledgeTestIndexCheck(t, knowledgeTestIndex),
     createEventLedgerCheck(t, eventLedger),
     createEventLedgerPartialWriteCheck(t, eventLedger),
+    // v2.0.0-rc.27 TASK-010 (audit §2.24): forward-compat warning surface for
+    // events.jsonl rows that fail Zod validation because of unknown
+    // schema_version or event_type tokens. Previously silently dropped.
+    createEventLedgerSchemaCompatCheck(t, eventLedger),
     createMcpConfigInWrongFileCheck(t, mcpConfigInWrongFile),
     createMetaManuallyDivergedCheck(t, metaManuallyDiverged),
     createKnowledgeDirUnindexedCheck(t, knowledgeDirUnindexed),
@@ -1905,7 +1963,8 @@ async function runDoctorFix(target) {
     "knowledge_test_index_missing",
     "knowledge_test_index_stale",
     "content_ref_missing",
-    "knowledge_dir_unindexed"
+    "knowledge_dir_unindexed",
+    "meta_manually_diverged"
   ];
   if (before.fixable_errors.some((issue) => reconcileCodes.includes(issue.code)) || before.warnings.some((issue) => reconcileCodes.includes(issue.code))) {
     await reconcileKnowledge(projectRoot, { trigger: "doctor" });
@@ -2487,7 +2546,19 @@ async function inspectEventLedger(projectRoot) {
   const path2 = getEventLedgerPath(projectRoot);
   const exists = existsSync4(path2);
   if (!exists) {
-    return { exists: false, writable: false, parseable: false, hasPartialWrite: false, partialWriteByteOffset: 0, partialWriteByteLength: 0, path: path2 };
+    return {
+      exists: false,
+      writable: false,
+      parseable: false,
+      hasPartialWrite: false,
+      partialWriteByteOffset: 0,
+      partialWriteByteLength: 0,
+      schemaVersionUnsupportedCount: 0,
+      eventTypeUnknownCount: 0,
+      schemaVersionSamples: [],
+      eventTypeSamples: [],
+      path: path2
+    };
   }
   try {
     await access(path2, constants.W_OK);
@@ -2495,6 +2566,25 @@ async function inspectEventLedger(projectRoot) {
     const raw = await readFile5(path2, "utf8");
     const invalidLine = raw.split(/\r?\n/u).map((line) => line.trim()).filter(Boolean).find((line) => !isValidJsonLine(line));
     const partialWarning = warnings.find((w) => w.kind === "partial_write_at_tail");
+    const schemaVersionSamples = [];
+    const eventTypeSamples = [];
+    let schemaVersionUnsupportedCount = 0;
+    let eventTypeUnknownCount = 0;
+    for (const w of warnings) {
+      if (w.kind === "schema_version_unsupported") {
+        schemaVersionUnsupportedCount += 1;
+        const token = String(w.schema_version);
+        if (!schemaVersionSamples.includes(token) && schemaVersionSamples.length < 3) {
+          schemaVersionSamples.push(token);
+        }
+      } else if (w.kind === "event_type_unknown") {
+        eventTypeUnknownCount += 1;
+        const token = String(w.event_type);
+        if (!eventTypeSamples.includes(token) && eventTypeSamples.length < 3) {
+          eventTypeSamples.push(token);
+        }
+      }
+    }
     return {
       exists: true,
       writable: true,
@@ -2502,6 +2592,10 @@ async function inspectEventLedger(projectRoot) {
       hasPartialWrite: partialWarning !== void 0,
       partialWriteByteOffset: partialWarning?.byte_offset ?? 0,
       partialWriteByteLength: partialWarning?.byte_length ?? 0,
+      schemaVersionUnsupportedCount,
+      eventTypeUnknownCount,
+      schemaVersionSamples,
+      eventTypeSamples,
       path: path2,
       error: invalidLine === void 0 ? void 0 : "events.jsonl contains an invalid JSON line."
     };
@@ -2513,6 +2607,10 @@ async function inspectEventLedger(projectRoot) {
       hasPartialWrite: false,
       partialWriteByteOffset: 0,
       partialWriteByteLength: 0,
+      schemaVersionUnsupportedCount: 0,
+      eventTypeUnknownCount: 0,
+      schemaVersionSamples: [],
+      eventTypeSamples: [],
       path: path2,
       error: error instanceof Error ? error.message : String(error)
     };
@@ -3053,6 +3151,47 @@ function createMcpConfigInWrongFileCheck(t, inspection) {
     t("doctor.check.mcp_config_in_wrong_file.ok")
   );
 }
+function createEventLedgerSchemaCompatCheck(t, ledger) {
+  if (!ledger.exists || !ledger.writable) {
+    return okCheck(
+      t("doctor.check.event_ledger_schema_compat.name"),
+      t("doctor.check.event_ledger_schema_compat.ok.skipped")
+    );
+  }
+  const hasUnsupportedVersion = ledger.schemaVersionUnsupportedCount > 0;
+  const hasUnknownEventType = ledger.eventTypeUnknownCount > 0;
+  if (!hasUnsupportedVersion && !hasUnknownEventType) {
+    return okCheck(
+      t("doctor.check.event_ledger_schema_compat.name"),
+      t("doctor.check.event_ledger_schema_compat.ok.clean")
+    );
+  }
+  const parts = [];
+  if (hasUnsupportedVersion) {
+    parts.push(
+      t("doctor.check.event_ledger_schema_compat.message.schema_version", {
+        count: String(ledger.schemaVersionUnsupportedCount),
+        samples: ledger.schemaVersionSamples.join(", ")
+      })
+    );
+  }
+  if (hasUnknownEventType) {
+    parts.push(
+      t("doctor.check.event_ledger_schema_compat.message.event_type", {
+        count: String(ledger.eventTypeUnknownCount),
+        samples: ledger.eventTypeSamples.join(", ")
+      })
+    );
+  }
+  return issueCheck(
+    t("doctor.check.event_ledger_schema_compat.name"),
+    "warn",
+    "warning",
+    "event_ledger_schema_compat",
+    parts.join(" "),
+    t("doctor.check.event_ledger_schema_compat.remediation")
+  );
+}
 function createEventLedgerPartialWriteCheck(t, ledger) {
   if (!ledger.exists || !ledger.writable) {
     return okCheck(

package/dist/{http-FMSBWYMO.js → http-3WADEK3O.js}

@@ -14,7 +14,7 @@ import {
   readEventLedger,
   runDoctorReport,
   sha256
-} from "./chunk-RHWIDD6A.js";
+} from "./chunk-NZSGNQKE.js";
 
 // src/http.ts
 import { randomUUID as randomUUID2 } from "crypto";

package/dist/index.d.ts

@@ -425,8 +425,14 @@ interface ReconcileKnowledgeOptions {
      * v2.0.0-rc.23 TASK-005 (a-B): `auto-heal-description` added so plan_context
      * can drive a full reconcile when it detects nodes with `description === undefined`
      * (legacy meta drift the revision-hash gate cannot detect).
+     *
+     * v2.0.0-rc.27 TASK-001 (§2.9 root): `post-approve` / `post-modify` added so
+     * `fab_review` approve/modify-layer-flip can drive an immediate meta rebuild
+     * — without this the new entry's `nodes[id]` stays empty until the next
+     * plan_context call's auto-heal, which leaves the entry undiscoverable in
+     * the description_index window between approve and the next hint call.
      */
-    trigger?: "startup" | "doctor" | "manual" | "auto-heal-description";
+    trigger?: "startup" | "doctor" | "manual" | "auto-heal-description" | "post-approve" | "post-modify";
 }
 /**
  * Full scan + rewrites agents.meta.json with ground-truth disk state + emits

package/dist/index.js

@@ -37,7 +37,7 @@ import {
   sha256,
   stableStringify,
   writeKnowledgeMeta
-} from "./chunk-RHWIDD6A.js";
+} from "./chunk-NZSGNQKE.js";
 
 // src/index.ts
 import { existsSync as existsSync4 } from "fs";
@@ -250,7 +250,24 @@ async function extractKnowledge(projectRoot, input) {
     const existing = await readFile(absolutePath, "utf8");
     const existingKey = readFrontmatterKey(existing, "x-fabric-idempotency-key");
     if (existingKey === idempotencyKey) {
-      const augmented = mergeEvidenceNotes(existing, summary, input.recent_paths);
+      const fresh2 = renderFreshEntry({
+        type: input.type,
+        sourceSessions,
+        idempotencyKey,
+        summary,
+        recentPaths: input.recent_paths,
+        layer,
+        proposedReason: input.proposed_reason,
+        sessionContext: input.session_context,
+        relevanceScope,
+        relevancePaths,
+        intentClues: input.intent_clues,
+        techStack: input.tech_stack,
+        impact: input.impact,
+        mustReadIf: input.must_read_if,
+        onboardSlot: input.onboard_slot
+      });
+      const augmented = mergeEvidenceNotes(existing, fresh2);
       await atomicWriteText(absolutePath, augmented);
       await emitEventBestEffort(projectRoot, {
         event_type: "knowledge_proposed",
@@ -402,62 +419,18 @@ function renderEvidenceBlock(summary, recentPaths) {
     `- ${summary.trim()}`
   ].join("\n");
 }
-function mergeEvidenceNotes(existing, newSummary, newRecentPaths) {
-  const beforeMatch = /^([\s\S]*?)(\n## Evidence(?:\s*\(call \d+\))?\s*\n)/u.exec(
-    existing.endsWith("\n") ? existing : `${existing}
-`
-  );
-  if (beforeMatch === null) {
-    const trimmed = existing.endsWith("\n") ? existing : `${existing}
-`;
-    return `${trimmed}
-## Evidence
-
-${renderEvidenceBlock(newSummary, newRecentPaths)}
+function mergeEvidenceNotes(existing, fresh) {
+  const freshSplit = splitAtEvidence(fresh);
+  if (freshSplit === null) {
+    return fresh.endsWith("\n") ? fresh : `${fresh}
 `;
   }
-  const head = beforeMatch[1] ?? "";
-  const existingNotes = [];
-  const existingPaths = [];
-  const evidenceBlockRe = /\n## Evidence(?:\s*\(call \d+\))?\s*\n([\s\S]*?)(?=\n## |$)/gu;
-  let m;
-  while ((m = evidenceBlockRe.exec(`${existing}
-`)) !== null) {
-    const block = m[1] ?? "";
-    const pathSection = /Recent paths:\s*\n([\s\S]*?)(?:\n\s*Notes:|$)/u.exec(block);
-    if (pathSection !== null) {
-      for (const rawLine of (pathSection[1] ?? "").split(/\r?\n/u)) {
-        const t = rawLine.trim();
-        if (t.startsWith("- ")) {
-          existingPaths.push(t.slice(2).trim());
-        }
-      }
-    }
-    const notesSection = /Notes:\s*\n([\s\S]*?)$/u.exec(block);
-    const noteBody = (notesSection !== null ? notesSection[1] : block) ?? "";
-    const bulletLines = [];
-    let prose = [];
-    for (const rawLine of noteBody.split(/\r?\n/u)) {
-      const t = rawLine.trim();
-      if (t.length === 0) continue;
-      if (t.startsWith("- ")) {
-        if (prose.length > 0) {
-          existingNotes.push(prose.join(" ").trim());
-          prose = [];
-        }
-        bulletLines.push(t.slice(2).trim());
-      } else {
-        prose.push(t);
-      }
-    }
-    if (prose.length > 0) existingNotes.push(prose.join(" ").trim());
-    for (const n of bulletLines) existingNotes.push(n);
-  }
+  const freshHead = freshSplit.head;
+  const oldEvidence = collectEvidenceItems(existing);
+  const freshEvidence = collectEvidenceItems(fresh);
   const mergedNotes = [];
   const seenNotes = /* @__PURE__ */ new Set();
-  const incomingNote = newSummary.trim();
-  const candidates = [...existingNotes, incomingNote];
-  for (const note of candidates) {
+  for (const note of [...oldEvidence.notes, ...freshEvidence.notes]) {
     const key = note.replace(/\s+/gu, " ").trim();
     if (key.length === 0) continue;
     if (seenNotes.has(key)) continue;
@@ -466,7 +439,7 @@ ${renderEvidenceBlock(newSummary, newRecentPaths)}
   }
   const mergedPaths = [];
   const seenPaths = /* @__PURE__ */ new Set();
-  for (const p of [...existingPaths, ...newRecentPaths]) {
+  for (const p of [...oldEvidence.paths, ...freshEvidence.paths]) {
     const key = p.trim();
     if (key.length === 0) continue;
     if (seenPaths.has(key)) continue;
@@ -484,12 +457,58 @@ ${renderEvidenceBlock(newSummary, newRecentPaths)}
     "",
     noteLines
   ].join("\n");
-  return `${head}
+  return `${freshHead}
 ## Evidence
 
 ${evidenceBody}
 `;
 }
+function splitAtEvidence(content) {
+  const tail = content.endsWith("\n") ? content : `${content}
+`;
+  const match = /^([\s\S]*?)(\n## Evidence(?:\s*\(call \d+\))?\s*\n)/u.exec(tail);
+  if (match === null) return null;
+  return { head: match[1] ?? "" };
+}
+function collectEvidenceItems(content) {
+  const notes = [];
+  const paths = [];
+  const evidenceBlockRe = /\n## Evidence(?:\s*\(call \d+\))?\s*\n([\s\S]*?)(?=\n## |$)/gu;
+  let m;
+  while ((m = evidenceBlockRe.exec(`${content}
+`)) !== null) {
+    const block = m[1] ?? "";
+    const pathSection = /Recent paths:\s*\n([\s\S]*?)(?:\n\s*Notes:|$)/u.exec(block);
+    if (pathSection !== null) {
+      for (const rawLine of (pathSection[1] ?? "").split(/\r?\n/u)) {
+        const t = rawLine.trim();
+        if (t.startsWith("- ")) {
+          paths.push(t.slice(2).trim());
+        }
+      }
+    }
+    const notesSection = /Notes:\s*\n([\s\S]*?)$/u.exec(block);
+    const noteBody = (notesSection !== null ? notesSection[1] : block) ?? "";
+    const bulletLines = [];
+    let prose = [];
+    for (const rawLine of noteBody.split(/\r?\n/u)) {
+      const t = rawLine.trim();
+      if (t.length === 0) continue;
+      if (t.startsWith("- ")) {
+        if (prose.length > 0) {
+          notes.push(prose.join(" ").trim());
+          prose = [];
+        }
+        bulletLines.push(t.slice(2).trim());
+      } else {
+        prose.push(t);
+      }
+    }
+    if (prose.length > 0) notes.push(prose.join(" ").trim());
+    for (const n of bulletLines) notes.push(n);
+  }
+  return { notes, paths };
+}
 function readFrontmatterKey(content, key) {
   const match = /^---\n([\s\S]*?)\n---/u.exec(content);
   if (match === null) {
@@ -567,7 +586,34 @@ import { minimatch } from "minimatch";
 import { deriveAgentsMetaLayer } from "@fenglimg/fabric-shared";
 var SELECTION_TOKEN_TTL_MS = 5 * 60 * 1e3;
 var selectionTokenCache = /* @__PURE__ */ new Map();
+function assertPathInSandbox(rawPath) {
+  if (rawPath === "**" || rawPath === "*") return;
+  const normalized = rawPath.replaceAll("\\", "/");
+  if (normalized.startsWith("/")) {
+    throw new Error(
+      `plan_context: absolute paths are not allowed (got "${rawPath}"); pass a path relative to the project root`
+    );
+  }
+  if (normalized.startsWith("~/") || normalized === "~") {
+    throw new Error(
+      `plan_context: shell sigil "~" is not allowed (got "${rawPath}"); expand to a project-relative path before calling`
+    );
+  }
+  if (normalized.split("/").some((seg) => seg === "..")) {
+    throw new Error(
+      `plan_context: ".." traversal is not allowed (got "${rawPath}"); pass a path that resolves under the project root`
+    );
+  }
+}
 async function planContext(projectRoot, input) {
+  for (const p of input.paths) {
+    assertPathInSandbox(p);
+  }
+  if (input.target_paths !== void 0) {
+    for (const p of input.target_paths) {
+      assertPathInSandbox(p);
+    }
+  }
   let metaResult = await loadActiveMetaOrStale(projectRoot, { caller: "planContext" });
   let meta = metaResult.meta;
   let firstSeenPreviousRevision = metaResult.previous_revision_hash;
@@ -1042,6 +1088,23 @@ function resolveSandboxedPath(projectRoot, candidate, options = {}) {
   }
   throw new Error(`path escapes knowledge root: ${candidate}`);
 }
+function extractBody(content) {
+  const match = /^(?:\uFEFF)?---\r?\n[\s\S]*?\r?\n---\s*(?:\r?\n|$)/u.exec(content);
+  if (match === null) {
+    return content.trim();
+  }
+  return content.slice(match[0].length).trim();
+}
+function isVisibleByLifecycle(fm, filters) {
+  if (fm.status === "rejected" && filters?.include_rejected !== true) {
+    return false;
+  }
+  if (fm.status === "deferred" && filters?.include_deferred !== true) {
+    if (fm.deferred_until === void 0) return false;
+    if (fm.deferred_until > (/* @__PURE__ */ new Date()).toISOString()) return false;
+  }
+  return true;
+}
 async function listPending(projectRoot, filters) {
   const items = [];
   const typesToScan = filters?.type !== void 0 ? [filters.type] : PLURAL_TYPES;
@@ -1090,14 +1153,27 @@ async function listPending(projectRoot, filters) {
             continue;
           }
         }
+        if (!isVisibleByLifecycle(fm, filters)) {
+          continue;
+        }
         const reportedPath = source.origin === "personal" ? `~/${relative2(resolvePersonalRoot2(), absolutePath)}` : relative2(projectRoot, absolutePath);
         items.push({
           pending_path: reportedPath,
+          // v2.0.0-rc.27 TASK-001 (§2.12): absolute path companion for
+          // personal entries so programmatic consumers (Read, fs.readFile)
+          // don't need to shell-expand the `~` themselves.
+          ...source.origin === "personal" ? { pending_path_absolute: absolutePath } : {},
           type,
           layer,
           maturity,
           origin: source.origin,
-          ...fm.tags !== void 0 && fm.tags.length > 0 ? { tags: fm.tags } : {}
+          ...fm.tags !== void 0 && fm.tags.length > 0 ? { tags: fm.tags } : {},
+          ...fm.status !== void 0 ? { status: fm.status } : {},
+          ...fm.deferred_until !== void 0 ? { deferred_until: fm.deferred_until } : {},
+          // v2.0.0-rc.27 TASK-006 (audit §2.23): full body when caller
+          // opted in. Reviewer UI consumes this to scan for prompt-injection
+          // payloads hidden under `## Evidence` body.
+          ...filters?.include_body === true ? { body: extractBody(content) } : {}
         });
       }
     }
@@ -1189,6 +1265,10 @@ async function approveOne(projectRoot, pendingPath, allocator) {
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       reason: `approve:${slug}`
     });
+    try {
+      await reconcileKnowledge(projectRoot, { trigger: "post-approve" });
+    } catch {
+    }
     return { pending_path: pendingPath, stable_id: stableId };
   } catch (err) {
     if (writtenTarget && targetAbs !== void 0 && existsSync3(targetAbs)) {
@@ -1210,6 +1290,17 @@ async function approveOne(projectRoot, pendingPath, allocator) {
 async function rejectAll(projectRoot, pendingPaths, reason) {
   const rejected = [];
   for (const pendingPath of pendingPaths) {
+    try {
+      const sandboxed = resolveSandboxedPath(projectRoot, pendingPath, { allowPersonal: true });
+      if (existsSync3(sandboxed.abs)) {
+        const content = await readFile3(sandboxed.abs, "utf8");
+        const merged = rewriteFrontmatterMerge(content, { status: "rejected" });
+        if (merged !== content) {
+          await atomicWriteText(sandboxed.abs, merged);
+        }
+      }
+    } catch {
+    }
     await emitEventBestEffort2(projectRoot, {
       event_type: "knowledge_rejected",
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -1268,6 +1359,11 @@ function extractSlug(path) {
   return file.replace(/^K[PT]-(MOD|DEC|GLD|PIT|PRO)-\d+--/u, "");
 }
 async function modifyLayerFlip(projectRoot, target, content, fm, changes) {
+  if (target.absPath.includes("/pending/")) {
+    throw new Error(
+      "layer-flip not allowed on pending entries; approve first, then modify the canonical entry's layer"
+    );
+  }
   const fromLayer = fm.layer ?? "team";
   const toLayer = changes.layer;
   const pluralType = fm.type ?? target.inferredType;
@@ -1334,6 +1430,10 @@ async function modifyLayerFlip(projectRoot, target, content, fm, changes) {
     });
   }
   const responsePath = toLayer === "team" ? relative2(projectRoot, toAbs) : `~/${relative2(resolvePersonalRoot2(), toAbs)}`;
+  try {
+    await reconcileKnowledge(projectRoot, { trigger: "post-modify" });
+  } catch {
+  }
   return {
     action: "modify",
     pending_path: responsePath,
@@ -1390,17 +1490,25 @@ async function searchEntries(projectRoot, query, filters) {
             continue;
           }
         }
+        if (!isVisibleByLifecycle(fm, filters)) {
+          continue;
+        }
+        const bodyForSearch = filters?.include_body === true ? extractBody(content) : "";
         const haystacks = [
           fm.title ?? "",
           fm.summary ?? "",
           ...fm.tags ?? [],
-          name
+          name,
+          bodyForSearch
         ].map((s) => s.toLowerCase());
         const matches = haystacks.some((h) => h.includes(lowerQuery));
         if (!matches) continue;
         const reportedPath = source.isPersonal ? `~/${relative2(resolvePersonalRoot2(), absolutePath)}` : relative2(projectRoot, absolutePath);
         items.push({
           pending_path: reportedPath,
+          // v2.0.0-rc.27 TASK-001 (§2.12): absolute companion for personal
+          // entries (mirrors listPending).
+          ...source.isPersonal ? { pending_path_absolute: absolutePath } : {},
           type,
           layer,
           maturity,
@@ -1409,7 +1517,14 @@ async function searchEntries(projectRoot, query, filters) {
           ...source.isPending ? { origin: source.isPersonal ? "personal" : "team" } : {},
           ...fm.tags !== void 0 && fm.tags.length > 0 ? { tags: fm.tags } : {},
           ...fm.title !== void 0 ? { title: fm.title } : {},
-          ...fm.summary !== void 0 ? { summary: fm.summary } : {}
+          ...fm.summary !== void 0 ? { summary: fm.summary } : {},
+          ...fm.status !== void 0 ? { status: fm.status } : {},
+          ...fm.deferred_until !== void 0 ? { deferred_until: fm.deferred_until } : {},
+          // v2.0.0-rc.27 TASK-006 (audit §2.23): body emission when opted in.
+          // Reuse the already-computed bodyForSearch to avoid a second pass
+          // over the content (the search loop above extracted it iff
+          // include_body=true).
+          ...filters?.include_body === true ? { body: bodyForSearch } : {}
         });
       }
     }
@@ -1419,6 +1534,21 @@ async function searchEntries(projectRoot, query, filters) {
 async function deferAll(projectRoot, pendingPaths, until, reason) {
   const deferred = [];
   for (const pendingPath of pendingPaths) {
+    try {
+      const sandboxed = resolveSandboxedPath(projectRoot, pendingPath, { allowPersonal: true });
+      if (existsSync3(sandboxed.abs)) {
+        const content = await readFile3(sandboxed.abs, "utf8");
+        const patch = {
+          status: "deferred",
+          ...until !== void 0 ? { deferred_until: until } : {}
+        };
+        const merged = rewriteFrontmatterMerge(content, patch);
+        if (merged !== content) {
+          await atomicWriteText(sandboxed.abs, merged);
+        }
+      }
+    } catch {
+    }
     await emitEventBestEffort2(projectRoot, {
       event_type: "knowledge_deferred",
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -1488,6 +1618,14 @@ function parseFrontmatter(content) {
       case "relevance_paths":
         out.relevance_paths = parseFlowArray(value);
         break;
+      case "status":
+        if (value === "active" || value === "rejected" || value === "deferred") {
+          out.status = value;
+        }
+        break;
+      case "deferred_until":
+        out.deferred_until = stripQuotes(value);
+        break;
       default:
         break;
     }
@@ -1549,6 +1687,8 @@ ${content}`;
   if (patch.tags !== void 0) updates.tags = `tags: [${patch.tags.join(", ")}]`;
   if (patch.relevance_scope !== void 0) updates.relevance_scope = `relevance_scope: ${patch.relevance_scope}`;
   if (patch.relevance_paths !== void 0) updates.relevance_paths = `relevance_paths: [${patch.relevance_paths.join(", ")}]`;
+  if (patch.status !== void 0) updates.status = `status: ${patch.status}`;
+  if (patch.deferred_until !== void 0) updates.deferred_until = `deferred_until: ${quoteIfNeeded(patch.deferred_until)}`;
   const lines = block.split(/\r?\n/u);
   const seen = /* @__PURE__ */ new Set();
   const newLines = [];
@@ -1582,6 +1722,8 @@ function appendPatchLines(lines, patch) {
   if (patch.tags !== void 0) lines.push(`tags: [${patch.tags.join(", ")}]`);
   if (patch.relevance_scope !== void 0) lines.push(`relevance_scope: ${patch.relevance_scope}`);
   if (patch.relevance_paths !== void 0) lines.push(`relevance_paths: [${patch.relevance_paths.join(", ")}]`);
+  if (patch.status !== void 0) lines.push(`status: ${patch.status}`);
+  if (patch.deferred_until !== void 0) lines.push(`deferred_until: ${quoteIfNeeded(patch.deferred_until)}`);
 }
 function quoteIfNeeded(value) {
   if (/[\n\r]/u.test(value)) {
@@ -1661,7 +1803,7 @@ var PRIORITY_ORDER = {
   medium: 1,
   low: 2
 };
-function extractBody(content) {
+function extractBody2(content) {
   const match = /^(?:\uFEFF)?---\r?\n([\s\S]*?)\r?\n---\s*(?:\r?\n|$)/u.exec(content);
   if (match === null) {
     return content.replace(/^\uFEFF/u, "");
@@ -1681,7 +1823,7 @@ async function getKnowledgeSections(projectRoot, input) {
   const rules = [];
   for (const rule of selectedRules) {
     const content = await readFile4(resolveRuleSourcePath(projectRoot, rule.path), "utf8");
-    const body = extractBody(content);
+    const body = extractBody2(content);
     const description = rule.node.description;
     if (description !== void 0 && description.knowledge_type === void 0 && description.knowledge_layer === void 0) {
       diagnostics.push({
@@ -1894,7 +2036,7 @@ function formatPreexistingRootMessage(projectRoot) {
 function createFabricServer(tracker) {
   const server = new McpServer({
     name: "fabric-knowledge-server",
-    version: "2.0.0-rc.26"
+    version: "2.0.0-rc.27"
   });
   registerPlanContext(server, tracker);
   registerKnowledgeSections(server, tracker);
@@ -2002,7 +2144,7 @@ function createShutdownHandler(deps) {
   };
 }
 async function startHttpServer(options) {
-  const { createFabricHttpApp } = await import("./http-FMSBWYMO.js");
+  const { createFabricHttpApp } = await import("./http-3WADEK3O.js");
   const { port, projectRoot, host = "127.0.0.1", authToken } = options;
   const app = createFabricHttpApp({ projectRoot, host, authToken });
   return await new Promise((resolveServer, rejectServer) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fenglimg/fabric-server",
-  "version": "2.0.0-rc.26",
+  "version": "2.0.0-rc.27",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -13,7 +13,7 @@
     "express": "^5.2.1",
     "minimatch": "^10.0.1",
     "zod": "^3.25.0",
-    "@fenglimg/fabric-shared": "2.0.0-rc.26"
+    "@fenglimg/fabric-shared": "2.0.0-rc.27"
   },
   "devDependencies": {
     "@types/express": "^5.0.6",