peaks-loop 4.0.54 → 4.1.1

package/dist/services/memory/project-memory-service/parsers/frontmatter-parse.js

@@ -0,0 +1,104 @@
+// ---------------------------------------------------------------------------
+// Frontmatter extract-path surface for project memory files.
+//
+// Split out of `./frontmatter.ts` by the `b1-filesplit-campaign` (wave 3,
+// leaf `b1w3-c-memory`): the accepted-kind allow-list, the `slugify` helper,
+// and the extract-path block parser / renderer. `./frontmatter.ts` re-exports
+// every name here so the `index.ts` barrel, `markdown-pure.ts` and the CLI
+// keep importing them from `./parsers/frontmatter.js` unchanged.
+// ---------------------------------------------------------------------------
+import { PROJECT_MEMORY_KINDS } from '../types.js';
+/** Accepted-kind set, derived from the canonical `PROJECT_MEMORY_KINDS`
+ *  tuple so the parser cannot drift from the union type / tier map. */
+export const VALID_MEMORY_KINDS = new Set(PROJECT_MEMORY_KINDS);
+/** Exported for guard tests + tooling that needs to enumerate the accepted
+ *  set (CLI help text, `--kind` validation) without duplicating the literal. */
+export const VALID_PROJECT_MEMORY_KINDS = PROJECT_MEMORY_KINDS;
+export function slugify(title) {
+    const slug = title
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+    return slug.length > 0 ? slug : 'project-memory';
+}
+/**
+ * Single implementation of the extract-path block parse. Returns a
+ * discriminated result so the caller can say WHY a found block was rejected.
+ *
+ * The precondition order mirrors the original combined `if` exactly
+ * (separator → title → kind present → kind valid → body non-empty), so the
+ * accepted set is bit-for-bit what it always was; only the explanation is new.
+ */
+export function parseBlockResult(block, sourceArtifact) {
+    const normalizedBlock = block.replace(/\r\n/g, '\n');
+    const separatorIndex = normalizedBlock.indexOf('\n---\n');
+    if (separatorIndex < 0) {
+        return {
+            ok: false,
+            reason: 'missing-separator',
+            detail: "block header is not followed by a '---' separator line"
+        };
+    }
+    const header = normalizedBlock.slice(0, separatorIndex).trim();
+    const body = normalizedBlock.slice(separatorIndex + '\n---\n'.length).trim();
+    const fields = new Map();
+    for (const line of header.split('\n')) {
+        const [key, ...valueParts] = line.split(':');
+        const normalizedKey = key?.trim();
+        const value = valueParts.join(':').trim();
+        if (normalizedKey && value) {
+            fields.set(normalizedKey, value);
+        }
+    }
+    const title = fields.get('title')?.trim();
+    const kind = fields.get('kind')?.trim();
+    if (!title) {
+        return {
+            ok: false,
+            reason: 'missing-title',
+            detail: "block header has no non-empty 'title:' field"
+        };
+    }
+    if (!kind) {
+        return {
+            ok: false,
+            reason: 'missing-kind',
+            detail: "block header has no non-empty 'kind:' field"
+        };
+    }
+    if (!VALID_MEMORY_KINDS.has(kind)) {
+        return {
+            ok: false,
+            reason: 'unknown-kind',
+            detail: `block declares kind '${kind}', which is not an accepted memory kind`
+        };
+    }
+    if (body.length === 0) {
+        return { ok: false, reason: 'empty-body', detail: 'block body is empty' };
+    }
+    return { ok: true, memory: { title, kind, body, sourceArtifact } };
+}
+/**
+ * `null`-on-failure projection of `parseBlockResult`. Kept because callers
+ * (and the parser's own contract) consume a plain nullable value; both views
+ * come from the one implementation above, so they cannot diverge.
+ */
+export function parseBlock(block, sourceArtifact) {
+    const parsed = parseBlockResult(block, sourceArtifact);
+    return parsed.ok ? parsed.memory : null;
+}
+export function renderMemoryFile(memory) {
+    const name = slugify(memory.title);
+    return [
+        '---',
+        `name: ${name}`,
+        `description: ${memory.title}`,
+        'metadata:',
+        `  type: ${memory.kind}`,
+        `  sourceArtifact: ${memory.sourceArtifact}`,
+        '---',
+        '',
+        memory.body,
+        ''
+    ].join('\n');
+}

