onadit 0.0.1 → 1.0.0

package/dist/src/retrieval/context-pack.js

@@ -0,0 +1,1483 @@
+/**
+ * Slice 3: ContextPack retrieval primitive.
+ *
+ * Builds a compact, bucketed view of prior context for an active task.
+ * Reuses hybrid search; never returns raw transcripts.
+ *
+ * Buckets:
+ *   - decisions:   strings pulled from matching conversations' `decisions` JSON
+ *   - constraints: MUST/NEVER/DO-NOT style lines pulled from matching docs
+ *   - examples:    compact pointers to prior conversations (title+summary+expand)
+ *   - rules:       compact pointers to project docs (title+snippet+expand)
+ *
+ * Hard caps (locked contract):
+ *   - each text item <= 200 chars
+ *   - each snippet  <= 200 chars
+ *   - max_per_bucket default 3, ceiling 10
+ *   - max_bytes default 6144, ceiling 16384
+ *
+ * Nothing here embeds or writes — pure assembly on top of hybridSearch
+ * plus direct row lookups for the decisions/constraints extraction.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { EMBED_WAIT_MS, hybridSearch, sharedEmbedding } from "./hybrid.js";
+import { rerank } from "./reranker.js";
+import { getTable } from "../storage/tables.js";
+import { resolveCwdRoot } from "./cwd.js";
+import { getProjectIndex, resolveProjectRoot } from "./project-index.js";
+import { computeContentSize } from "./compact.js";
+import { extractPassages } from "./passages.js";
+import { decodeUserStatement, MAX_QUOTE_CHARS, } from "../capture/user-statements.js";
+import { groupByParent, rankedKey } from "./group-by-parent.js";
+import { collapseConversationDuplicates, convDedupEnabled, poolHasChunkMarkers, } from "./conversation-dedup.js";
+import { parentKeyForRow } from "../ingestion/chunk-meta.js";
+import { inFilter } from "../storage/filter.js";
+import { classifyClaimType, classifyEvidenceIntent, partitionEvidence, } from "./current-truth.js";
+import { probeGitStates, resolveRepoRoot, } from "./git-state.js";
+import { canonicalEvidenceInputs, canonicalFilesEnabled, cleanItemText, holdsQuestionSubject, selectCanonicalSections, } from "./canonical-files.js";
+// --- Locked caps ---
+export const ITEM_TEXT_MAX = 200;
+export const SNIPPET_MAX = 200;
+/** Task-matching passage per example card. */
+export const PASSAGE_MAX = 360;
+export const DEFAULT_MAX_PER_BUCKET = 3;
+export const MAX_PER_BUCKET_CEILING = 10;
+/**
+ * Default envelope. 6 KB since passages were added (2026-09-24): at 4 KB the
+ * passages pushed the third example card out of every frozen-task pack; at
+ * 6 KB none were trimmed (packs measured 4.0–5.3 KB).
+ */
+export const DEFAULT_MAX_BYTES = 6144;
+export const MAX_BYTES_CEILING = 16384;
+/** Request `task` is echoed in the response, so it counts against `max_bytes`. Capped to keep the envelope small. */
+export const TASK_MAX = 1024;
+/**
+ * Minimum `S_sim` for a ranked candidate to feed the `decisions` /
+ * `examples` buckets. Below this floor we prefer an empty bucket over
+ * confidently-worded unrelated content — Slice 5 validation showed
+ * that when the task has no real match in the corpus, decisions from
+ * the top-ranked-but-unrelated row still come back, and an agent has
+ * no way to tell they're noise.
+ *
+ * `S_sim` is cosine similarity in [0,1] for vector / hybrid results
+ * and max-normalized BM25 for lexical-only. The floor is deliberately
+ * low (0.3): genuine weak matches still pass, but rows that are
+ * essentially keyword-free or cosine-orthogonal drop out. Constraints
+ * and rules are already heavily filtered (marker matching + engine-
+ * owned-path exclusion), so we only apply the floor to the two
+ * "free-text content" buckets where noise is most costly.
+ */
+export const DECISIONS_RELEVANCE_FLOOR = 0.3;
+export const EXAMPLES_RELEVANCE_FLOOR = 0.3;
+/**
+ * Equal-relevance band for {@link sortByRelevanceFirst}. Two candidates
+ * whose relevance signals (`max(S_sim, bm25_normalized)`) sit within
+ * this absolute delta are treated as effectively tied and fall through
+ * to the composite-score tie-breaker. Small enough to keep genuinely
+ * better relevance on top, wide enough that floating-point noise and
+ * trivial ranking jitter don't cause ping-pong between near-equal rows.
+ */
+export const RELEVANCE_TIE_EPSILON = 0.02;
+/**
+ * A sentence the user said is on the task's subject when it shares two of its
+ * subject words, or when it is this close to the task in meaning. Short rules
+ * rarely repeat two words of a task ("Inter, or any good looking sans font."
+ * for a task about the website's font), so the word test alone drops them.
+ *
+ * The bar is cosine similarity, and each model has its own scale, so each
+ * measured model has its own bar. Both were set against the owner's stored
+ * statements and past task strings (4,615 pairs) to let through the same
+ * small share of pairs, about 0.6%: on voyage-3-lite the 99th percentile is
+ * 0.44 and on voyage-4-lite at 512 dimensions 0.48. At these bars both font
+ * rules pass on a short question and on a long task description, the lowest
+ * at 0.497 on voyage-3-lite. A model that was not measured keeps the word
+ * test alone.
+ */
+export const STATEMENT_CLOSENESS_MIN = {
+    "voyage-3-lite": 0.47,
+    "voyage-4-lite": 0.5,
+};
+const STATEMENT_CLOSENESS_PROVIDER = "voyage";
+/**
+ * The most sentences one pack sends to be compared. A session keeps every
+ * statement the user made, so a long one can hold hundreds; the rest are
+ * compared by the next packs, and the pack says it is partial until then.
+ */
+export const STATEMENT_COMPARE_MAX = 200;
+/** Statement vectors kept for the life of the process: a stored sentence never changes. */
+const STATEMENT_VECTOR_CACHE_MAX = 5_000;
+const statementVectors = new Map();
+/** Test hook: forget the kept statement vectors. */
+export function resetStatementVectorCache() {
+    statementVectors.clear();
+}
+// Fetch more candidates than we keep so we have headroom to extract
+// decisions/constraints from multiple sources and dedupe downstream.
+const CANDIDATE_FETCH_MULTIPLIER = 4;
+/** Tables that feed the rules / constraints buckets. */
+const DOC_TABLES = ["structured_docs", "structured_docs_local"];
+/** Tracker sections read per pack; each bucket then takes its own cap from them. */
+const TRACKER_SECTION_POOL = 24;
+/** Same floor as examples: below it an other-project document is noise. */
+export const OTHER_PROJECTS_RELEVANCE_FLOOR = 0.3;
+/**
+ * The task names work outside this project ("from another project", "pour un
+ * autre client"). Other-project documents then get their budget first;
+ * otherwise they only use what the project's own evidence leaves free.
+ */
+const ASKS_OTHER_PROJECTS = /\b(?:an)?other\s+(?:projects?|clients?|repos?|repositor(?:y|ies))\b|\bcross[- ]project\b|\belsewhere\b|\bautres?\s+(?:projets?|clients?)\b|\bailleurs\b/i;
+// --- Project-first retrieval ---
+/**
+ * Project rows lead only when they are nearly as relevant as the best
+ * candidate overall; otherwise a question about another project asked from
+ * this repo would surface weak local matches first.
+ */
+export const PROJECT_FIRST_RELEVANCE_RATIO = 0.8;
+async function resolvePackProjects(cwd) {
+    const index = getProjectIndex();
+    const root = cwd ? resolveProjectRoot(cwd) : null;
+    if (!index || !root)
+        return { current: null, otherProjectOf: () => undefined };
+    const { byRoot, projectById } = await index.rowsByProject();
+    const rowIds = byRoot.get(root) ?? [];
+    return {
+        current: rowIds.length ? { root, rowIds, idSet: new Set(rowIds) } : null,
+        otherProjectOf: (rowId) => {
+            const home = projectById.get(rowId);
+            return home && home !== root ? path.basename(home) : undefined;
+        },
+    };
+}
+function mergeCandidates(a, b) {
+    const byId = new Map();
+    for (const c of [...a, ...b]) {
+        const prev = byId.get(c.id);
+        if (!prev)
+            byId.set(c.id, c);
+        else
+            byId.set(c.id, { ...prev, raw_sim: Math.max(prev.raw_sim, c.raw_sim), raw_bm25: Math.max(prev.raw_bm25, c.raw_bm25) });
+    }
+    return [...byId.values()];
+}
+/**
+ * For a task that asks for work from other projects: sessions that ran in
+ * another project lead, when close to the best of them. The reverse of
+ * {@link projectFirst}, which would bury exactly what was asked for.
+ */
+export function otherProjectsFirst(ranked, isOtherProject) {
+    const rel = (r) => Math.max(r.factors.S_sim, r.bm25_normalized);
+    const others = ranked.filter((r) => isOtherProject(r.id));
+    const best = others.reduce((m, r) => Math.max(m, rel(r)), 0);
+    const leadSet = new Set(others.filter((r) => rel(r) >= best * PROJECT_FIRST_RELEVANCE_RATIO));
+    return [...leadSet, ...ranked.filter((r) => !leadSet.has(r))];
+}
+/** Stable-partition: close-to-best project rows first, everything else after. */
+export function projectFirst(ranked, idSet) {
+    const rel = (r) => Math.max(r.factors.S_sim, r.bm25_normalized);
+    const best = ranked.reduce((m, r) => Math.max(m, rel(r)), 0);
+    const lead = ranked.filter((r) => idSet.has(r.id) && rel(r) >= best * PROJECT_FIRST_RELEVANCE_RATIO);
+    const leadSet = new Set(lead);
+    return [...lead, ...ranked.filter((r) => !leadSet.has(r))];
+}
+// --- Public entry ---
+export async function buildContextPack(opts) {
+    const maxPerBucket = clamp(opts.maxPerBucket ?? DEFAULT_MAX_PER_BUCKET, 1, MAX_PER_BUCKET_CEILING);
+    const maxBytes = clamp(opts.maxBytes ?? DEFAULT_MAX_BYTES, 512, MAX_BYTES_CEILING);
+    const cwdMatch = opts.cwd && opts.sources ? resolveCwdRoot(opts.cwd, opts.sources) : null;
+    const sourcePathPrefix = cwdMatch?.rootPath;
+    // Fetch candidates in two lanes in parallel: conversations and documents.
+    // These feed different buckets, so running them separately lets each bucket
+    // draw on its own candidate pool without one starving the other.
+    //
+    // The docs lane uses scope="all" restricted to the structured_docs table,
+    // because scope="documents" would also require `source_scope='document'`
+    // — excluding project-scoped files like CLAUDE.md / AGENTS.md / PRD.md
+    // that are the whole point of the `rules` bucket. Restricting the table
+    // (instead of filtering afterwards) keeps the docs lane from re-running the
+    // conversation search, and one shared embedding serves both lanes.
+    const fetchK = maxPerBucket * CANDIDATE_FETCH_MULTIPLIER;
+    const embedding = opts.embedding ? sharedEmbedding(opts.embedding) : undefined;
+    const { current: project, otherProjectOf } = await resolvePackProjects(opts.cwd);
+    const asksOtherProjects = ASKS_OTHER_PROJECTS.test(opts.task);
+    const [convRes, docRes, projRes, otherRes] = await Promise.all([
+        hybridSearch(opts.task, embedding, {
+            scope: "conversations",
+            top_k: fetchK,
+            ...(opts.since ? { since: opts.since } : {}),
+        }),
+        hybridSearch(opts.task, embedding, {
+            scope: "all",
+            tables: DOC_TABLES,
+            top_k: fetchK,
+            ...(opts.since ? { since: opts.since } : {}),
+            ...(sourcePathPrefix ? { sourcePathPrefix } : {}),
+        }),
+        // Project-first lane: the same search restricted to conversations captured
+        // in this project, so project history is not crowded out by the archive.
+        // When the task asks for other projects it is the reverse: everything
+        // but this project's sessions, so they cannot crowd out the others.
+        project
+            ? hybridSearch(opts.task, embedding, {
+                scope: "conversations",
+                tables: ["conversations_hot"],
+                ...(asksOtherProjects
+                    ? { excludeConversationIds: project.rowIds }
+                    : { conversationIds: project.rowIds }),
+                top_k: fetchK,
+                ...(opts.since ? { since: opts.since } : {}),
+            })
+            : Promise.resolve(null),
+        // Other-projects lane: the docs lane above is locked to this project, so
+        // a document in another configured project is never a candidate there.
+        // The same search with this project left out finds it. Left out in the
+        // query: filtered afterwards, a project with many matching documents
+        // would fill top_k and leave no room for anyone else's.
+        sourcePathPrefix
+            ? hybridSearch(opts.task, embedding, {
+                scope: "all",
+                tables: DOC_TABLES,
+                top_k: fetchK,
+                excludeSourcePathPrefix: `${sourcePathPrefix.replace(/\/+$/, "")}/`,
+                ...(opts.since ? { since: opts.since } : {}),
+            })
+            : Promise.resolve(null),
+    ]);
+    let degraded = convRes.degraded || docRes.degraded;
+    let degradedReason = convRes.degraded_reason ?? docRes.degraded_reason;
+    // Rerank the project lane together with the global lane: BM25 is normalized
+    // over the pool, so a separately reranked project pool would inflate weak
+    // project matches.
+    let convRanked = rerank(toRerankInput(mergeCandidates(convRes.candidates, projRes?.candidates ?? [])));
+    if (project) {
+        // Half the pool is held for the lane's side: this project's sessions, or
+        // everyone else's when the task asks for other projects.
+        const held = convRanked.filter((r) => project.idSet.has(r.id) !== asksOtherProjects);
+        const rest = convRanked.filter((r) => project.idSet.has(r.id) === asksOtherProjects);
+        convRanked = [...held.slice(0, Math.ceil(fetchK / 2)), ...rest];
+    }
+    convRanked = convRanked.slice(0, fetchK);
+    let docRanked = rerank(toRerankInput(docRes.candidates.filter((c) => c.source_table === "structured_docs" ||
+        c.source_table === "structured_docs_local"))).slice(0, fetchK);
+    const otherRanked = otherRes
+        ? rerank(toRerankInput(otherRes.candidates)).slice(0, fetchK)
+        : [];
+    // Fetch raw rows for the top ranked results so we can pull `decisions`,
+    // `content`, `metadata.title`, `source_path`, etc.
+    const [convRows, docRows, otherRows] = await Promise.all([
+        fetchRowsById(convRanked),
+        fetchRowsById(docRanked),
+        fetchRowsById(otherRanked),
+    ]);
+    // Collapse chunk siblings so one long conversation/document contributes a
+    // single card downstream (decisions / examples / rules / evidence) instead of
+    // one per chunk. No-op for unchunked/legacy rows (parentKeyForRow → null).
+    const parentKeyOf = (rows) => (r) => {
+        const row = rows.get(rankedKey(r));
+        return row ? parentKeyForRow(r.source_table, row) : null;
+    };
+    const convGrouped = groupByParent(convRanked, parentKeyOf(convRows));
+    convRanked = convGrouped.ranked;
+    docRanked = groupByParent(docRanked, parentKeyOf(docRows)).ranked;
+    // Collapse near-duplicate conversation captures (same task re-captured across
+    // sessions = distinct rows groupByParent can't merge) so one card per topic
+    // reaches decisions/examples/evidence instead of N redundant copies.
+    // Conversation rows only; docs pass through. Flag-gated (RIFT_CONV_DEDUP),
+    // provable no-op when off. Skipped when the conversation pool has chunk markers
+    // (best-chunk text would false-merge distinct conversations — see conversation-dedup).
+    let foldedCaptures = new Map();
+    if (convDedupEnabled() && !poolHasChunkMarkers(convGrouped)) {
+        const collapsed = collapseConversationDuplicates(convRanked);
+        convRanked = collapsed.ranked;
+        foldedCaptures = collapsed.foldedMembersById;
+    }
+    // Drop any doc candidates whose source_path points into engine-internal or
+    // build-artifact directories. These rows are not project rules — they are
+    // raw conversation snapshots, embedding cache files, quarantine drops,
+    // compiled JS/TS, node_modules, worktree copies, etc. — and they crowd
+    // real project-rule files (CLAUDE.md / AGENTS.md / PROJECT_STATE.md /
+    // TODO.md) out of the `rules` and `constraints` buckets. Conversation
+    // content is still reachable via `convRanked`.
+    const docRankedClean = docRanked.filter((r) => !shouldExcludeDocFromRules(docRows.get(rankedKey(r))?.["source_path"]));
+    // Constraints layer an extra filter on top via the contract helper:
+    // one-shot agent prompts (`*-prompt.md`) routinely carry "Hard
+    // Constraints" sections that match `extractConstraintLines`'s marker
+    // gate but are scaffolding, not durable project law. They stay
+    // eligible for `rules` (legitimate doc-level evidence) but must not
+    // lead `constraints` as project law. Calling
+    // `shouldExcludeDocFromConstraints` here — rather than composing the
+    // two helpers inline — keeps the constraint-exclusion contract in one
+    // place, so any future per-bucket exclusion is picked up automatically.
+    const docRankedForConstraints = docRanked.filter((r) => !shouldExcludeDocFromConstraints(docRows.get(rankedKey(r))?.["source_path"]));
+    // Re-sort the conversation candidates by query relevance before
+    // extracting `decisions` and `examples`. The global rerank() composite
+    // weights S_sim at only 55% — quality/tier/freshness can pull a
+    // high-confidence but tangential row above a more relevant one, which
+    // is the exact REX failure the relevance-first slice closes
+    // (docs/feedback/2026-05-14-fact-checking-rex.md, P1 #5). The re-sort
+    // is local to the context-pack path; onadit_search and the global
+    // reranker are intentionally unchanged.
+    const convSorted = sortByRelevanceFirst(convRanked);
+    const convByRelevance = asksOtherProjects
+        ? otherProjectsFirst(convSorted, (id) => otherProjectOf(id) !== undefined)
+        : project
+            ? projectFirst(convSorted, project.idSet)
+            : convSorted;
+    // Tracker sections read live (canonical-file lane). Trackers aren't indexed,
+    // and auto-captured sessions carry no extracted decisions, so without this
+    // the decisions and constraints a project wrote down never reach the pack.
+    // opts.cwd is the agent's working dir, often a SUBDIR (src/, tests/). The
+    // canonical files live at the repo root, so resolve the git top-level first
+    // (same resolution probeGitStates does) — otherwise we'd look in the subdir,
+    // find nothing, and silently no-op. Falls back to cwd outside a git repo.
+    const trackerMatches = canonicalFilesEnabled() && opts.cwd
+        ? selectCanonicalSections({
+            projectRoot: resolveRepoRoot(opts.cwd),
+            query: opts.task,
+            maxSections: TRACKER_SECTION_POOL,
+        })
+        : [];
+    // Tracker cards fill the slots the search-ranked cards leave free; they
+    // never take one. The lane matches on words, and a tracker note that only
+    // mentions the subject must not replace a decision that is about it. A
+    // tracker section that loses its slot here still reaches the agent as a
+    // current-truth card. Each bucket reads the whole pool, so a rule further
+    // down is not lost to the cap.
+    const convForDecisions = filterByRelevance(convByRelevance, DECISIONS_RELEVANCE_FLOOR);
+    // A session captured more than once is shown once, but each capture holds
+    // the statements found in it. So every capture of a shown session is read
+    // for what the user stated, and for nothing else.
+    const convForStatements = convForDecisions.flatMap((r) => [r, ...(foldedCaptures.get(rankedKey(r)) ?? [])]);
+    const statementOnlyIds = new Set(convForDecisions.flatMap((r) => foldedCaptures.get(rankedKey(r)) ?? []).map((r) => r.id));
+    // Not after a degraded search: the task's vector did not arrive in time
+    // there, and asking for it again would hold the pack a second time. That
+    // pack is already marked partial.
+    const closeness = embedding && !convRes.degraded
+        ? await statementCloseness(convForStatements, convRows, opts.task, embedding, opts.statementWaitMs ?? EMBED_WAIT_MS)
+        : NO_CLOSENESS;
+    // Sentences were waiting and were not compared: the pack may lack a rule
+    // the next one will hold, so it says so rather than look complete.
+    if (closeness.missed) {
+        degraded = true;
+        degradedReason ??= closeness.missed;
+    }
+    const decisions = [
+        ...extractDecisions(convForStatements, convRows, maxPerBucket, otherProjectOf, opts.task, closeness, statementOnlyIds),
+        ...trackerDecisions(trackerMatches),
+    ].slice(0, maxPerBucket);
+    const examples = buildExamples(filterByRelevance(convByRelevance, EXAMPLES_RELEVANCE_FLOOR), convRows, maxPerBucket, opts.task, otherProjectOf);
+    const rules = buildRules(docRankedClean, docRows, maxPerBucket);
+    const otherProjects = cwdMatch && opts.sources
+        ? buildOtherProjects(groupByParent(otherRanked, parentKeyOf(otherRows)).ranked, otherRows, cwdMatch.rootPath, opts.sources, maxPerBucket)
+        : [];
+    // Rules the user stated in a session come last: they are past discussion,
+    // and a rule written in a document or a live tracker outranks it.
+    const constraints = [
+        ...extractConstraints(docRankedForConstraints, docRows, maxPerBucket),
+        ...trackerConstraints(trackerMatches),
+        ...userConstraints(convForStatements, convRows, maxPerBucket, otherProjectOf, opts.task, closeness),
+    ].slice(0, maxPerBucket);
+    // Current Truth Mode v0/v1 — intent-aware evidence partition. Reuses
+    // the already-retrieved conv + doc hits; does not change ranking or
+    // fetch anything new. v1 adds the git-state probe below so file-backed
+    // evidence carries a tracked/untracked/modified/deleted/newer_on_disk
+    // signal into the partitioner. See src/retrieval/current-truth.ts +
+    // src/retrieval/git-state.ts.
+    const intent = classifyEvidenceIntent(opts.task);
+    const claimType = classifyClaimType(opts.task);
+    // v1: probe git state once per buildContextPack call. We only probe
+    // when a project root is available (opts.cwd) — without one, every
+    // path returns "unknown" anyway, and we'd be paying for a no-op git
+    // invocation. Conversations don't carry source_paths suitable for
+    // git probing, so the input set is just the document hits.
+    const gitStateInputs = [];
+    if (opts.cwd) {
+        for (const r of docRankedClean) {
+            const row = docRows.get(rankedKey(r));
+            const sourcePath = row?.["source_path"] || undefined;
+            if (!sourcePath)
+                continue;
+            const indexedAt = row?.["indexed_at"] || undefined;
+            gitStateInputs.push({ sourcePath, indexedAt });
+        }
+    }
+    const gitStateBySourcePath = opts.cwd
+        ? probeGitStates(gitStateInputs, { projectRoot: opts.cwd })
+        : new Map();
+    const evidenceInputs = [
+        ...convByRelevance.map((r) => ({
+            ranked: r,
+            row: convRows.get(rankedKey(r)),
+            kind: "conversation",
+        })),
+        ...docRankedClean.map((r) => {
+            const row = docRows.get(rankedKey(r));
+            const sourcePath = row?.["source_path"] || undefined;
+            const gs = sourcePath ? gitStateBySourcePath.get(sourcePath) : undefined;
+            const input = {
+                ranked: r,
+                row,
+                kind: "document",
+            };
+            if (gs)
+                input.gitState = gs;
+            return input;
+        }),
+    ];
+    // Tracker sections lead the evidence as tracker-tier inputs. The partitioner
+    // below is UNCHANGED and decides placement BY INTENT: tracker docs lead
+    // `current_truth` for current_truth/blended, and stay `current_truth`
+    // background under reasoning_archive ("what did we decide …" classifies as
+    // reasoning_archive, the exact case this lane must cover). No matches, no
+    // inputs.
+    evidenceInputs.unshift(...canonicalEvidenceInputs(trackerMatches.slice(0, maxPerBucket * 3)));
+    const partition = partitionEvidence(evidenceInputs, {
+        intent,
+        claimType,
+        maxPerSection: maxPerBucket,
+        ...(opts.cwd ? { projectRoot: opts.cwd } : {}),
+        ...(opts.selfReportsRoot ? { selfReportsRoot: opts.selfReportsRoot } : {}),
+    });
+    // The fallback list names files a project often keeps. Someone who keeps
+    // none of them must not be told to go and read them.
+    if (opts.cwd) {
+        const roots = [opts.cwd, resolveRepoRoot(opts.cwd) ?? opts.cwd];
+        partition.recommended_live_files = partition.recommended_live_files.filter((f) => path.isAbsolute(f.path) || roots.some((root) => fs.existsSync(path.join(root, f.path))));
+    }
+    const assembled = enforceBudget({ decisions, constraints, examples, rules }, {
+        maxBytes,
+        task: opts.task,
+        intent,
+        partition,
+        otherProjects,
+        otherProjectsFirst: asksOtherProjects,
+        degraded,
+        ...(degradedReason ? { degradedReason } : {}),
+        ...(embedding ? {} : { lexical: true }),
+        ...(project ? { projectScope: { root: project.root, conversations: project.rowIds.length } } : {}),
+    });
+    const pack = {
+        task: opts.task,
+        intent,
+        decisions: assembled.decisions,
+        constraints: assembled.constraints,
+        examples: assembled.examples,
+        rules: assembled.rules,
+        total_bytes: assembled.totalBytes,
+        truncated: assembled.truncated,
+        degraded,
+    };
+    if (assembled.partition.current_truth.length > 0)
+        pack.current_truth = assembled.partition.current_truth;
+    if (assembled.partition.past_reasoning.length > 0)
+        pack.past_reasoning = assembled.partition.past_reasoning;
+    if (assembled.partition.older_memory.length > 0)
+        pack.older_memory = assembled.partition.older_memory;
+    if (assembled.partition.discounted.length > 0)
+        pack.discounted = assembled.partition.discounted;
+    if (assembled.partition.recommended_live_files.length > 0)
+        pack.recommended_live_files = assembled.partition.recommended_live_files;
+    if (assembled.partition.conflicts.length > 0)
+        pack.conflicts = assembled.partition.conflicts;
+    if (assembled.partition.current_truth_caveat)
+        pack.current_truth_caveat = assembled.partition.current_truth_caveat;
+    if (assembled.otherProjects.length > 0)
+        pack.other_projects = assembled.otherProjects;
+    if (degradedReason)
+        pack.degraded_reason = degradedReason;
+    if (!embedding)
+        pack.mode = "lexical";
+    if (project)
+        pack.project_scope = { root: project.root, conversations: project.rowIds.length };
+    return pack;
+}
+/**
+ * Drop candidates whose best available relevance signal falls below
+ * `floor`. Combines semantic similarity (`S_sim`) and normalized BM25
+ * via `max()` so a strong keyword match keeps a row that happens to
+ * score weakly on the embedding axis, and a strong semantic match
+ * keeps a row that happens to share no tokens. Both signals live in
+ * `[0,1]`. Exported so tests can exercise the floor directly with
+ * synthetic `RankedResult`s.
+ */
+export function filterByRelevance(ranked, floor) {
+    return ranked.filter((r) => Math.max(r.factors.S_sim, r.bm25_normalized) >= floor);
+}
+/**
+ * Re-sort ranked candidates so that query relevance dominates ordering,
+ * with the composite rerank score acting only as a tie-breaker.
+ *
+ * Primary key: `max(S_sim, bm25_normalized)`, descending — the same
+ * dual-channel signal `filterByRelevance` already uses, so semantic
+ * and keyword evidence are treated symmetrically. Two candidates whose
+ * primary keys are within `epsilon` ({@link RELEVANCE_TIE_EPSILON})
+ * fall through to the composite `score`, descending — preserving the
+ * freshness / quality / tier ordering that the PRD-6.2 reranker
+ * encodes when relevance is effectively equal. ID is a final
+ * tie-breaker for determinism.
+ *
+ * Slice motivation: the global reranker weights `S_sim` at only 55%
+ * of the composite score, so a confidently-captured but tangential row
+ * could outrank a clearly more relevant lower-confidence row in the
+ * `decisions` and `examples` buckets. This helper is applied only to
+ * the conversation pipeline that feeds those two buckets; `onadit_search`
+ * and the global reranker are intentionally untouched. See
+ * docs/feedback/2026-05-14-fact-checking-rex.md (P1 #5) for the REX
+ * trace that motivated the change.
+ *
+ * Pure / non-mutating: returns a new array.
+ */
+export function sortByRelevanceFirst(ranked, epsilon = RELEVANCE_TIE_EPSILON) {
+    const withKey = ranked.map((r) => ({
+        r,
+        rel: Math.max(r.factors.S_sim, r.bm25_normalized),
+    }));
+    withKey.sort((a, b) => {
+        if (Math.abs(a.rel - b.rel) > epsilon)
+            return b.rel - a.rel;
+        if (a.r.score !== b.r.score)
+            return b.r.score - a.r.score;
+        return a.r.id < b.r.id ? -1 : a.r.id > b.r.id ? 1 : 0;
+    });
+    return withKey.map((x) => x.r);
+}
+// --- Bucket builders ---
+function extractDecisions(ranked, rows, cap, otherProjectOf, task, closeness, statementOnlyIds = new Set()) {
+    const out = [];
+    const seen = new Set();
+    for (const r of ranked) {
+        if (out.length >= cap)
+            break;
+        const row = rows.get(rankedKey(r));
+        if (!row)
+            continue;
+        const raw = row["decisions"];
+        const list = parseJsonStringArray(raw);
+        if (list.length === 0)
+            continue;
+        const timestamp = row["indexed_at"] || undefined;
+        const source = row["source"] || "conversation";
+        for (const d of list) {
+            if (out.length >= cap)
+                break;
+            const quote = userQuote(d, "decision", r, row, task, closeness);
+            // A folded capture adds the user's sentences only: its saved decisions
+            // are the shown capture's, and would repeat them.
+            if (quote === "skip" || (!quote && statementOnlyIds.has(r.id)))
+                continue;
+            const text = quote?.text ?? truncate(collapseWhitespace(d), ITEM_TEXT_MAX);
+            if (!text)
+                continue;
+            const key = text.toLowerCase();
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            const card = { text, source_id: r.id, source, ...quote?.ref };
+            if (timestamp)
+                card.timestamp = timestamp;
+            const otherProject = otherProjectOf(r.id);
+            if (otherProject)
+                card.project = otherProject;
+            out.push(card);
+        }
+    }
+    return out;
+}
+/** What a session is about, short enough to sit on every card that cites it. */
+const SESSION_LABEL_MAX = 80;
+const NO_CLOSENESS = { close: new Set() };
+/**
+ * Compare the task with the user's sentences that the word test would drop,
+ * in the candidate sessions only. Nothing new leaves the machine: the task is
+ * already embedded for the search and each sentence is part of a transcript
+ * embedded at capture. A failed or slow request leaves the word test in
+ * charge and is reported as `missed`; its late answer still fills the cache,
+ * so the next pack for the same sessions has it.
+ */
+async function statementCloseness(ranked, rows, task, embedding, waitMs) {
+    const bar = embedding.name === STATEMENT_CLOSENESS_PROVIDER ? STATEMENT_CLOSENESS_MIN[embedding.model] : undefined;
+    if (bar === undefined)
+        return NO_CLOSENESS;
+    const quotes = new Set();
+    for (const r of ranked) {
+        for (const entry of parseJsonStringArray(rows.get(rankedKey(r))?.["decisions"])) {
+            const quote = decodeUserStatement(entry)?.quote;
+            if (quote && quote.length <= MAX_QUOTE_CHARS && !holdsQuestionSubject(quote, task))
+                quotes.add(quote);
+        }
+    }
+    if (quotes.size === 0)
+        return NO_CLOSENESS;
+    const key = (quote) => `${embedding.model}\u0000${quote}`;
+    const uncompared = [...quotes].filter((q) => !statementVectors.has(key(q)));
+    const missing = uncompared.slice(0, STATEMENT_COMPARE_MAX);
+    const waiting = uncompared.length - missing.length;
+    const fetched = (async () => {
+        if (missing.length === 0)
+            return;
+        const vectors = await embedding.embedBatch(missing);
+        for (const [i, quote] of missing.entries()) {
+            const vector = vectors[i];
+            if (!vector)
+                continue;
+            if (statementVectors.size >= STATEMENT_VECTOR_CACHE_MAX) {
+                statementVectors.delete(statementVectors.keys().next().value);
+            }
+            statementVectors.set(key(quote), vector);
+        }
+    })();
+    let timer;
+    const deadline = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error(`no answer within ${waitMs} ms`)), waitMs);
+    });
+    try {
+        const [taskVector] = await Promise.race([Promise.all([embedding.embed(task), fetched]), deadline]);
+        const close = new Set();
+        for (const quote of quotes) {
+            const vector = statementVectors.get(key(quote));
+            if (vector && cosine(taskVector, vector) >= bar)
+                close.add(quote);
+        }
+        if (waiting === 0)
+            return { close };
+        return {
+            close,
+            missed: `partial pack: ${waiting} of your own statements are still to be compared with the task; a rule you stated may be missing`,
+        };
+    }
+    catch (err) {
+        fetched.catch(() => undefined);
+        const cause = err instanceof Error ? err.message : String(err);
+        return {
+            close: NO_CLOSENESS.close,
+            missed: `partial pack: your own statements were not compared with the task (${cause}); a rule you stated may be missing`,
+        };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function cosine(a, b) {
+    if (a.length !== b.length)
+        return 0;
+    let dot = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+        dot += a[i] * b[i];
+        normA += a[i] * a[i];
+        normB += b[i] * b[i];
+    }
+    return normA && normB ? dot / Math.sqrt(normA * normB) : 0;
+}
+/**
+ * Read one entry of a row's `decisions` column as a sentence the user typed.
+ * Null for an entry capture did not mark (a manual save or an import), which
+ * keeps its existing treatment. "skip" for a marked entry of the other kind, or
+ * one that does not hold the question's subject: a session can match the task
+ * while most of what the user ruled in it is about something else.
+ */
+function userQuote(entry, kind, r, row, task, closeness) {
+    const statement = decodeUserStatement(entry);
+    if (!statement)
+        return null;
+    if (statement.kind !== kind)
+        return "skip";
+    if (!holdsQuestionSubject(statement.quote, task) && !closeness.close.has(statement.quote))
+        return "skip";
+    // Whole or not at all. Cut short, a rule can lose the clause that limits
+    // it and still read as something the user said.
+    const text = collapseWhitespace(statement.quote);
+    if (text.length > MAX_QUOTE_CHARS)
+        return "skip";
+    const ref = {
+        said_by: "user",
+        session: truncate(collapseWhitespace(row["summary"] || ""), SESSION_LABEL_MAX),
+        source_table: r.source_table,
+    };
+    const offset = (row["content"] || "").indexOf(statement.quote);
+    if (offset >= 0)
+        ref.offset = offset;
+    return { text, ref };
+}
+/**
+ * Rules the user stated in a captured session of this project. A rule set in
+ * another project's session is not this project's rule, so it is left out.
+ */
+function userConstraints(ranked, rows, cap, otherProjectOf, task, closeness) {
+    const out = [];
+    const seen = new Set();
+    for (const r of ranked) {
+        if (out.length >= cap)
+            break;
+        const row = rows.get(rankedKey(r));
+        if (!row || otherProjectOf(r.id))
+            continue;
+        for (const entry of parseJsonStringArray(row["decisions"])) {
+            if (out.length >= cap)
+                break;
+            const quote = userQuote(entry, "constraint", r, row, task, closeness);
+            if (!quote || quote === "skip")
+                continue;
+            const key = quote.text.toLowerCase();
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            const card = {
+                text: quote.text,
+                source_id: r.id,
+                source: row["source"] || "conversation",
+                ...quote.ref,
+            };
+            const timestamp = row["indexed_at"] || undefined;
+            if (timestamp)
+                card.timestamp = timestamp;
+            out.push(card);
+        }
+    }
+    return out;
+}
+/** Matched items under a tracker's decisions heading, as decision cards. */
+function trackerDecisions(matches) {
+    const out = [];
+    for (const m of matches) {
+        if (m.group !== "decision")
+            continue;
+        const text = truncate(collapseWhitespace(cleanItemText(m.section.text)), ITEM_TEXT_MAX);
+        if (!text)
+            continue;
+        const sourcePath = `${m.fileName}:${m.section.line}`;
+        const card = {
+            text,
+            source_id: `canonical:${sourcePath}`,
+            source: "tracker",
+            source_path: sourcePath,
+        };
+        const date = /^\d{4}-\d{2}-\d{2}/.exec(text)?.[0];
+        if (date)
+            card.timestamp = date;
+        out.push(card);
+    }
+    return out;
+}
+/** A tracker heading whose items are standing rules as written. */
+const GUARDRAIL_HEADING = /\b(guardrails?|constraints?)\b/i;
+/** Trackers are often written in French; the doc-lane markers are English only. */
+const FRENCH_MARKER_AT_START = /^(?:ne\s+(?:pas|rien|jamais|plus)|jamais|toujours|interdit)\b/i;
+/**
+ * Constraint clauses from matched tracker items. A tracker states its rules
+ * mid-sentence ("Keep email parked; do not add another source during the
+ * pilot"), so each item is split into clauses before the marker test.
+ */
+function trackerConstraints(matches) {
+    const out = [];
+    const seen = new Set();
+    for (const m of matches) {
+        const item = cleanItemText(m.section.text);
+        const clauses = item.split(/(?<=[.;:])\s+|\s+—\s+|\n/);
+        const lines = GUARDRAIL_HEADING.test(m.section.parent)
+            ? [collapseWhitespace(item)]
+            : [
+                ...extractConstraintLines(clauses.join("\n")),
+                ...clauses
+                    .map((clause) => collapseWhitespace(clause.replace(/[.;]+\s*$/, "")))
+                    .filter((clause) => FRENCH_MARKER_AT_START.test(clause)),
+            ];
+        const sourcePath = `${m.fileName}:${m.section.line}`;
+        for (const line of lines) {
+            const text = truncate(line, ITEM_TEXT_MAX);
+            const key = text.toLowerCase();
+            if (!text || seen.has(key))
+                continue;
+            seen.add(key);
+            out.push({ text, source_id: `canonical:${sourcePath}`, source_path: sourcePath });
+        }
+    }
+    return out;
+}
+function buildExamples(ranked, rows, cap, task, otherProjectOf) {
+    const out = [];
+    for (const r of ranked) {
+        if (out.length >= cap)
+            break;
+        const row = rows.get(rankedKey(r));
+        const fullContent = row?.["content"] || r.content || "";
+        const summary = truncate(collapseWhitespace(row?.["summary"] || fullContent), SNIPPET_MAX);
+        if (!summary)
+            continue;
+        const title = deriveExampleTitle(row, summary);
+        const source = row?.["source"] || "conversation";
+        const timestamp = row?.["indexed_at"] || undefined;
+        const { content_bytes, content_tokens_estimate } = computeContentSize(fullContent);
+        const card = {
+            id: r.id,
+            title,
+            source,
+            summary,
+            content_bytes,
+            content_tokens_estimate,
+            expand: {
+                route: "/search",
+                // Size fields are mirrored into `expand.params` so an agent that
+                // copy-pastes the pointer sees the warning at the exact moment it
+                // decides whether to spend context on `detail="full"`.
+                params: {
+                    id: r.id,
+                    tier: r.source_table === "conversations_cold" ? "cold" : "hot",
+                    source_table: r.source_table,
+                    detail: "full",
+                    content_bytes,
+                    content_tokens_estimate,
+                },
+            },
+        };
+        if (timestamp)
+            card.timestamp = timestamp;
+        const otherProject = otherProjectOf(r.id);
+        if (otherProject)
+            card.project = otherProject;
+        const [passage] = extractPassages(fullContent, task, { max: 1, windowChars: PASSAGE_MAX });
+        if (passage) {
+            card.passage = {
+                text: passage.text,
+                offset: passage.start,
+                matched: `${passage.terms_matched}/${passage.terms_total}`,
+            };
+        }
+        out.push(card);
+    }
+    return out;
+}
+function buildRules(ranked, rows, cap) {
+    const out = [];
+    for (const r of ranked) {
+        if (out.length >= cap)
+            break;
+        const row = rows.get(rankedKey(r));
+        const content = row?.["content"] || r.content || "";
+        const snippet = truncate(collapseWhitespace(content), SNIPPET_MAX);
+        if (!snippet)
+            continue;
+        const sourcePath = row?.["source_path"] || "";
+        const title = deriveRuleTitle(row, sourcePath, snippet);
+        const { content_bytes, content_tokens_estimate } = computeContentSize(content);
+        const card = {
+            id: r.id,
+            title,
+            snippet,
+            content_bytes,
+            content_tokens_estimate,
+            expand: {
+                route: "/search",
+                params: {
+                    id: r.id,
+                    tier: "structured_doc",
+                    source_table: r.source_table,
+                    detail: "full",
+                    content_bytes,
+                    content_tokens_estimate,
+                },
+            },
+        };
+        if (sourcePath)
+            card.source_path = sourcePath;
+        out.push(card);
+    }
+    return out;
+}
+/**
+ * Documents that match the task and sit in a configured project other than
+ * the current one. They become reference cards labelled with their project,
+ * and stay out of rules, constraints and current truth: another project's
+ * "NEVER" is not this project's law.
+ */
+function buildOtherProjects(ranked, rows, currentRoot, sources, cap) {
+    const out = [];
+    for (const r of filterByRelevance(ranked, OTHER_PROJECTS_RELEVANCE_FLOOR)) {
+        if (out.length >= cap)
+            break;
+        const row = rows.get(rankedKey(r));
+        const sourcePath = row?.["source_path"] || "";
+        if (!sourcePath || shouldExcludeDocFromRules(sourcePath))
+            continue;
+        const home = resolveCwdRoot(sourcePath, sources);
+        if (!home || home.rootPath === currentRoot)
+            continue;
+        const content = row?.["content"] || r.content || "";
+        const snippet = truncate(collapseWhitespace(content), SNIPPET_MAX);
+        if (!snippet)
+            continue;
+        const { content_bytes, content_tokens_estimate } = computeContentSize(content);
+        out.push({
+            id: r.id,
+            title: deriveRuleTitle(row, sourcePath, snippet),
+            project: home.projectName,
+            snippet,
+            source_path: sourcePath,
+            content_bytes,
+            content_tokens_estimate,
+            expand: {
+                route: "/search",
+                params: {
+                    id: r.id,
+                    tier: "structured_doc",
+                    source_table: r.source_table,
+                    detail: "full",
+                    content_bytes,
+                    content_tokens_estimate,
+                },
+            },
+        });
+    }
+    return out;
+}
+/**
+ * Pull constraint-shaped lines out of the matching rule documents. Looks
+ * for classic imperative markers (MUST/MUST NOT/NEVER/DO NOT/ALWAYS/AVOID)
+ * which are the idiom for CLAUDE.md / AGENTS.md / PRD-style project rules.
+ * Falls back silently if none found — constraints is the bucket most
+ * likely to be empty, by design.
+ */
+function extractConstraints(ranked, rows, cap) {
+    const out = [];
+    const seen = new Set();
+    for (const r of ranked) {
+        if (out.length >= cap)
+            break;
+        const row = rows.get(rankedKey(r));
+        const content = row?.["content"] || r.content;
+        if (!content)
+            continue;
+        const lines = extractConstraintLines(content);
+        if (lines.length === 0)
+            continue;
+        const sourcePath = row?.["source_path"] || undefined;
+        for (const line of lines) {
+            if (out.length >= cap)
+                break;
+            const text = truncate(line, ITEM_TEXT_MAX);
+            const key = text.toLowerCase();
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            const card = { text, source_id: r.id };
+            if (sourcePath)
+                card.source_path = sourcePath;
+            out.push(card);
+        }
+    }
+    return out;
+}
+/**
+ * The idiom we are matching is project-law: "MUST run pnpm check",
+ * "NEVER commit secrets", "Do not modify files outside this repo".
+ * Real constraints put the imperative word at the start of the line.
+ * Mid-line occurrences are almost always narrative prose, JSON values,
+ * or quoted excerpts — we'd rather drop those than admit them.
+ */
+const MARKER_AT_START = /^(?:MUST(?:\s+NOT)?|NEVER|DO\s+NOT|DON'T|ALWAYS|AVOID|REQUIRED|FORBIDDEN)\b/i;
+/** Bullet or numbered list prefix, stripped before checking for the marker. */
+const LIST_PREFIX = /^\s*(?:[-*+]|\d+[.)]|\(\d+\))\s+/;
+/** Leading markdown emphasis (`**`, `__`), stripped before checking. */
+const EMPHASIS_PREFIX = /^(?:\*+|_+)\s*/;
+/**
+ * Reject lines that look like a JSON/YAML fragment, a quoted transcript
+ * snippet, or other structured-data debris. These are the classic
+ * false-positive shapes from Slice 5 validation: raw conversation JSON
+ * and excerpt blobs that happen to contain marker words inside quoted
+ * values get pulled into the `constraints` bucket as if they were
+ * project law.
+ */
+function looksLikeStructuredFragment(line) {
+    // JSON key-value: `"content": "..."`, `"excerpt": "..."`, etc.
+    if (/^"[^"]+"\s*:/.test(line))
+        return true;
+    // JSON structural punctuation anywhere — a real constraint line would
+    // not contain `{` or `}`.
+    if (/[{}]/.test(line))
+        return true;
+    // Line opens with a quote or backtick → quoted transcript/code snippet.
+    if (/^["'`]/.test(line))
+        return true;
+    return false;
+}
+export function extractConstraintLines(content) {
+    const out = [];
+    for (const raw of content.split(/\r?\n/)) {
+        const trimmed = raw.trim();
+        if (!trimmed)
+            continue;
+        if (looksLikeStructuredFragment(trimmed))
+            continue;
+        const body = trimmed.replace(LIST_PREFIX, "").replace(EMPHASIS_PREFIX, "");
+        if (!MARKER_AT_START.test(body))
+            continue;
+        const cleaned = collapseWhitespace(body.replace(/[.?!]+\s*$/, ""));
+        out.push(cleaned);
+    }
+    return out;
+}
+/**
+ * Greedy round-robin fill: start with empty buckets, pull one item at a
+ * time from each input bucket in a fixed order, add only if it fits in
+ * the remaining budget. Guarantees each bucket gets a fair shot even
+ * when one bucket's items would otherwise crowd the budget.
+ *
+ * `totalBytes` is seeded from the serialized response envelope (task +
+ * degraded flags + empty-bucket overhead) so the returned value reflects
+ * the whole payload, not just bucket contents — `max_bytes` is a contract
+ * on response size.
+ */
+function enforceBudget(input, ctx) {
+    const { maxBytes } = ctx;
+    const order = [
+        "decisions",
+        "constraints",
+        "rules",
+        "examples",
+    ];
+    const queues = {
+        decisions: [...input.decisions],
+        constraints: [...input.constraints],
+        examples: [...input.examples],
+        rules: [...input.rules],
+    };
+    const output = {
+        decisions: [],
+        constraints: [],
+        examples: [],
+        rules: [],
+    };
+    // Current-truth-mode partition shares the same byte budget. We seed
+    // outputs with copies and copy-back any items that fit. Recommended
+    // live files are small and high-value — fill first.
+    const partitionOut = {
+        current_truth: [],
+        past_reasoning: [],
+        older_memory: [],
+        discounted: [],
+        recommended_live_files: [],
+        conflicts: [],
+        ...(ctx.partition.current_truth_caveat
+            ? { current_truth_caveat: ctx.partition.current_truth_caveat }
+            : {}),
+    };
+    const partitionQueues = {
+        current_truth: [...ctx.partition.current_truth],
+        past_reasoning: [...ctx.partition.past_reasoning],
+        older_memory: [...ctx.partition.older_memory],
+        discounted: [...ctx.partition.discounted],
+        recommended_live_files: [...ctx.partition.recommended_live_files],
+        conflicts: [...ctx.partition.conflicts],
+    };
+    let totalBytes = envelopeBytes(output, ctx);
+    let truncated = false;
+    // Pass 1: conflicts + recommended_live_files — small, high-value entries
+    // the asker needs first (a surfaced conflict is the whole point of the
+    // mode). Fill conflicts before live files; both before the bulk buckets.
+    while (partitionQueues.conflicts.length > 0) {
+        const item = partitionQueues.conflicts[0];
+        const added = itemBytes(item);
+        if (totalBytes + added > maxBytes) {
+            truncated = true;
+            break;
+        }
+        partitionQueues.conflicts.shift();
+        partitionOut.conflicts.push(item);
+        totalBytes += added;
+    }
+    while (partitionQueues.recommended_live_files.length > 0) {
+        const item = partitionQueues.recommended_live_files[0];
+        const added = itemBytes(item);
+        if (totalBytes + added > maxBytes) {
+            truncated = true;
+            break;
+        }
+        partitionQueues.recommended_live_files.shift();
+        partitionOut.recommended_live_files.push(item);
+        totalBytes += added;
+    }
+    // Pass 1b: the best tracker section read live is placed before the
+    // round-robin, so the project's own current answer is never lost to the
+    // budget. The other tracker sections take their turn below like any card.
+    if (partitionQueues.current_truth[0]?.id.startsWith("canonical:")) {
+        const item = partitionQueues.current_truth[0];
+        const added = itemBytes(item);
+        if (totalBytes + added > maxBytes) {
+            truncated = true;
+        }
+        else {
+            partitionQueues.current_truth.shift();
+            partitionOut.current_truth.push(item);
+            totalBytes += added;
+        }
+    }
+    // Other-project documents: before the round-robin when the task asks for
+    // them, after it otherwise, so by default they never take a byte from the
+    // project's own evidence.
+    const otherQueue = [...ctx.otherProjects];
+    const otherOut = [];
+    const fillOtherProjects = () => {
+        while (otherQueue.length > 0) {
+            const item = otherQueue[0];
+            // The section key itself (`,"other_projects":[]`) ships with the first card.
+            const added = itemBytes(item) + (otherOut.length === 0 ? OTHER_PROJECTS_KEY_BYTES : 0);
+            if (totalBytes + added > maxBytes) {
+                truncated = true;
+                break;
+            }
+            otherQueue.shift();
+            otherOut.push(item);
+            totalBytes += added;
+        }
+    };
+    if (ctx.otherProjectsFirst)
+        fillOtherProjects();
+    // Pass 2: round-robin across legacy buckets and partition sections so
+    // every section gets a fair shot even when one would otherwise crowd
+    // the budget.
+    const partitionOrder = [
+        "current_truth",
+        "past_reasoning",
+        "older_memory",
+        "discounted",
+    ];
+    let progressed = true;
+    while (progressed) {
+        progressed = false;
+        for (const key of order) {
+            const q = queues[key];
+            if (q.length === 0)
+                continue;
+            const item = q[0];
+            const addedBytes = itemBytes(item);
+            if (totalBytes + addedBytes > maxBytes) {
+                truncated = true;
+                continue;
+            }
+            q.shift();
+            output[key].push(item);
+            totalBytes += addedBytes;
+            progressed = true;
+        }
+        for (const key of partitionOrder) {
+            const q = partitionQueues[key];
+            if (q.length === 0)
+                continue;
+            const item = q[0];
+            const added = itemBytes(item);
+            if (totalBytes + added > maxBytes) {
+                truncated = true;
+                continue;
+            }
+            q.shift();
+            partitionOut[key].push(item);
+            totalBytes += added;
+            progressed = true;
+        }
+    }
+    // Pass 3: a rule the user stated about this task that the rotation left out
+    // takes the place of other past discussion, which is what it is itself: the
+    // last cards of the discounted, older-memory and past-reasoning sections,
+    // in that order. Nothing else gives way to it: not a document's or a
+    // tracker's rule, a decision, current truth or a conflict. And it is not
+    // shown while a rule that outranks it in the bucket is still waiting.
+    while (queues.constraints[0]?.said_by === "user") {
+        const item = queues.constraints[0];
+        const needed = totalBytes + itemBytes(item) - maxBytes;
+        const givesWay = [];
+        let freed = 0;
+        for (const key of USER_RULE_REPLACES) {
+            for (let i = partitionOut[key].length - 1; i >= 0 && freed < needed; i--) {
+                freed += itemBytes(partitionOut[key][i]);
+                givesWay.push(key);
+            }
+        }
+        if (freed < needed)
+            break;
+        for (const key of givesWay) {
+            // Back on its queue, so the pack still says something was left out.
+            const card = partitionOut[key].pop();
+            partitionQueues[key].unshift(card);
+            totalBytes -= itemBytes(card);
+        }
+        queues.constraints.shift();
+        output.constraints.push(item);
+        totalBytes += itemBytes(item);
+    }
+    if (!ctx.otherProjectsFirst)
+        fillOtherProjects();
+    // Any items still sitting in the queues were dropped for budget.
+    for (const key of order) {
+        if (queues[key].length > 0) {
+            truncated = true;
+            break;
+        }
+    }
+    if (!truncated) {
+        for (const key of partitionOrder) {
+            if (partitionQueues[key].length > 0) {
+                truncated = true;
+                break;
+            }
+        }
+        if (partitionQueues.recommended_live_files.length > 0)
+            truncated = true;
+        if (partitionQueues.conflicts.length > 0)
+            truncated = true;
+    }
+    return {
+        decisions: output.decisions,
+        constraints: output.constraints,
+        examples: output.examples,
+        rules: output.rules,
+        partition: partitionOut,
+        otherProjects: otherOut,
+        totalBytes,
+        truncated,
+    };
+}
+/** The sections a user's own rule may take room from, first to give way first. */
+const USER_RULE_REPLACES = ["discounted", "older_memory", "past_reasoning"];
+const OTHER_PROJECTS_KEY_BYTES = Buffer.byteLength(',"other_projects":[]', "utf-8");
+function envelopeBytes(buckets, ctx) {
+    // Full serialized response envelope, including echoed `task`, `degraded`
+    // flags, and a worst-case integer placeholder for `total_bytes`. Used as
+    // the starting-point byte count so `max_bytes` bounds the whole payload,
+    // not just the bucket contents. The intent field is small but
+    // included so the budget reflects its real serialized cost.
+    const envelope = {
+        task: ctx.task,
+        intent: ctx.intent,
+        decisions: buckets.decisions,
+        constraints: buckets.constraints,
+        examples: buckets.examples,
+        rules: buckets.rules,
+        total_bytes: ctx.maxBytes,
+        truncated: true,
+        degraded: ctx.degraded,
+    };
+    // v2: the caveat is a fixed-size string that always ships when set;
+    // count it up front so a thin budget doesn't push the envelope over.
+    // Conflicts and live files are filled item-by-item in the passes above,
+    // so they're not pre-counted here.
+    if (ctx.partition.current_truth_caveat)
+        envelope["current_truth_caveat"] = ctx.partition.current_truth_caveat;
+    if (ctx.degradedReason)
+        envelope["degraded_reason"] = ctx.degradedReason;
+    if (ctx.lexical)
+        envelope["mode"] = "lexical";
+    if (ctx.projectScope)
+        envelope["project_scope"] = ctx.projectScope;
+    return Buffer.byteLength(JSON.stringify(envelope), "utf-8");
+}
+function itemBytes(item) {
+    return Buffer.byteLength(JSON.stringify(item), "utf-8") + 1; // +1 for comma
+}
+// --- Utilities ---
+function toRerankInput(cands) {
+    return cands.map((c) => {
+        const entry = {
+            id: c.id,
+            content: c.content,
+            raw_sim: c.raw_sim,
+            raw_bm25: c.raw_bm25,
+            source_table: c.source_table,
+            retrieval_method: c.retrieval_method,
+        };
+        if (c.indexed_at)
+            entry.indexed_at = c.indexed_at;
+        if (c.quality)
+            entry.quality = c.quality;
+        return entry;
+    });
+}
+async function fetchRowsById(ranked) {
+    const byTable = new Map();
+    for (const r of ranked) {
+        const arr = byTable.get(r.source_table) ?? [];
+        arr.push(r.id);
+        byTable.set(r.source_table, arr);
+    }
+    // Keyed by rankedKey — (source_table, id), not bare id — so a doc id present
+    // in both the cloud and local tables can't have one row overwrite the other
+    // and misattribute evidence. Look up via get(rankedKey(r)).
+    const out = new Map();
+    await Promise.all([...byTable].map(async ([tableName, ids]) => {
+        if (ids.length === 0)
+            return;
+        const table = getTable(tableName);
+        // Everything but the stored vector, which nothing downstream reads.
+        const columns = (await table.schema()).fields
+            .map((f) => f.name)
+            .filter((name) => name !== "embedding");
+        const rows = (await table
+            .query()
+            .select(columns)
+            .where(inFilter("id", ids, { validateAsRowId: true }))
+            .limit(ids.length)
+            .toArray());
+        for (const row of rows) {
+            out.set(rankedKey({ source_table: tableName, id: row["id"] }), row);
+        }
+    }));
+    return out;
+}
+function parseJsonStringArray(raw) {
+    if (typeof raw !== "string" || !raw)
+        return [];
+    try {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed.filter((x) => typeof x === "string" && !!x.trim());
+    }
+    catch {
+        return [];
+    }
+}
+function deriveExampleTitle(row, summary) {
+    const topics = parseJsonStringArray(row?.["topics"]);
+    if (topics.length > 0)
+        return truncate(topics.slice(0, 3).join(", "), 120);
+    return truncate(firstLine(summary) || "(conversation)", 120);
+}
+function deriveRuleTitle(row, sourcePath, snippet) {
+    const metaTitle = readMetadataTitle(row);
+    if (metaTitle)
+        return truncate(metaTitle, 120);
+    if (sourcePath) {
+        const base = sourcePath.split("/").filter(Boolean).pop();
+        if (base)
+            return truncate(base, 120);
+    }
+    return truncate(firstLine(snippet) || "(document)", 120);
+}
+function readMetadataTitle(row) {
+    const meta = row?.["metadata"];
+    if (typeof meta !== "string" || !meta)
+        return null;
+    try {
+        const parsed = JSON.parse(meta);
+        const t = parsed["title"];
+        if (typeof t === "string" && t.trim())
+            return t.trim();
+    }
+    catch {
+        // ignore
+    }
+    return null;
+}
+function firstLine(text) {
+    for (const line of text.split(/\r?\n/)) {
+        const t = line.trim();
+        if (t)
+            return t.replace(/^#+\s*/, "").replace(/^[-*]\s+/, "");
+    }
+    return "";
+}
+function truncate(text, max) {
+    if (text.length <= max)
+        return text;
+    return text.slice(0, max);
+}
+function collapseWhitespace(text) {
+    return text.replace(/\s+/g, " ").trim();
+}
+function clamp(n, lo, hi) {
+    if (n < lo)
+        return lo;
+    if (n > hi)
+        return hi;
+    return n;
+}
+/**
+ * True when `source_path` points into a `data/raw/conversations/**` directory.
+ * Those are raw conversation JSON snapshots that sometimes get indexed as
+ * `structured_docs` because they live under a watched source path; they are
+ * not project rule documents and must not populate `rules` / `constraints`.
+ */
+export function isRawConversationPath(p) {
+    return typeof p === "string" && /\/data\/raw\/conversations\//.test(p);
+}
+/**
+ * Baseline engine-owned / build-artifact path exclusion for both the
+ * `rules` and `constraints` buckets. The `constraints` bucket layers an
+ * additional filter on top — see {@link shouldExcludeDocFromConstraints}
+ * — to keep one-shot agent prompts out of the project-law surface while
+ * still allowing them to be cited as `rules` doc evidence.
+ *
+ * Explicitly enumerates engine-owned subdirectories under `data/` rather
+ * than matching `data/` wholesale, so user-facing locations the daemon
+ * legitimately watches (notably `data/imports/`) remain eligible:
+ *   - `/data/raw/`              — raw conversation snapshots
+ *   - `/data/embeddings/`       — cloud embedding cache
+ *   - `/data/embeddings-local/` — local embedding cache
+ *   - `/data/quarantine/`       — failed ingest drops
+ *   - `/data/review-queue/`     — review-pipeline state
+ *   - `/data/inbox/`            — pre-ingest staging
+ *   - `/data/observability/`    — metrics / logs
+ *   - `/data/triage-results/`   — batch triage output
+ *   - `/data/lancedb/`          — the vector store itself
+ *   - `/dist/`                  — compiled JS/TS build artifacts
+ *   - `/node_modules/`          — third-party dependencies
+ *   - `/.git/`                  — git internals
+ *   - `/.codex-worktrees/`      — ephemeral worktrees created by codex runs
+ * Rule-bearing human-authored files under `src/`, `docs/`, `reports/`,
+ * `data/imports/`, or at the project root (CLAUDE.md, AGENTS.md,
+ * PROJECT_STATE.md, TODO.md, …) are untouched.
+ */
+const EXCLUDED_RULE_PATH_PATTERNS = [
+    /\/data\/raw\//,
+    /\/data\/embeddings\//,
+    /\/data\/embeddings-local\//,
+    /\/data\/quarantine\//,
+    /\/data\/review-queue\//,
+    /\/data\/inbox\//,
+    /\/data\/observability\//,
+    /\/data\/triage-results\//,
+    /\/data\/lancedb\//,
+    /\/dist\//,
+    /\/node_modules\//,
+    /\/\.git\//,
+    /\/\.codex-worktrees\//,
+];
+export function shouldExcludeDocFromRules(p) {
+    if (typeof p !== "string")
+        return false;
+    return EXCLUDED_RULE_PATH_PATTERNS.some((rx) => rx.test(p));
+}
+/**
+ * True when `source_path`'s basename ends with `-prompt.md` — the naming
+ * convention this project uses for one-shot agent prompts (e.g.
+ * `reports/insights/2026-05-03-opus-rift-intelligence-snapshot-prompt.md`,
+ * `docs/05-claude-code-challenge-prompt.md`). These files routinely
+ * include `Hard Constraints` sections such as "Do not modify, create,
+ * delete, move, or rewrite any repository file." which match the
+ * imperative-marker gate in {@link extractConstraintLines} but are
+ * one-shot scaffolding, not durable project law — surfacing them in the
+ * `constraints` bucket erodes trust in the bucket as a whole
+ * (`docs/feedback/2026-05-14-fact-checking-rex.md`, P1 #6).
+ *
+ * Intentionally narrow: only files whose basename ends in literal
+ * `-prompt.md` match. A spec doc like `docs/02-agent-access-without-prompting.md`
+ * (ends in `-prompting.md`), a playbook like `prompts-overview.md`, or a
+ * mid-name occurrence like `prompt-engineering-notes.md` are untouched.
+ * Over-filtering a real project rule is worse than letting some prompt
+ * noise through.
+ */
+export function isPromptArtifactPath(p) {
+    return typeof p === "string" && /-prompt\.md$/i.test(p);
+}
+/**
+ * Per-bucket exclusion for the `constraints` surface. Combines the
+ * baseline engine/build filter with the one-shot prompt-artifact filter
+ * so an agent prompt can still appear in `rules` (as legitimate doc
+ * evidence — "this is what we instructed Opus") without contributing
+ * its imperative-marker lines to `constraints` (as if they were project
+ * law).
+ */
+export function shouldExcludeDocFromConstraints(p) {
+    return shouldExcludeDocFromRules(p) || isPromptArtifactPath(p);
+}
+//# sourceMappingURL=context-pack.js.map