aiden-runtime 4.8.1 → 4.9.1

package/dist/core/v4/memory/namespaceRegistry.js

@@ -0,0 +1,117 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * core/v4/memory/namespaceRegistry.ts — v4.9.0 Slice 11.
+ *
+ * Generalizes Aiden's two-file memory model (`memory` + `user`) to a
+ * registry. Adds a third default namespace — `project` — keyed off
+ * the caller's current working directory. The registry is the single
+ * authority every other surface (tool schemas, CLI parser, prompt
+ * injector, reviewer, backup) consults; adding a namespace is one
+ * registration call instead of an N-place patch.
+ *
+ * Slice 11 ships THREE default namespaces:
+ *
+ *   memory   — Aiden environment / project & technical notes.    2200 chars
+ *   user     — User identity / preferences / workflow style.     1375 chars
+ *   project  — Per-project context at `<projectRoot>/.aiden/PROJECT.md`. 1800 chars
+ *
+ * The `'memory'` vs `'project'` distinction:
+ *   - `memory` is GLOBAL per-install (Aiden-wide notes).
+ *   - `project` is PER-DIRECTORY (one PROJECT.md per repo / workdir).
+ *
+ * Char limit for `project` (1800) sits between `user` (1375) and the
+ * legacy `memory` (2200) — project context is verbose but not as
+ * verbose as full environment notes.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNamespace = getNamespace;
+exports.hasNamespace = hasNamespace;
+exports.listNamespaces = listNamespaces;
+exports.listNamespaceNames = listNamespaceNames;
+exports.registerNamespace = registerNamespace;
+exports._resetNamespacesForTests = _resetNamespacesForTests;
+const node_path_1 = __importDefault(require("node:path"));
+const BUILTIN = [
+    {
+        name: 'memory',
+        label: 'Memory (project & environment)',
+        description: 'Global notes about Aiden\'s environment + this project.',
+        charLimit: 2200,
+        injectIntoPrompt: true,
+        promptHeader: 'Project & Environment',
+        resolve: (paths) => paths.memoryMd,
+    },
+    {
+        name: 'user',
+        label: 'User (identity & preferences)',
+        description: 'User identity, preferences, workflow style.',
+        charLimit: 1375,
+        injectIntoPrompt: true,
+        promptHeader: 'User Identity & Preferences',
+        resolve: (paths) => paths.userMd,
+    },
+    {
+        name: 'project',
+        label: 'Project (per-repo context)',
+        description: 'Per-project context at <projectRoot>/.aiden/PROJECT.md.',
+        charLimit: 1800,
+        injectIntoPrompt: true,
+        promptHeader: 'Current Project Context',
+        requiresProject: true,
+        resolve: (_paths, projectRoot) => {
+            if (!projectRoot) {
+                throw new Error('project namespace requires a project root (run from inside a git repo or directory with .aiden/PROJECT.md)');
+            }
+            return node_path_1.default.join(projectRoot, '.aiden', 'PROJECT.md');
+        },
+    },
+];
+const REGISTRY = new Map(BUILTIN.map((n) => [n.name, n]));
+/** Throw-on-unknown getter. Callers MUST check `has()` first if the
+ *  name is user-supplied — `getNamespace` is for trusted callsites. */
+function getNamespace(name) {
+    const ns = REGISTRY.get(name);
+    if (!ns) {
+        const known = Array.from(REGISTRY.keys()).join(', ');
+        throw new Error(`unknown memory namespace '${name}' (known: ${known})`);
+    }
+    return ns;
+}
+/** Soft check — does this name resolve to a registered namespace. */
+function hasNamespace(name) {
+    return REGISTRY.has(name);
+}
+/** Iteration order matches registration order. */
+function listNamespaces() {
+    return Array.from(REGISTRY.values());
+}
+/** Names only — for tool schema enums + CLI argument validation. */
+function listNamespaceNames() {
+    return Array.from(REGISTRY.keys());
+}
+/**
+ * Reserved for v4.10+ user-defined namespaces (plugins). Not wired to
+ * config.yaml or plugin loaders in this slice; the entry point exists
+ * so the runtime can extend without further refactor.
+ */
+function registerNamespace(ns) {
+    if (REGISTRY.has(ns.name)) {
+        throw new Error(`memory namespace '${ns.name}' is already registered`);
+    }
+    REGISTRY.set(ns.name, ns);
+}
+/** Test seam — restore registry to the three built-ins. */
+function _resetNamespacesForTests() {
+    REGISTRY.clear();
+    for (const ns of BUILTIN)
+        REGISTRY.set(ns.name, ns);
+}