package/dist/services/memory/project-memory-service/parsers/frontmatter.d.ts

@@ -1,27 +1,5 @@
-import type { ExtractedProjectMemory, MemoryBlockParse, ProjectMemoryKind, StoredProjectMemory } from '../types.js';
-/** Accepted-kind set, derived from the canonical `PROJECT_MEMORY_KINDS`
- *  tuple so the parser cannot drift from the union type / tier map. */
-export declare const VALID_MEMORY_KINDS: ReadonlySet<ProjectMemoryKind>;
-/** Exported for guard tests + tooling that needs to enumerate the accepted
- *  set (CLI help text, `--kind` validation) without duplicating the literal. */
-export declare const VALID_PROJECT_MEMORY_KINDS: readonly ProjectMemoryKind[];
-export declare function slugify(title: string): string;
-/**
- * Single implementation of the extract-path block parse. Returns a
- * discriminated result so the caller can say WHY a found block was rejected.
- *
- * The precondition order mirrors the original combined `if` exactly
- * (separator → title → kind present → kind valid → body non-empty), so the
- * accepted set is bit-for-bit what it always was; only the explanation is new.
- */
-export declare function parseBlockResult(block: string, sourceArtifact: string): MemoryBlockParse;
-/**
- * `null`-on-failure projection of `parseBlockResult`. Kept because callers
- * (and the parser's own contract) consume a plain nullable value; both views
- * come from the one implementation above, so they cannot diverge.
- */
-export declare function parseBlock(block: string, sourceArtifact: string): ExtractedProjectMemory | null;
-export declare function renderMemoryFile(memory: ExtractedProjectMemory): string;
+import type { ProjectMemoryKind, StoredProjectMemory } from '../types.js';
+export { parseBlock, parseBlockResult, renderMemoryFile, slugify, VALID_MEMORY_KINDS, VALID_PROJECT_MEMORY_KINDS } from './frontmatter-parse.js';
 /**
  * Where a stored memory file's `kind` came from. `'none'` means the file
  * has no resolvable kind (no `metadata.type`, no `kind:`, no `type:`, or

package/dist/services/memory/project-memory-service/parsers/frontmatter.js

@@ -20,82 +20,12 @@
 // `slugify` helper used to derive filenames from titles.
 // ---------------------------------------------------------------------------
 import { basename } from 'node:path';
-import { PROJECT_MEMORY_KINDS } from '../types.js';
-/** Accepted-kind set, derived from the canonical `PROJECT_MEMORY_KINDS`
- *  tuple so the parser cannot drift from the union type / tier map. */
-export const VALID_MEMORY_KINDS = new Set(PROJECT_MEMORY_KINDS);
-/** Exported for guard tests + tooling that needs to enumerate the accepted
- *  set (CLI help text, `--kind` validation) without duplicating the literal. */
-export const VALID_PROJECT_MEMORY_KINDS = PROJECT_MEMORY_KINDS;
-export function slugify(title) {
-    const slug = title.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
-    return slug.length > 0 ? slug : 'project-memory';
-}
-/**
- * Single implementation of the extract-path block parse. Returns a
- * discriminated result so the caller can say WHY a found block was rejected.
- *
- * The precondition order mirrors the original combined `if` exactly
- * (separator → title → kind present → kind valid → body non-empty), so the
- * accepted set is bit-for-bit what it always was; only the explanation is new.
- */
-export function parseBlockResult(block, sourceArtifact) {
-    const normalizedBlock = block.replace(/\r\n/g, '\n');
-    const separatorIndex = normalizedBlock.indexOf('\n---\n');
-    if (separatorIndex < 0) {
-        return { ok: false, reason: 'missing-separator', detail: "block header is not followed by a '---' separator line" };
-    }
-    const header = normalizedBlock.slice(0, separatorIndex).trim();
-    const body = normalizedBlock.slice(separatorIndex + '\n---\n'.length).trim();
-    const fields = new Map();
-    for (const line of header.split('\n')) {
-        const [key, ...valueParts] = line.split(':');
-        const normalizedKey = key?.trim();
-        const value = valueParts.join(':').trim();
-        if (normalizedKey && value) {
-            fields.set(normalizedKey, value);
-        }
-    }
-    const title = fields.get('title')?.trim();
-    const kind = fields.get('kind')?.trim();
-    if (!title) {
-        return { ok: false, reason: 'missing-title', detail: "block header has no non-empty 'title:' field" };
-    }
-    if (!kind) {
-        return { ok: false, reason: 'missing-kind', detail: "block header has no non-empty 'kind:' field" };
-    }
-    if (!VALID_MEMORY_KINDS.has(kind)) {
-        return { ok: false, reason: 'unknown-kind', detail: `block declares kind '${kind}', which is not an accepted memory kind` };
-    }
-    if (body.length === 0) {
-        return { ok: false, reason: 'empty-body', detail: 'block body is empty' };
-    }
-    return { ok: true, memory: { title, kind, body, sourceArtifact } };
-}
-/**
- * `null`-on-failure projection of `parseBlockResult`. Kept because callers
- * (and the parser's own contract) consume a plain nullable value; both views
- * come from the one implementation above, so they cannot diverge.
- */
-export function parseBlock(block, sourceArtifact) {
-    const parsed = parseBlockResult(block, sourceArtifact);
-    return parsed.ok ? parsed.memory : null;
-}
-export function renderMemoryFile(memory) {
-    const name = slugify(memory.title);
-    return [
-        '---',
-        `name: ${name}`,
-        `description: ${memory.title}`,
-        'metadata:',
-        `  type: ${memory.kind}`,
-        `  sourceArtifact: ${memory.sourceArtifact}`,
-        '---',
-        '',
-        memory.body,
-        ''
-    ].join('\n');
-}
+import { VALID_MEMORY_KINDS } from './frontmatter-parse.js';
+// The kind allow-list, the `slugify` helper, and the extract-path block
+// parser / renderer now live in `./frontmatter-parse.ts`. Re-exported here so
+// the `index.ts` barrel and `markdown-pure.ts` keep resolving them from
+// `./parsers/frontmatter.js` unchanged.
+export { parseBlock, parseBlockResult, renderMemoryFile, slugify, VALID_MEMORY_KINDS, VALID_PROJECT_MEMORY_KINDS } from './frontmatter-parse.js';
 /**
  * Resolve the peaks memory kind from a stored memory file's frontmatter.
  *
@@ -170,11 +100,21 @@ export function parseMemoryFrontmatter(content) {
     const normalized = content.replace(/\r\n/g, '\n');
     const head = normalized.slice(leadingCommentPrefixLength(normalized));
     if (!head.startsWith('---\n')) {
-        return { hasFrontmatter: false, kind: { kind: null, source: 'none', rawKind: null }, frontmatter: '', body: normalized.trim() };
+        return {
+            hasFrontmatter: false,
+            kind: { kind: null, source: 'none', rawKind: null },
+            frontmatter: '',
+            body: normalized.trim()
+        };
     }
     const endIndex = head.indexOf('\n---\n', 4);
     if (endIndex < 0) {
-        return { hasFrontmatter: false, kind: { kind: null, source: 'none', rawKind: null }, frontmatter: '', body: normalized.trim() };
+        return {
+            hasFrontmatter: false,
+            kind: { kind: null, source: 'none', rawKind: null },
+            frontmatter: '',
+            body: normalized.trim()
+        };
     }
     const frontmatter = head.slice(4, endIndex);
     const body = head.slice(endIndex + '\n---\n'.length).trim();
@@ -228,7 +168,16 @@ export function parseMemoryFrontmatter(content) {
             break;
         }
     }
-    return { hasFrontmatter: true, frontmatter, ...(name !== undefined ? { name } : {}), ...(titleField !== undefined ? { title: titleField } : {}), ...(description !== undefined ? { description } : {}), ...(sourceArtifact !== undefined ? { sourceArtifact } : {}), kind, body };
+    return {
+        hasFrontmatter: true,
+        frontmatter,
+        ...(name !== undefined ? { name } : {}),
+        ...(titleField !== undefined ? { title: titleField } : {}),
+        ...(description !== undefined ? { description } : {}),
+        ...(sourceArtifact !== undefined ? { sourceArtifact } : {}),
+        kind,
+        body
+    };
 }
 /**
  * Deterministic name fallback chain for the read path:

package/dist/services/memory/project-memory-service/parsers/markdown-pure.js

@@ -60,7 +60,9 @@ export function summarizeMemoryBody(body) {
         .replace(/^\s*[-*+]\s+/gm, '')
         .replace(/\n+/g, ' ')
         .trim();
-    const sentences = cleaned.split(/(?<=[.!?])\s+/).filter((s) => s.length > MIN_BODY_SENTENCE_LENGTH && !/^\[.+\]$/.test(s));
+    const sentences = cleaned
+        .split(/(?<=[.!?])\s+/)
+        .filter((s) => s.length > MIN_BODY_SENTENCE_LENGTH && !/^\[.+\]$/.test(s));
     if (sentences.length === 0) {
         return cleaned.slice(0, MAX_DESCRIPTION_LENGTH) || 'Project memory';
     }
@@ -101,7 +103,10 @@ export function extractStableProjectMemoriesWithDiagnostics(content, sourceArtif
             memories.push(parsed.memory);
         }
         else {
-            drops.push({ index: start, drop: { sourceArtifact, reason: parsed.reason, detail: parsed.detail } });
+            drops.push({
+                index: start,
+                drop: { sourceArtifact, reason: parsed.reason, detail: parsed.detail }
+            });
         }
         searchStart = end + END_MARKER.length;
     }
@@ -120,7 +125,14 @@ export function extractStableProjectMemoriesWithDiagnostics(content, sourceArtif
         const index = match.index ?? 0;
         if (locatedRanges.some(([from, to]) => index >= from && index < to))
             continue;
-        drops.push({ index, drop: { sourceArtifact, reason: 'unrecognized-marker', detail: describeUnrecognizedMarker(found) } });
+        drops.push({
+            index,
+            drop: {
+                sourceArtifact,
+                reason: 'unrecognized-marker',
+                detail: describeUnrecognizedMarker(found)
+            }
+        });
     }
     drops.sort((left, right) => left.index - right.index);
     return {

package/dist/services/memory/project-memory-service/store/atomic-write.d.ts

@@ -24,6 +24,12 @@ export declare const SENSITIVE_MEMORY_CHECKS: {
  * a value — so echoing it into the error envelope cannot leak anything.
  */
 export declare function findSensitiveMemoryTitleTerm(title: string): string | null;
