@getrift/rift 0.0.0 → 0.1.0-beta.0

package/dist/src/retrieval/context-pack.d.ts

@@ -0,0 +1,123 @@
+/**
+ * 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 4096, ceiling 16384
+ *
+ * Nothing here embeds or writes — pure assembly on top of hybridSearch
+ * plus direct row lookups for the decisions/constraints extraction.
+ */
+import type { EmbeddingProvider } from "../providers/types.js";
+import type { SourceDir } from "../config/schema.js";
+import { type RankedResult } from "./reranker.js";
+export declare const ITEM_TEXT_MAX = 200;
+export declare const SNIPPET_MAX = 200;
+export declare const DEFAULT_MAX_PER_BUCKET = 3;
+export declare const MAX_PER_BUCKET_CEILING = 10;
+export declare const DEFAULT_MAX_BYTES = 4096;
+export declare 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 declare 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 declare const DECISIONS_RELEVANCE_FLOOR = 0.3;
+export declare const EXAMPLES_RELEVANCE_FLOOR = 0.3;
+export interface DecisionCard {
+    text: string;
+    source_id: string;
+    source: string;
+    timestamp?: string;
+}
+export interface ConstraintCard {
+    text: string;
+    source_id: string;
+    source_path?: string;
+}
+export interface ExampleCard {
+    id: string;
+    title: string;
+    source: string;
+    summary: string;
+    timestamp?: string;
+    expand: {
+        route: string;
+        params: Record<string, unknown>;
+    };
+}
+export interface RuleCard {
+    id: string;
+    title: string;
+    snippet: string;
+    source_path?: string;
+    expand: {
+        route: string;
+        params: Record<string, unknown>;
+    };
+}
+export interface ContextPack {
+    task: string;
+    decisions: DecisionCard[];
+    constraints: ConstraintCard[];
+    examples: ExampleCard[];
+    rules: RuleCard[];
+    total_bytes: number;
+    truncated: boolean;
+    degraded: boolean;
+    degraded_reason?: string;
+}
+export interface BuildContextPackOptions {
+    task: string;
+    embedding: EmbeddingProvider;
+    cwd?: string;
+    sources?: readonly SourceDir[];
+    since?: string;
+    maxPerBucket?: number;
+    maxBytes?: number;
+}
+export declare function buildContextPack(opts: BuildContextPackOptions): Promise<ContextPack>;
+/**
+ * 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 declare function filterByRelevance(ranked: RankedResult[], floor: number): RankedResult[];
+export declare function extractConstraintLines(content: string): string[];
+/**
+ * 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 declare function isRawConversationPath(p: unknown): boolean;
+export declare function shouldExcludeDocFromRules(p: unknown): boolean;
+//# sourceMappingURL=context-pack.d.ts.map

package/dist/src/retrieval/context-pack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-pack.d.ts","sourceRoot":"","sources":["../../../src/retrieval/context-pack.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC/D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAErD,OAAO,EAAU,KAAK,YAAY,EAAE,MAAM,eAAe,CAAC;AAM1D,eAAO,MAAM,aAAa,MAAM,CAAC;AACjC,eAAO,MAAM,WAAW,MAAM,CAAC;AAC/B,eAAO,MAAM,sBAAsB,IAAI,CAAC;AACxC,eAAO,MAAM,sBAAsB,KAAK,CAAC;AACzC,eAAO,MAAM,iBAAiB,OAAO,CAAC;AACtC,eAAO,MAAM,iBAAiB,QAAQ,CAAC;AACvC,qHAAqH;AACrH,eAAO,MAAM,QAAQ,OAAO,CAAC;AAE7B;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,yBAAyB,MAAM,CAAC;AAC7C,eAAO,MAAM,wBAAwB,MAAM,CAAC;AAQ5C,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,CAAC;CAC5D;AAED,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,CAAC;CAC5D;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,YAAY,EAAE,CAAC;IAC1B,WAAW,EAAE,cAAc,EAAE,CAAC;IAC9B,QAAQ,EAAE,WAAW,EAAE,CAAC;IACxB,KAAK,EAAE,QAAQ,EAAE,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,OAAO,CAAC;IACnB,QAAQ,EAAE,OAAO,CAAC;IAClB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,iBAAiB,CAAC;IAC7B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,SAAS,SAAS,EAAE,CAAC;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAID,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,uBAAuB,GAC5B,OAAO,CAAC,WAAW,CAAC,CA0GtB;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,YAAY,EAAE,EACtB,KAAK,EAAE,MAAM,GACZ,YAAY,EAAE,CAIhB;AAoLD,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAYhE;AA2OD;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAEzD;AAwCD,wBAAgB,yBAAyB,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAG7D"}

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

@@ -0,0 +1,553 @@
+import { hybridSearch } from "./hybrid.js";
+import { rerank } from "./reranker.js";
+import { getTable } from "../storage/tables.js";
+import { resolveCwdRoot } from "./cwd.js";
+// --- Locked caps ---
+export const ITEM_TEXT_MAX = 200;
+export const SNIPPET_MAX = 200;
+export const DEFAULT_MAX_PER_BUCKET = 3;
+export const MAX_PER_BUCKET_CEILING = 10;
+export const DEFAULT_MAX_BYTES = 4096;
+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;
+// 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;
+// --- 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 scopes 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 fetch uses scope="all" and filters to doc tables afterwards,
+    // 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.
+    const fetchK = maxPerBucket * CANDIDATE_FETCH_MULTIPLIER;
+    const [convRes, docRes] = await Promise.all([
+        hybridSearch(opts.task, opts.embedding, {
+            scope: "conversations",
+            top_k: fetchK,
+            ...(opts.since ? { since: opts.since } : {}),
+        }),
+        hybridSearch(opts.task, opts.embedding, {
+            scope: "all",
+            top_k: fetchK,
+            ...(opts.since ? { since: opts.since } : {}),
+            ...(sourcePathPrefix ? { sourcePathPrefix } : {}),
+        }),
+    ]);
+    const degraded = convRes.degraded || docRes.degraded;
+    const degradedReason = convRes.degraded_reason ?? docRes.degraded_reason;
+    const convRanked = rerank(toRerankInput(convRes.candidates)).slice(0, fetchK);
+    const docRanked = rerank(toRerankInput(docRes.candidates.filter((c) => c.source_table === "structured_docs" ||
+        c.source_table === "structured_docs_local"))).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] = await Promise.all([
+        fetchRowsById(convRanked),
+        fetchRowsById(docRanked),
+    ]);
+    // 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(r.id)?.["source_path"]));
+    const decisions = extractDecisions(filterByRelevance(convRanked, DECISIONS_RELEVANCE_FLOOR), convRows, maxPerBucket);
+    const examples = buildExamples(filterByRelevance(convRanked, EXAMPLES_RELEVANCE_FLOOR), convRows, maxPerBucket);
+    const rules = buildRules(docRankedClean, docRows, maxPerBucket);
+    const constraints = extractConstraints(docRankedClean, docRows, maxPerBucket);
+    const assembled = enforceBudget({ decisions, constraints, examples, rules }, {
+        maxBytes,
+        task: opts.task,
+        degraded,
+        ...(degradedReason ? { degradedReason } : {}),
+    });
+    const pack = {
+        task: opts.task,
+        decisions: assembled.decisions,
+        constraints: assembled.constraints,
+        examples: assembled.examples,
+        rules: assembled.rules,
+        total_bytes: assembled.totalBytes,
+        truncated: assembled.truncated,
+        degraded,
+    };
+    if (degradedReason)
+        pack.degraded_reason = degradedReason;
+    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);
+}
+// --- Bucket builders ---
+function extractDecisions(ranked, rows, cap) {
+    const out = [];
+    const seen = new Set();
+    for (const r of ranked) {
+        if (out.length >= cap)
+            break;
+        const row = rows.get(r.id);
+        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 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 };
+            if (timestamp)
+                card.timestamp = timestamp;
+            out.push(card);
+        }
+    }
+    return out;
+}
+function buildExamples(ranked, rows, cap) {
+    const out = [];
+    for (const r of ranked) {
+        if (out.length >= cap)
+            break;
+        const row = rows.get(r.id);
+        const summary = truncate(collapseWhitespace(row?.["summary"] || row?.["content"] || r.content), SNIPPET_MAX);
+        if (!summary)
+            continue;
+        const title = deriveExampleTitle(row, summary);
+        const source = row?.["source"] || "conversation";
+        const timestamp = row?.["indexed_at"] || undefined;
+        const card = {
+            id: r.id,
+            title,
+            source,
+            summary,
+            expand: {
+                route: "/search",
+                params: {
+                    id: r.id,
+                    tier: r.source_table === "conversations_cold" ? "cold" : "hot",
+                    source_table: r.source_table,
+                    detail: "full",
+                },
+            },
+        };
+        if (timestamp)
+            card.timestamp = timestamp;
+        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(r.id);
+        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 card = {
+            id: r.id,
+            title,
+            snippet,
+            expand: {
+                route: "/search",
+                params: {
+                    id: r.id,
+                    tier: "structured_doc",
+                    source_table: r.source_table,
+                    detail: "full",
+                },
+            },
+        };
+        if (sourcePath)
+            card.source_path = sourcePath;
+        out.push(card);
+    }
+    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(r.id);
+        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: [],
+    };
+    let totalBytes = envelopeBytes(output, ctx);
+    let truncated = false;
+    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;
+        }
+    }
+    // Any items still sitting in the queues were dropped for budget.
+    for (const key of order) {
+        if (queues[key].length > 0) {
+            truncated = true;
+            break;
+        }
+    }
+    return {
+        decisions: output.decisions,
+        constraints: output.constraints,
+        examples: output.examples,
+        rules: output.rules,
+        totalBytes,
+        truncated,
+    };
+}
+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.
+    const envelope = {
+        task: ctx.task,
+        decisions: buckets.decisions,
+        constraints: buckets.constraints,
+        examples: buckets.examples,
+        rules: buckets.rules,
+        total_bytes: ctx.maxBytes,
+        truncated: true,
+        degraded: ctx.degraded,
+    };
+    if (ctx.degradedReason)
+        envelope["degraded_reason"] = ctx.degradedReason;
+    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);
+    }
+    const out = new Map();
+    for (const [tableName, ids] of byTable) {
+        if (ids.length === 0)
+            continue;
+        const quoted = ids.map((i) => `'${i.replace(/'/g, "''")}'`).join(",");
+        const rows = (await getTable(tableName)
+            .query()
+            .where(`id IN (${quoted})`)
+            .limit(ids.length)
+            .toArray());
+        for (const row of rows) {
+            out.set(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);
+}
+/**
+ * Paths that should never populate the `rules` / `constraints` buckets.
+ * Explicitly enumerate 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));
+}
+//# sourceMappingURL=context-pack.js.map