package/dist/core/v4/memory/projectRoot.js

@@ -0,0 +1,76 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * core/v4/memory/projectRoot.ts — v4.9.0 Slice 11.
+ *
+ * Walk-up project-root detection. Returns the first ancestor of
+ * `cwd` containing any of the standard project anchors:
+ *
+ *   .git/                    most repos
+ *   package.json             Node
+ *   pyproject.toml           Python
+ *   Cargo.toml               Rust
+ *   go.mod                   Go
+ *   .aiden/PROJECT.md        explicit Aiden-managed project
+ *
+ * Returns `null` when the walk reaches the filesystem root without
+ * finding any anchor. Result is cached per-process keyed on the
+ * normalised cwd; the cache is cleared via `_resetProjectRootCacheForTests`.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findProjectRoot = findProjectRoot;
+exports._resetProjectRootCacheForTests = _resetProjectRootCacheForTests;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const ANCHORS = [
+    '.git',
+    'package.json',
+    'pyproject.toml',
+    'Cargo.toml',
+    'go.mod',
+    node_path_1.default.join('.aiden', 'PROJECT.md'),
+];
+const _cache = new Map();
+/**
+ * Walk up from `cwd` looking for an anchor. Returns the absolute path
+ * of the directory holding the first anchor, or `null` when nothing
+ * is found before filesystem root. Cached per `cwd`.
+ */
+function findProjectRoot(cwd = process.cwd()) {
+    const startedAt = node_path_1.default.resolve(cwd);
+    if (_cache.has(startedAt))
+        return _cache.get(startedAt);
+    let current = startedAt;
+    // Cap the walk at 64 levels — pathological symlink loops shouldn't burn.
+    for (let i = 0; i < 64; i += 1) {
+        for (const anchor of ANCHORS) {
+            const probe = node_path_1.default.join(current, anchor);
+            try {
+                const stat = node_fs_1.default.statSync(probe);
+                if (stat.isFile() || stat.isDirectory()) {
+                    _cache.set(startedAt, current);
+                    return current;
+                }
+            }
+            catch { /* ENOENT — keep looking */ }
+        }
+        const parent = node_path_1.default.dirname(current);
+        if (parent === current)
+            break; // reached filesystem root
+        current = parent;
+    }
+    _cache.set(startedAt, null);
+    return null;
+}
+/** Test seam — clear the per-process cache. */
+function _resetProjectRootCacheForTests() {
+    _cache.clear();
+}

package/dist/core/v4/memory/reviewer/index.js