+/**
+ * Which content rule refused this text — the id, never the match. A rule whose
+ * candidate fails `shaped` does not stop the scan: a later rule may still fire,
+ * exactly as a later alternative in the old `||` chain would have.
+ */
+export declare function findSensitiveMemoryContentRule(content: string): string | null;
 export declare function hasSensitiveMemoryContent(content: string): boolean;
 /**
  * The refusal `assertSafeMemory` raises: the check that fired and the term it
@@ -42,19 +48,25 @@ export declare function hasSensitiveMemoryContent(content: string): boolean;
  * `check` for the same reason — a substring test against a message whose words
  * can be rewritten is not a routing rule, it is a guess.
  *
- * NOTHING HERE WEAKENS THE REDACTOR. The content scan never puts its match in
- * this object (see `matchedTerm` below), so no value can reach an envelope
- * through it; the redactor's guarantee is intact and is pinned by the cases in
+ * NOTHING HERE WEAKENS THE REDACTOR. Both scans put a NAME in this field, never
+ * a match: the title term comes from `SENSITIVE_PROSE_TERMS` and the content
+ * value from the closed id list in `SENSITIVE_CONTENT_RULES`, so no credential
+ * can reach an envelope through it. The redactor's guarantee over `message` is
+ * intact and is pinned by the cases in
  * `tests/unit/services/memory/memory-title-sensitive-scan.test.ts`.
  */
 export declare class UnsafeMemoryError extends Error {
     /** One of `SENSITIVE_MEMORY_CHECKS` — which rule refused the write. */
     readonly check: string;
     /**
-     * The credential term the TITLE scan matched, or `null` for the other two
-     * checks. `null` is not an omission: their match can BE the credential
-     * (`ghp_…`, the PEM header, the JWT), which is why their messages describe
-     * the pattern family and never echo the text.
+     * WHAT matched, as a name rather than a value: the credential term for the
+     * title scan, the rule id for the content scan, `null` only for the metadata
+     * key scan (whose predicate answers by a config-key vocabulary the memory
+     * metadata never contains — see the note on `assertSafeMemory`).
+     *
+     * It is never the match itself: for most content patterns the match IS the
+     * credential (`ghp_…`, the PEM header, the JWT), which is why their messages
+     * describe the pattern family and never echo the text.
      */
     readonly matchedTerm: string | null;
     constructor(check: string, detail: string, matchedTerm?: string | null);

package/dist/services/memory/project-memory-service/store/atomic-write.js

@@ -4,7 +4,9 @@
 //   - `hasSensitiveMemoryContent` — pattern check for api keys, tokens,
 //     PEM private keys, JWTs, GitHub / GitLab tokens, AWS access keys. Used
 //     both by the extract path (`assertSafeMemory`) and the backup path
-//     (`assertSafeMemoryFileContent`).
+//     (`assertSafeMemoryFileContent`). It is a wrapper over
+//     `findSensitiveMemoryContentRule`, which answers the same question and
+//     names the rule that answered it.
 //   - `findSensitiveMemoryTitleTerm` — the PROSE predicate for
 //     `memory.title`. It is deliberately NOT the config-key predicate: see
 //     the block comment above it (slice C0).
@@ -77,20 +79,32 @@ const SENSITIVE_MEMORY_REFUSAL = 'Refusing to store sensitive memory content';
  * predicate exists to end.
  */
 const SENSITIVE_PROSE_TERMS = new Set([
-    'apikey', 'apikeys',
-    'accesskey', 'accesskeys',
-    'privatekey', 'privatekeys',
-    'secretkey', 'secretkeys',
-    'accesstoken', 'accesstokens',
-    'authtoken', 'authtokens',
-    'authkey', 'authkeys',
-    'refreshtoken', 'refreshtokens',
-    'token', 'tokens',
-    'secret', 'secrets',
-    'password', 'passwords',
+    'apikey',
+    'apikeys',
+    'accesskey',
+    'accesskeys',
+    'privatekey',
+    'privatekeys',
+    'secretkey',
+    'secretkeys',
+    'accesstoken',
+    'accesstokens',
+    'authtoken',
+    'authtokens',
+    'authkey',
+    'authkeys',
+    'refreshtoken',
+    'refreshtokens',
+    'token',
+    'tokens',
+    'secret',
+    'secrets',
+    'password',
+    'passwords',
     'passwd',
     'bearer',
-    'credential', 'credentials'
+    'credential',
+    'credentials'
 ]);
 /** A lower→upper transition: the boundary between the words of `apiKey`. */
 const CAMEL_CASE_BOUNDARY = /([a-z0-9])([A-Z])/g;
@@ -124,17 +138,89 @@ export function findSensitiveMemoryTitleTerm(title) {
     }
     return null;
 }
+/**
+ * Is this string shaped like a credential VALUE rather than like prose?
+ *
+ * WHY THIS EXISTS. The value-carrying patterns used to fire on the SEPARATOR
+ * alone: `password:` was a match whether or not anything followed it, so a
+ * memory writing `password: the field label in the form` or `myApiKey: from
+ * env` was refused for describing an interface. Two documents were killed that
+ * way before anyone could say which of ten rules had fired — and the rules
+ * could not be tightened, because nothing in them described the VALUE.
+ *
+ * THE TEST, AND WHAT IT COSTS. A value is credential-shaped when it is at least
+ * 5 characters AND carries a digit or one of `_ + / =`. `hunter2`,
+ * `abcdef123456`, `supp3rSecret` and every base64-ish token pass;
+ * `Authorization`, `the`, `from`, `abc`, `well-designed` fail. Given up
+ * deliberately: an all-letter opaque run (`bearer abcdefghijklmnopq`) is no
+ * longer caught, and neither is a 4-character real password. The alternative was
+ * a rule that cannot tell an English word from a random string, and the
+ * complaint on record is about English words. Digits are the discriminator
+ * rather than `-` and `.` because hyphens and full stops belong to ordinary
+ * prose; provider tokens in the wild carry digits, and the prefix-shaped
+ * patterns (`ghp_`, `AKIA`, the PEM header, the JWT) keep their own length floors
+ * and are untouched by this predicate.
+ */
+const MIN_VALUE_CHARS = 5;
+function isCredentialShapedValue(value) {
+    return value.length >= MIN_VALUE_CHARS && /[0-9_+/=]/.test(value);
+}
+/** A placeholder names where a value will go; it is not itself a secret. */
+const PLACEHOLDER_VALUE = /^[<[{(]|^(?:your|the|an|some|my|example|placeholder|todo|fake)/i;
+function isPlaceholderValue(value) {
+    return (PLACEHOLDER_VALUE.test(value) ||
+        /(?:replace|insert|provide|redact|<[a-z_]+>)/i.test(value) ||
+        /^[A-Za-z]+(?:_[A-Z*]+)+$/.test(value) // API_KEY_HERE-style constant
+    );
+}
+const SENSITIVE_CONTENT_RULES = [
+    {
+        id: 'credential-assignment',
+        pattern: /\b(?:api[_-]?key|access[_-]?token|auth[_-]?token|refresh[_-]?token|secret|password|passwd|credential|token|bearer)\s*[:=]\s*([^\s,;"'`]+)/gi,
+        shaped: (value) => isCredentialShapedValue(value) && !isPlaceholderValue(value)
+    },
+    {
+        id: 'authorization-bearer-header',
+        pattern: /\bauthorization\s*:\s*bearer\s+([^\s,;"'`]+)/gi,
+        shaped: (value) => isCredentialShapedValue(value) && !isPlaceholderValue(value)
+    },
+    {
+        id: 'bearer-value',
+        pattern: /\bbearer\s+([A-Za-z0-9._~+/=-]{8,})/gi,
+        shaped: (value) => isCredentialShapedValue(value) && !isPlaceholderValue(value)
+    },
+    {
+        id: 'sk-prefixed-key',
+        // The SUFFIX is captured, not the whole `sk-…`: `sk-abcdef is the prefix`
+        // is a sentence about the scheme, and the shape test on the suffix is what
+        // tells it from `sk-abcdef1234567890`.
+        pattern: /\bsk-([A-Za-z0-9_-]{6,})\b/g,
+        shaped: (value) => isCredentialShapedValue(value) && !isPlaceholderValue(value)
+    },
+    { id: 'gh-prefixed-key', pattern: /\bgh[pousr]_[A-Za-z0-9_]{20,}\b/g },
+    { id: 'github-pat', pattern: /\bgithub_pat_[A-Za-z0-9_]{20,}\b/g },
+    { id: 'glpat-prefixed-key', pattern: /\bglpat-[A-Za-z0-9_-]{20,}\b/g },
+    { id: 'akia-prefixed-key', pattern: /\bAKIA[0-9A-Z]{16}\b/g },
+    { id: 'pem-private-key', pattern: /-----BEGIN [A-Z ]*PRIVATE KEY-----/g },
+    { id: 'jwt-shaped-value', pattern: /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/g }
+];
+/**
+ * Which content rule refused this text — the id, never the match. A rule whose
+ * candidate fails `shaped` does not stop the scan: a later rule may still fire,
+ * exactly as a later alternative in the old `||` chain would have.
+ */
+export function findSensitiveMemoryContentRule(content) {
+    for (const rule of SENSITIVE_CONTENT_RULES) {
+        for (const match of content.matchAll(rule.pattern)) {
+            const candidate = match[1] ?? match[0];
+            if (rule.shaped === undefined || rule.shaped(candidate))
+                return rule.id;
+        }
+    }
+    return null;
+}
 export function hasSensitiveMemoryContent(content) {
-    return /(?:api[_-]?key|token|secret|password|credential|bearer)\s*[:=]/i.test(content)
-        || /\bauthorization\s*:\s*bearer\s+\S+/i.test(content)
-        || /\bbearer\s+[A-Za-z0-9._~+/=-]{12,}\b/i.test(content)
-        || /\bsk-[A-Za-z0-9_-]{6,}\b/.test(content)
-        || /\bgh[pousr]_[A-Za-z0-9_]{20,}\b/.test(content)
-        || /\bgithub_pat_[A-Za-z0-9_]{20,}\b/.test(content)
-        || /\bglpat-[A-Za-z0-9_-]{20,}\b/.test(content)
-        || /\bAKIA[0-9A-Z]{16}\b/.test(content)
-        || /-----BEGIN [A-Z ]*PRIVATE KEY-----/.test(content)
-        || /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/.test(content);
+    return findSensitiveMemoryContentRule(content) !== null;
 }
 /**
  * The refusal `assertSafeMemory` raises: the check that fired and the term it
@@ -153,19 +239,25 @@ export function hasSensitiveMemoryContent(content) {
  * `check` for the same reason — a substring test against a message whose words
  * can be rewritten is not a routing rule, it is a guess.
  *
- * NOTHING HERE WEAKENS THE REDACTOR. The content scan never puts its match in
- * this object (see `matchedTerm` below), so no value can reach an envelope
- * through it; the redactor's guarantee is intact and is pinned by the cases in
+ * NOTHING HERE WEAKENS THE REDACTOR. Both scans put a NAME in this field, never
+ * a match: the title term comes from `SENSITIVE_PROSE_TERMS` and the content
+ * value from the closed id list in `SENSITIVE_CONTENT_RULES`, so no credential
+ * can reach an envelope through it. The redactor's guarantee over `message` is
+ * intact and is pinned by the cases in
  * `tests/unit/services/memory/memory-title-sensitive-scan.test.ts`.
  */
 export class UnsafeMemoryError extends Error {
     /** One of `SENSITIVE_MEMORY_CHECKS` — which rule refused the write. */
     check;
     /**
-     * The credential term the TITLE scan matched, or `null` for the other two
-     * checks. `null` is not an omission: their match can BE the credential
-     * (`ghp_…`, the PEM header, the JWT), which is why their messages describe
-     * the pattern family and never echo the text.
+     * WHAT matched, as a name rather than a value: the credential term for the
+     * title scan, the rule id for the content scan, `null` only for the metadata
+     * key scan (whose predicate answers by a config-key vocabulary the memory
+     * metadata never contains — see the note on `assertSafeMemory`).
+     *
+     * It is never the match itself: for most content patterns the match IS the
+     * credential (`ghp_…`, the PEM header, the JWT), which is why their messages
+     * describe the pattern family and never echo the text.
      */
     matchedTerm;
     constructor(check, detail, matchedTerm = null) {
@@ -181,19 +273,28 @@ export function assertSafeMemory(memory) {
     if (containsSensitiveConfigValue(metadata)) {
         throw new UnsafeMemoryError(SENSITIVE_MEMORY_CHECKS.metadataKey, 'matched a credential key in the memory metadata');
     }
-    if (hasSensitiveMemoryContent(content)) {
-        // The match is deliberately NOT echoed, in the message or in the error's
-        // fields: for most of these patterns the match IS the credential, so
+    const contentRule = findSensitiveMemoryContentRule(content);
+    if (contentRule !== null) {
+        // The matched TEXT is deliberately NOT echoed, in the message or in the
+        // error's fields: for most of these patterns the match IS the credential, so
         // copying it would write the value this scan exists to keep out.
         //
+        // The RULE ID is echoed, and it is echoed in `matchedTerm` rather than only
+        // in prose. This used to be the one refusal that could not say what fired:
+        // the predicate returned a boolean, so the caller had no match to report and
+        // `matchedTerm` was `null` by construction while the title scan named its
+        // term. A reader then had to guess across documents which of ten shapes had
+        // refused them. An id from a closed vocabulary leaks nothing and answers the
+        // question, so the two paths are diagnosable the same way.
+        //
         // The DETAIL is worded around the envelope redactor's vocabulary on
         // purpose. Its catch-all (`/(secret|token|password|api[-_ ]?key)/gi`)
         // rewrites those four words wherever they appear in a failure message, so
         // naming the pattern families in their own words arrives on the CLI as
         // "an [redacted] / [redacted] / [redacted] assignment" — a remedy sentence
-        // redacted into uselessness by the very policy it agrees with. Measured on
-        // the real CLI, both wordings; this one survives intact.
-        throw new UnsafeMemoryError(SENSITIVE_MEMORY_CHECKS.content, 'matched a credential value in the memory content (a `key=value` credential assignment, a Bearer header, a PEM private key, a JWT, or a provider credential)');
+        // redacted into uselessness by the very policy it agrees with. The rule ids
+        // above are spelled to survive that pass.
+        throw new UnsafeMemoryError(SENSITIVE_MEMORY_CHECKS.content, `matched the credential pattern "${contentRule}" in the memory content`, contentRule);
     }
     const titleTerm = findSensitiveMemoryTitleTerm(memory.title);
     if (titleTerm !== null) {
@@ -201,8 +302,13 @@ export function assertSafeMemory(memory) {
     }
 }
 export function assertSafeMemoryFileContent(content) {
-    if (hasSensitiveMemoryContent(content)) {
-        throw new Error('Refusing to back up sensitive memory content');
+    const rule = findSensitiveMemoryContentRule(content);
+    if (rule !== null) {
+        // The id travels here too. This path has no `UnsafeMemoryError` (it is not
+        // the extract gate, and its callers do not route on `check`), but a backup
+        // refusal that cannot say which shape fired is the same dead end as the one
+        // the extract path used to be.
+        throw new Error(`Refusing to back up sensitive memory content (rule: ${rule})`);
     }
 }
 export function writeNewFile(path, content) {

package/dist/services/memory/project-memory-service/store/paths.js

@@ -93,7 +93,8 @@ export function safeRealpath(path) {
     try {
         return realpathSync(path);
     }
-    catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
+    catch {
+        // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
         return null;
     }
 }

package/dist/services/memory/project-memory-service/types.d.ts

@@ -1,34 +1,6 @@
-/**
- * Canonical memory-kind vocabulary — the single source of truth.
- *
- * The union type, the accepted-kind set in the frontmatter parser, the
- * hot/warm tier map below, `KIND_ORDER` in the reindex view, and the CLI
- * `--kind` help text all derive from this tuple. Adding a kind here is the
- * only edit required; TypeScript then forces `MEMORY_KIND_TIER` to cover it.
- *
- * Slice 2026-09-10-memory-vocab-and-rotate (E): the original 8 kinds are
- * unchanged. The 13 appended kinds were observed on disk with real values
- * that the index schema rejected (`peaks memory reindex` reported them as
- * `unrecognized kind value`). Accepting them moves those files into the
- * index; files with no kind field at all stay reported as unclassified.
- */
-export declare const PROJECT_MEMORY_KINDS: readonly ["project", "rule", "decision", "reference", "feedback", "convention", "module", "lesson", "bug", "investigation", "technical-pattern", "project-rule", "design", "handoff", "session-handoff", "project-todo", "publish-closure", "project-closure", "slice-closure", "slice-pilot-findings", "sediment"];
-export type ProjectMemoryKind = (typeof PROJECT_MEMORY_KINDS)[number];
-/** Hot kinds keep their body in the always-available index; warm kinds are
- *  indexed with the same entry shape but read on demand. */
-export type MemoryKindTier = 'hot' | 'warm';
-/**
- * Hot/warm tier per kind. Insertion order IS the deterministic section order
- * used by the generated `MEMORY.md` (`KIND_ORDER` in `index/reindex.ts`),
- * so this object's key order is load-bearing — append new kinds at the end
- * of their tier block rather than reshuffling existing entries.
- *
- * The `Record<ProjectMemoryKind, MemoryKindTier>` annotation makes a missing
- * tier a compile error whenever `PROJECT_MEMORY_KINDS` grows.
- */
-export declare const MEMORY_KIND_TIER: Record<ProjectMemoryKind, MemoryKindTier>;
-export declare const HOT_MEMORY_KINDS: readonly ProjectMemoryKind[];
-export declare const WARM_MEMORY_KINDS: readonly ProjectMemoryKind[];
+import type { ProjectMemoryKind } from './memory-kinds.js';
+export { HOT_MEMORY_KINDS, MEMORY_KIND_TIER, PROJECT_MEMORY_KINDS, WARM_MEMORY_KINDS } from './memory-kinds.js';
+export type { MemoryKindTier, ProjectMemoryKind } from './memory-kinds.js';
 export type ExtractedProjectMemory = {
     title: string;
     kind: ProjectMemoryKind;