@@ -0,0 +1,162 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * core/v4/memory/reviewer/index.ts — v4.9.0 Slice 10.
+ *
+ * Orchestrator for the post-turn memory reviewer. Pure functions +
+ * one entry point `runReview(opts)`. The LLM call is injected as a
+ * callback so the reviewer is testable + provider-agnostic — the CLI
+ * wires the callback to whatever provider the user has configured.
+ *
+ * Fail-open guarantees (project rule): any error in the reviewer
+ * (LLM timeout, parse error, file write error) is caught + logged
+ * but NEVER propagated to the user. `runReview` returns a structured
+ * outcome envelope; the CLI surfaces it humanely.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runReview = runReview;
+exports.stripPendingSections = stripPendingSections;
+const prompt_1 = require("./prompt");
+const skipRules_1 = require("./skipRules");
+const pendingStore_1 = require("./pendingStore");
+const memoryManager_1 = require("../../memoryManager");
+const namespaceRegistry_1 = require("../namespaceRegistry");
+/**
+ * Run one review pass. Always resolves (never throws). Use the
+ * returned outcome envelope to surface humanely.
+ */
+async function runReview(opts) {
+    const start = Date.now();
+    const log = opts.log ?? (() => { });
+    try {
+        // Build prompt. Strip pending sections from the "live" snapshots so the
+        // reviewer doesn't see its own past proposals as duplicates.
+        const liveMemory = stripPendingSections(opts.liveMemoryRaw);
+        const liveUser = stripPendingSections(opts.liveUserRaw);
+        const prompt = (0, prompt_1.buildReviewerPrompt)({
+            recentTurns: opts.recentTurns,
+            liveMemory,
+            liveUser,
+            maxCandidates: opts.maxCandidates,
+        });
+        // LLM call inside a timeout race.
+        const raw = await raceTimeout(opts.callLLM(prompt), opts.timeoutMs);
+        if (raw === TIMEOUT_SENTINEL) {
+            log('warn', '[memory-reviewer] timeout — no candidates produced');
+            return { outcome: 'timeout', durationMs: Date.now() - start };
+        }
+        // Parse + skip-rule validate.
+        const { candidates: parsed, parserDrops } = (0, prompt_1.parseReviewerResponse)(raw);
+        const liveMemoryEntries = splitLiveEntries(liveMemory);
+        const liveUserEntries = splitLiveEntries(liveUser);
+        const dropsByClass = {
+            sensitive_class: 0, negation: 0, transient: 0, duplicate: 0, char_cap: 0,
+            no_project_root: 0, parser: parserDrops,
+        };
+        // v4.9.0 Slice 11 — per-namespace kept buckets so `project`
+        // (and future namespaces) flow through the same path as memory/user.
+        const keptByNamespace = new Map();
+        for (const c of parsed) {
+            let total = 0;
+            for (const arr of keptByNamespace.values())
+                total += arr.length;
+            if (total >= opts.maxCandidates)
+                break;
+            // Skip-rule: `requiresProject` namespace + no detected root → drop.
+            try {
+                const ns = (0, namespaceRegistry_1.getNamespace)(c.file);
+                if (ns.requiresProject && !opts.projectRoot) {
+                    dropsByClass.no_project_root += 1;
+                    log('info', `[memory-reviewer] skipped (no_project_root): "${c.text.slice(0, 60)}"`);
+                    continue;
+                }
+            }
+            catch { /* unknown namespace — parser already dropped these but defensive */ }
+            const live = c.file === 'user' ? liveUserEntries : liveMemoryEntries;
+            const decision = (0, skipRules_1.evaluateCandidate)(c.text, live);
+            if (decision.drop && decision.klass) {
+                dropsByClass[decision.klass] += 1;
+                log('info', `[memory-reviewer] skipped (${decision.klass}): "${c.text.slice(0, 60)}"`);
+                continue;
+            }
+            const bucket = keptByNamespace.get(c.file) ?? [];
+            bucket.push({ text: c.text, rationale: c.rationale });
+            keptByNamespace.set(c.file, bucket);
+        }
+        // Append into pending sections — one call per namespace.
+        const candidatesProposed = [];
+        for (const [nsName, kept] of keptByNamespace) {
+            let targetPath;
+            if (nsName === 'memory')
+                targetPath = opts.memoryPath;
+            else if (nsName === 'user')
+                targetPath = opts.userPath;
+            else if (opts.paths) {
+                try {
+                    targetPath = (0, namespaceRegistry_1.getNamespace)(nsName).resolve(opts.paths, opts.projectRoot ?? null);
+                }
+                catch {
+                    continue; /* skip — already counted in no_project_root */
+                }
+            }
+            else {
+                continue;
+            }
+            const stamped = await (0, pendingStore_1.appendCandidates)(targetPath, nsName, kept);
+            candidatesProposed.push(...stamped);
+        }
+        log('info', `[memory-reviewer] review complete: proposed=${candidatesProposed.length} ` +
+            `parser_drops=${parserDrops} ` +
+            `rule_drops=${Object.entries(dropsByClass).filter(([k]) => k !== 'parser').map(([k, v]) => `${k}:${v}`).join(' ')}`);
+        return {
+            outcome: 'ok',
+            candidatesProposed,
+            dropsByClass,
+            llmCharsIn: prompt.length,
+            llmCharsOut: raw.length,
+            durationMs: Date.now() - start,
+        };
+    }
+    catch (e) {
+        const error = e instanceof Error ? e.message : String(e);
+        log('error', `[memory-reviewer] error (fail-open): ${error}`);
+        return { outcome: 'error', error, durationMs: Date.now() - start };
+    }
+}
+const TIMEOUT_SENTINEL = Symbol('memoryReviewerTimeout');
+async function raceTimeout(p, ms) {
+    let timer = null;
+    const timeout = new Promise((resolve) => {
+        timer = setTimeout(() => resolve(TIMEOUT_SENTINEL), ms);
+    });
+    try {
+        const result = await Promise.race([p, timeout]);
+        if (timer)
+            clearTimeout(timer);
+        return result;
+    }
+    catch (e) {
+        if (timer)
+            clearTimeout(timer);
+        throw e;
+    }
+}
+/**
+ * Strip `## Pending review` blocks from a raw file so the reviewer
+ * doesn't see its own prior candidates as "live entries".
+ */
+function stripPendingSections(raw) {
+    if (!raw.includes('## Pending review'))
+        return raw;
+    return raw.replace(/\n*§?\n*## Pending review[\s\S]*?(?=(?:\n§\n)|$)/g, '').trimEnd();
+}
+function splitLiveEntries(raw) {
+    if (!raw.trim())
+        return [];
+    return raw.split(memoryManager_1.ENTRY_SEPARATOR).map((e) => e.trim()).filter((e) => e.length > 0);
+}

package/dist/core/v4/memory/reviewer/pendingStore.js

@@ -0,0 +1,136 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * core/v4/memory/reviewer/pendingStore.ts — v4.9.0 Slice 10.
+ *
+ * Read + append the `## Pending review` markdown section on MEMORY.md /
+ * USER.md. The section is delimited by the entry separator (`\n§\n`)
+ * before the markdown header, so live entries remain unaffected by
+ * pending candidates. Format:
+ *
+ *   <live entries, separated by \n§\n>
+ *   §
+ *   ## Pending review (2026-05-22T12:00:00Z)
+ *   - [ ] mem_<uuidv7>  | <text>  | <rationale>
+ *
+ * `parsePending` extracts the candidate list; `appendCandidates`
+ * appends one ## Pending review block per call (idempotent on no-op).
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appendCandidates = appendCandidates;
+exports.listPending = listPending;
+exports.dropCandidate = dropCandidate;
+exports.listAllPending = listAllPending;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const identity_1 = require("../../identity");
+const memoryManager_1 = require("../../memoryManager");
+const PENDING_HEADER_RE = /^## Pending review/m;
+const CANDIDATE_LINE_RE = /^- \[ \] (mem_[0-9a-f]{32})\s*\|\s*([^|]+?)\s*\|\s*(.+)$/;
+/** Read the file (or empty string) without throwing on ENOENT. */
+async function readOrEmpty(path) {
+    try {
+        return await node_fs_1.promises.readFile(path, 'utf8');
+    }
+    catch (e) {
+        if (e.code === 'ENOENT')
+            return '';
+        throw e;
+    }
+}
+/**
+ * Append a batch of candidates to the file as a fresh `## Pending review`
+ * block (markdown, after a separator). Atomic write via tmp + rename.
+ * Returns the list of memIds that were stamped onto the candidates.
+ */
+async function appendCandidates(filePath, file, inputs, proposedAtIso = new Date().toISOString()) {
+    if (inputs.length === 0)
+        return [];
+    const stamped = inputs.map((c) => ({
+        memId: (0, identity_1.newMemoryId)(),
+        file,
+        text: c.text.trim(),
+        rationale: c.rationale.trim(),
+        proposedAt: proposedAtIso,
+    }));
+    const block = [
+        memoryManager_1.ENTRY_SEPARATOR,
+        `## Pending review (${proposedAtIso})`,
+        ...stamped.map((c) => `- [ ] ${c.memId}  | ${c.text}  | ${c.rationale}`),
+        '',
+    ].join('\n');
+    const existing = await readOrEmpty(filePath);
+    const next = existing.endsWith('\n') || existing.length === 0
+        ? existing + block
+        : existing + '\n' + block;
+    // Atomic write: ensure parent dir exists (first-run case where
+    // memories/ hasn't been created yet), then tmp + rename.
+    await node_fs_1.promises.mkdir(node_path_1.default.dirname(filePath), { recursive: true });
+    const tmp = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+    await node_fs_1.promises.writeFile(tmp, next, 'utf8');
+    await node_fs_1.promises.rename(tmp, filePath);
+    return stamped;
+}
+/** Parse the `## Pending review` candidates out of a file. */
+async function listPending(filePath) {
+    const raw = await readOrEmpty(filePath);
+    if (!PENDING_HEADER_RE.test(raw))
+        return [];
+    // Default file shape: pending lives at end of file. Walk every line
+    // checking the candidate line shape — the proposedAt is associated
+    // with the most-recent `## Pending review (...)` header above each
+    // run of candidate lines.
+    const out = [];
+    let currentTs = new Date().toISOString();
+    for (const line of raw.split(/\r?\n/)) {
+        const hMatch = /^## Pending review \(([^)]+)\)\s*$/.exec(line);
+        if (hMatch) {
+            currentTs = hMatch[1];
+            continue;
+        }
+        const cMatch = CANDIDATE_LINE_RE.exec(line);
+        if (cMatch) {
+            out.push({
+                memId: cMatch[1],
+                // Caller knows which file this came from; we set 'memory' as a
+                // placeholder so the type checker stays happy — the CLI overrides
+                // this from the caller-side file context.
+                file: 'memory',
+                text: cMatch[2].trim(),
+                rationale: cMatch[3].trim(),
+                proposedAt: currentTs,
+            });
+        }
+    }
+    return out;
+}
+/** Drop ONE candidate by memId from the file's pending blocks. Atomic. */
+async function dropCandidate(filePath, memId) {
+    const raw = await readOrEmpty(filePath);
+    if (!raw.includes(memId))
+        return false;
+    const next = raw
+        .split(/\r?\n/)
+        .filter((line) => !line.includes(memId))
+        .join('\n');
+    // Clean up orphan `## Pending review (...)` headers whose lines are gone.
+    const cleaned = next.replace(/## Pending review \([^)]*\)\s*\n(?=\n*## |\n*§|\n*$)/g, '');
+    const tmp = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+    await node_fs_1.promises.writeFile(tmp, cleaned, 'utf8');
+    await node_fs_1.promises.rename(tmp, filePath);
+    return true;
+}
+/** Convenience: list pending across both files. */
+async function listAllPending(memoryPath, userPath) {
+    const m = (await listPending(memoryPath)).map((c) => ({ ...c, file: 'memory' }));
+    const u = (await listPending(userPath)).map((c) => ({ ...c, file: 'user' }));
+    return [...m, ...u];
+}

package/dist/core/v4/memory/reviewer/prompt.js

@@ -0,0 +1,105 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * core/v4/memory/reviewer/prompt.ts — v4.9.0 Slice 10.
+ *
+ * Reviewer system prompt + the on-disk wire format parser. The reviewer
+ * LLM is told to emit one candidate per line, pipe-delimited:
+ *
+ *   <file>|<text>|<rationale>
+ *
+ * where `<file>` is `memory` or `user`. Lines that don't match the
+ * shape, or that propose unknown files, are silently dropped — they
+ * count toward the `parser_drops` telemetry counter but don't fail
+ * the whole review.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildReviewerPrompt = buildReviewerPrompt;
+exports.parseReviewerResponse = parseReviewerResponse;
+const namespaceRegistry_1 = require("../namespaceRegistry");
+/**
+ * Reviewer system prompt. Conservative, skip-rules-first. The LLM is
+ * told to follow these rules; the parser + skipRules drop any
+ * candidate that slips through anyway.
+ */
+function buildReviewerPrompt(opts) {
+    const turnText = opts.recentTurns
+        .map((m) => `[${m.role}] ${m.content}`)
+        .join('\n');
+    return [
+        'You are Aiden\'s post-turn memory reviewer. You read the recent',
+        'conversation and propose AT MOST ' + String(opts.maxCandidates) +
+            ' additions to long-term memory.',
+        '',
+        'STRICT RULES (a candidate that violates ANY rule is DROPPED):',
+        // v4.9.0 Slice 11 — namespaces are now dynamic. The parser drops
+        // any candidate whose `<file>` field isn't in the registry; the
+        // skip-rule pass drops `project` candidates when no project root
+        // is detected.
+        '  - <file> must be one of: ' + (0, namespaceRegistry_1.listNamespaceNames)().join(', ') + '.',
+        '    `memory` = project / environment / Aiden facts (global).',
+        '    `user`   = user identity / preferences / workflow style.',
+        '    `project` (when available) = current-repo-specific context.',
+        '  - NO negations ("user does not X", "no longer Y"). Skip them.',
+        '  - NO transient artifacts ("today", "this session", "just now").',
+        '  - NO sensitive inference (health, politics, religion, finance,',
+        '    sexual orientation, family planning). NEVER propose these.',
+        '  - NO duplicates of what is already in memory below.',
+        '  - Each candidate <= 200 chars.',
+        '',
+        'OUTPUT FORMAT — one candidate per line, exactly:',
+        '  <file>|<text>|<rationale>',
+        'where <file> ∈ {memory, user}. No prose, no headers, no markdown.',
+        'If nothing is worth proposing, return an empty response.',
+        '',
+        '=== CURRENT live MEMORY.md ===',
+        opts.liveMemory || '(empty)',
+        '',
+        '=== CURRENT live USER.md ===',
+        opts.liveUser || '(empty)',
+        '',
+        '=== RECENT CONVERSATION TURNS ===',
+        turnText || '(no turns)',
+        '',
+        'Now propose candidates:',
+    ].join('\n');
+}
+/**
+ * Parse the LLM response into structured candidates. Drops lines that
+ * don't match `<file>|<text>|<rationale>` or use an unknown file. The
+ * caller's skipRules pass over each result for additional validation.
+ */
+function parseReviewerResponse(raw) {
+    const lines = raw.split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0);
+    const out = [];
+    let drops = 0;
+    for (const line of lines) {
+        // Strip leading bullets / numbering the LLM may have added despite instructions.
+        const cleaned = line.replace(/^[-*\d.)\s]+/, '');
+        const parts = cleaned.split('|').map((p) => p.trim());
+        if (parts.length < 3) {
+            drops += 1;
+            continue;
+        }
+        const [file, text, ...rest] = parts;
+        // v4.9.0 Slice 11 — accept any registered namespace name. The
+        // reviewer orchestrator's skip-rule pass drops `project`
+        // candidates when no project root resolves.
+        if (!(0, namespaceRegistry_1.listNamespaceNames)().includes(file)) {
+            drops += 1;
+            continue;
+        }
+        const rationale = rest.join('|').trim();
+        if (!text || !rationale) {
+            drops += 1;
+            continue;
+        }
+        out.push({ file: file, text, rationale });
+    }
+    return { candidates: out, parserDrops: drops };
+}