@getrift/rift 0.1.0-beta.12 → 0.1.0-beta.13

package/dist/src/retrieval/current-truth.js

@@ -0,0 +1,747 @@
+/**
+ * Phrase triggers for `reasoning_archive`. Multi-word — these must be
+ * matched in word order against the lower-cased query. A reasoning
+ * question is almost always phrased with possessive ("my take") or
+ * historical-tense framing ("why did I", "how did I frame") — single-
+ * keyword matching would catch too many false positives.
+ */
+const REASONING_PHRASE_TRIGGERS = [
+    "why did i",
+    "why did we",
+    "what did i decide",
+    "what did we decide",
+    "how did i frame",
+    "how did we frame",
+    "my take",
+    "my view",
+    "my philosophy",
+    "relationship between",
+];
+/**
+ * Single-word triggers for `reasoning_archive`. These score the query as
+ * a taste/philosophy/origin question — old conversations are the right
+ * evidence, not trackers.
+ */
+const REASONING_WORD_TRIGGERS = [
+    "favorite",
+    "favorites",
+    "favourite",
+    "favourites",
+    "taste",
+    "philosophy",
+    "origin",
+    "lineage",
+];
+/**
+ * Phrase triggers for `current_truth`. Indicates the asker wants the
+ * present-tense state, not historical reasoning.
+ */
+const CURRENT_PHRASE_TRIGGERS = [
+    "what's next",
+    "whats next",
+    "what is next",
+    "install path",
+];
+/**
+ * Single-word triggers for `current_truth`. Strong signal that the
+ * answer should lead with trackers / source / recent state.
+ *
+ * `customers`/`clients`/`roster`/`freelancer` cover roster-shape
+ * questions (Q4: "who are Clément's customers as a freelancer") —
+ * roster questions are present-tense state, not historical reasoning,
+ * so they belong here even though they don't carry an explicit
+ * "current" / "today" marker.
+ */
+const CURRENT_WORD_TRIGGERS = [
+    "current",
+    "latest",
+    "today",
+    "now",
+    "state",
+    "status",
+    "next",
+    "roadmap",
+    "launch",
+    "pending",
+    "shipped",
+    "version",
+    "customers",
+    "customer",
+    "clients",
+    "roster",
+    "freelancer",
+    "freelance",
+];
+/**
+ * Classify a query's evidence intent. Deterministic and transparent so
+ * v0 can be debugged by eye. Algorithm:
+ *
+ *   1. Lower-case the query.
+ *   2. Check phrase triggers (multi-word) for each intent.
+ *   3. Check single-word triggers (matched as whole words via word
+ *      boundaries — no partial matches like "currently" → "current").
+ *   4. If exactly one intent matches → that intent.
+ *   5. If both match → return `blended` (the asker is conflating
+ *      "what's my taste on the current X").
+ *   6. If neither matches → `blended`.
+ *
+ * Note on Q7 ("difference between second brain and Rift"): only
+ * `relationship between` is in the reasoning-archive trigger list, not
+ * `difference between`. Q7 fires no trigger and falls to `blended`,
+ * which is the deliberate v0 outcome — disambiguation questions surface
+ * both the current product framing and the historical context without
+ * forcing an order.
+ */
+export function classifyEvidenceIntent(query) {
+    const q = (query || "").toLowerCase();
+    if (!q.trim())
+        return "blended";
+    const reasoning = hasAnyPhrase(q, REASONING_PHRASE_TRIGGERS) ||
+        hasAnyWord(q, REASONING_WORD_TRIGGERS);
+    const current = hasAnyPhrase(q, CURRENT_PHRASE_TRIGGERS) ||
+        hasAnyWord(q, CURRENT_WORD_TRIGGERS);
+    if (current && !reasoning)
+        return "current_truth";
+    if (reasoning && !current)
+        return "reasoning_archive";
+    return "blended";
+}
+const CURRENT_STATE_CLAIM_WORDS = [
+    "current",
+    "latest",
+    "today",
+    "now",
+    "state",
+    "status",
+    "next",
+    "roadmap",
+    "launch",
+    "pending",
+    "shipped",
+    "version",
+    "install",
+    "onboarding",
+    "customer",
+    "customers",
+    "clients",
+    "roster",
+];
+const FRAMING_CLAIM_WORDS = [
+    "pricing",
+    "price",
+    "brand",
+    "framing",
+    "history",
+    "positioning",
+    "narrative",
+    "messaging",
+];
+/**
+ * Unambiguous rationale signals — always a reasoning claim. "decision" /
+ * "decide" are deliberately NOT here: they're ambiguous (see
+ * {@link DECISION_CLAIM_WORDS}).
+ */
+const REASONING_CLAIM_WORDS = [
+    "why",
+    "taste",
+    "relationship",
+    "philosophy",
+    "favorite",
+    "favourite",
+    "origin",
+    "rationale",
+];
+/**
+ * Rationale-shaped phrases — "why/how did we decide", "reasoning behind".
+ * These pin a decision query to reasoning regardless of qualifiers.
+ */
+const REASONING_CLAIM_PHRASES = [
+    "why did",
+    "why we",
+    "how did we decide",
+    "how we decided",
+    "reasoning behind",
+    "rationale behind",
+    "thinking behind",
+];
+/**
+ * Ambiguous decision words. "What's the latest decision about X" is a
+ * current-state question (what the decision *is*); "why did we decide X"
+ * is reasoning (caught by {@link REASONING_CLAIM_PHRASES}). So a bare
+ * decision word is reasoning ONLY when no current-state qualifier is
+ * present — otherwise the qualifier wins.
+ */
+const DECISION_CLAIM_WORDS = ["decision", "decide", "decided"];
+/**
+ * Classify the claim-type of a query. Precedence: rationale phrases →
+ * strong reasoning words → ambiguous decision-without-current-qualifier →
+ * current_state → framing → default current_state. A "why did we decide X"
+ * question is reasoning even if it mentions a current-state noun; "latest
+ * decision about X" is a current-state question (P2 fix). An ambiguous
+ * query defaults to the strictest tier discipline (current_state) so we
+ * never under-apply the trust gating.
+ */
+export function classifyClaimType(query) {
+    const q = (query || "").toLowerCase();
+    if (!q.trim())
+        return "current_state";
+    if (hasAnyPhrase(q, REASONING_CLAIM_PHRASES))
+        return "reasoning";
+    if (hasAnyWord(q, REASONING_CLAIM_WORDS))
+        return "reasoning";
+    const hasCurrentQualifier = hasAnyWord(q, CURRENT_STATE_CLAIM_WORDS);
+    if (hasAnyWord(q, DECISION_CLAIM_WORDS) && !hasCurrentQualifier) {
+        return "reasoning";
+    }
+    if (hasCurrentQualifier)
+        return "current_state";
+    if (hasAnyWord(q, FRAMING_CLAIM_WORDS))
+        return "framing";
+    return "current_state";
+}
+function hasAnyPhrase(q, phrases) {
+    return phrases.some((p) => q.includes(p));
+}
+function hasAnyWord(q, words) {
+    for (const w of words) {
+        const rx = new RegExp(`\\b${escapeRx(w)}\\b`, "i");
+        if (rx.test(q))
+            return true;
+    }
+    return false;
+}
+function escapeRx(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+// ─── Freshness / canonicalness classification ───────────────────────────
+/**
+ * Default freshness cutoff: a hit indexed within `RECENT_WINDOW_DAYS` of
+ * "now" counts as recent. 21 days is wide enough that a paused-but-
+ * active project's tracker still reads as current, and narrow enough
+ * that an April-26 LAUNCH.md (now ~3 weeks old by 2026-05-19) starts
+ * looking stale relative to a 2026-05-19 PROJECT_STATE.md edit.
+ */
+export const RECENT_WINDOW_DAYS = 21;
+/**
+ * Source-path patterns that mark a hit as a current-truth-shaped
+ * artifact — the kind of file you'd open by hand to answer "what's the
+ * state right now". Tracker files at the project root, source code,
+ * install scripts, and the package manifest all qualify. Matched on
+ * basename for the manifests/READMEs (so per-project copies count) and
+ * on path segments for src/scripts.
+ */
+const TRACKER_PATH_PATTERNS = [
+    /(^|\/)PROJECT_STATE\.md$/i,
+    /(^|\/)TODO\.md$/i,
+    /(^|\/)README\.md$/i,
+    /(^|\/)README\.dev\.md$/i,
+    /(^|\/)CLAUDE\.md$/i,
+    /(^|\/)AGENTS\.md$/i,
+    /(^|\/)package\.json$/i,
+    /\/src\//,
+    /\/scripts\//,
+    /(^|\/)config\.json$/i,
+];
+/**
+ * Source-path patterns that mark a hit as a *snapshot* — useful as
+ * historical context but not as current truth. Reports/insights are the
+ * obvious case (Opus overnight passes), plus filename markers like
+ * `-snapshot-`, `-overnight-`, and `-pass-N` that consistently denote
+ * frozen syntheses.
+ *
+ * `LAUNCH.md` is intentionally NOT in this list as of v1: the git-state
+ * probe ({@link GitState}) is the general signal — an untracked file is
+ * discounted regardless of basename, and removing the hardcoded entry
+ * means we don't mis-discount a future `LAUNCH.md` that does get
+ * committed to a project as durable launch state.
+ */
+const SNAPSHOT_PATH_PATTERNS = [
+    /\/reports\/insights\//i,
+    /\/reports\/backfill-audit\//i,
+    /-snapshot-/i,
+    /-overnight-/i,
+    /-pass-\d+/i,
+];
+export function isTrackerPath(p) {
+    return typeof p === "string" && TRACKER_PATH_PATTERNS.some((rx) => rx.test(p));
+}
+export function isSnapshotPath(p) {
+    return typeof p === "string" && SNAPSHOT_PATH_PATTERNS.some((rx) => rx.test(p));
+}
+/** Live/executable state: source, scripts, manifests, config. */
+const LIVE_STATE_PATH_PATTERNS = [
+    /\/src\//,
+    /\/scripts\//,
+    /(^|\/)package\.json$/i,
+    /(^|\/)config\.json$/i,
+    /(^|\/)install\.sh$/i,
+];
+/** Intentional state trackers. */
+const TRACKER_FILE_PATTERNS = [
+    /(^|\/)PROJECT_STATE\.md$/i,
+    /(^|\/)TODO\.md$/i,
+];
+/** Durable committed framing docs. */
+const COMMITTED_DOC_PATTERNS = [
+    /(^|\/)README(\.[a-z]+)?\.md$/i,
+    /(^|\/)CLAUDE\.md$/i,
+    /(^|\/)AGENTS\.md$/i,
+    /(^|\/)PRD\.md$/i,
+    /(^|\/)PLAN\.md$/i,
+];
+function matchesAny(p, patterns) {
+    return patterns.some((rx) => rx.test(p));
+}
+/**
+ * Assign a {@link TrustTier} to one evidence input. Pure, structural,
+ * claim-type-independent: git-state is the strongest signal (an untracked
+ * or deleted document is `discounted` no matter how it's named — the v1
+ * generalization of the LAUNCH.md hack), then snapshot paths, then the
+ * path-pattern ladder. Conversations are always `discussion`.
+ *
+ * Defaults to `committed_doc` for a tracked/unknown document that matches
+ * none of the specific ladders — it's a durable file we just can't place
+ * more precisely, which is a safer default than claiming it's live state.
+ */
+export function assignTrustTier(kind, gitState, sourcePath) {
+    if (kind === "conversation")
+        return "discussion";
+    if (gitState === "untracked" || gitState === "deleted")
+        return "discounted";
+    if (isSnapshotPath(sourcePath))
+        return "discounted";
+    const p = typeof sourcePath === "string" ? sourcePath : "";
+    if (p && matchesAny(p, LIVE_STATE_PATH_PATTERNS))
+        return "live_state";
+    if (p && matchesAny(p, TRACKER_FILE_PATTERNS))
+        return "tracker";
+    if (p && matchesAny(p, COMMITTED_DOC_PATTERNS))
+        return "committed_doc";
+    return "committed_doc";
+}
+/**
+ * Parse a row's `indexed_at` and return whether it falls within the
+ * recency window. Robust to missing / unparseable timestamps — we'd
+ * rather call a row "unknown-age" (treated as not-recent) than blow up
+ * the answer packaging.
+ */
+export function isRecent(indexedAt, now = new Date(), windowDays = RECENT_WINDOW_DAYS) {
+    if (!indexedAt)
+        return false;
+    const t = Date.parse(indexedAt);
+    if (Number.isNaN(t))
+        return false;
+    const ageMs = now.getTime() - t;
+    return ageMs <= windowDays * 24 * 60 * 60 * 1000;
+}
+/** Hard rule 3 caveat string — single source so renderer + DTO agree. */
+export const TRACKER_ONLY_CAVEAT = "tracker-backed, not live-verified";
+/**
+ * Snippet cap for evidence cards. Mirrors `SNIPPET_MAX` in context-pack,
+ * intentionally duplicated here to keep this module decoupled.
+ */
+const EVIDENCE_SNIPPET_MAX = 200;
+export function partitionEvidence(inputs, opts) {
+    const cap = opts.maxPerSection;
+    const now = opts.now ?? new Date();
+    const out = {
+        current_truth: [],
+        past_reasoning: [],
+        older_memory: [],
+        discounted: [],
+        recommended_live_files: [],
+        conflicts: [],
+    };
+    // Track tracker-paths we encounter so the recommended_live_files fallback
+    // can prefer paths the index already knows about. Value is the
+    // pre-probed git state (if any) so the recommendation card can echo
+    // it back to the asker (e.g. "newer on disk than indexed copy").
+    const seenTrackerPaths = new Map();
+    // Tracker paths surfaced in hits with a live git state — eligible for
+    // promotion to `recommended_live_files`. We exclude `untracked` and
+    // `deleted` here: recommending a file the asker can't open or that
+    // isn't under version control would defeat the point.
+    const recommendableGitStates = new Set([
+        "tracked",
+        "modified",
+        "newer_on_disk",
+        undefined,
+    ]);
+    // Basenames of paths the partitioner discounted as untracked or
+    // deleted. The canonical fallback list is hand-written basenames
+    // (`PROJECT_STATE.md`, `TODO.md`, `package.json`) and was probed
+    // alongside the rest of the hits — so if any of those basenames
+    // were already discounted, the recommendation must drop them
+    // rather than re-suggest them. Tracked via basename because the
+    // canonical fallback doesn't have absolute paths to match against.
+    const discountedBasenames = new Set();
+    for (const input of inputs) {
+        const { row, kind, gitState } = input;
+        const sourcePath = row?.["source_path"] || undefined;
+        const indexedAt = row?.["indexed_at"] || undefined;
+        const recent = isRecent(indexedAt, now);
+        const tracker = isTrackerPath(sourcePath);
+        const snapshot = isSnapshotPath(sourcePath);
+        const card = buildEvidenceCard(input);
+        if (!card)
+            continue;
+        if (tracker &&
+            sourcePath &&
+            recommendableGitStates.has(gitState)) {
+            seenTrackerPaths.set(sourcePath, gitState);
+        }
+        if (opts.intent === "reasoning_archive") {
+            if (kind === "conversation") {
+                pushIfRoom(out.past_reasoning, card, cap);
+            }
+            else if (tracker) {
+                pushIfRoom(out.current_truth, card, cap);
+            }
+            else if (snapshot) {
+                pushIfRoom(out.older_memory, card, cap);
+            }
+            else {
+                pushIfRoom(out.older_memory, card, cap);
+            }
+            continue;
+        }
+        // v1 git-state discounts. Apply ONLY to documents and ONLY in
+        // current-truth-shaped modes (current_truth + blended). Conversations
+        // don't have a meaningful git state, and reasoning_archive mode
+        // (handled above) cares about framing, not canonicalness.
+        if (kind === "document" && gitState === "deleted") {
+            pushIfRoom(out.discounted, withReason(card, "deleted from disk"), cap);
+            if (sourcePath)
+                discountedBasenames.add(basename(sourcePath));
+            continue;
+        }
+        if (kind === "document" && gitState === "untracked") {
+            pushIfRoom(out.discounted, withReason(card, "untracked in git (not committed)"), cap);
+            if (sourcePath)
+                discountedBasenames.add(basename(sourcePath));
+            continue;
+        }
+        if (opts.intent === "current_truth") {
+            // v2 hard rule 1: conversations can NEVER enter `current_truth` on
+            // recency alone. This is the load-bearing fix — it breaks the
+            // `untrusted source → recent conversation → current_truth` laundering
+            // loop (and its self-corroboration variant where a captured Rift
+            // answer re-enters as evidence). Recent conversations surface as
+            // `past_reasoning` ("recent discussion"); older ones as `older_memory`.
+            // Demote-by-default: a conversation is never sole authority here.
+            if (kind === "conversation") {
+                pushIfRoom(recent ? out.past_reasoning : out.older_memory, card, cap);
+            }
+            else if (tracker) {
+                pushIfRoom(out.current_truth, card, cap);
+            }
+            else if (snapshot) {
+                pushIfRoom(out.discounted, withReason(card, "snapshot or insight report"), cap);
+            }
+            else if (!recent) {
+                pushIfRoom(out.discounted, withReason(card, "older document"), cap);
+            }
+            else {
+                pushIfRoom(out.current_truth, card, cap);
+            }
+            continue;
+        }
+        // blended
+        if (tracker) {
+            pushIfRoom(out.current_truth, card, cap);
+        }
+        else if (kind === "conversation") {
+            pushIfRoom(out.past_reasoning, card, cap);
+        }
+        else if (snapshot) {
+            pushIfRoom(out.discounted, withReason(card, "snapshot or insight report"), cap);
+        }
+        else if (recent) {
+            pushIfRoom(out.current_truth, card, cap);
+        }
+        else {
+            pushIfRoom(out.older_memory, card, cap);
+        }
+    }
+    // v2 hard rule 5 (staleness demotion): a tracker is *not* absolute. If
+    // `current_truth` holds a `live_state`-tier card and a tracker/
+    // committed_doc card is older than that live evidence by more than the
+    // recency window, the tracker is stale relative to live activity —
+    // demote it to `older_memory` (tier label retained so the demotion is
+    // visible). Runs before the recommended-live-files check so an emptied
+    // `current_truth` correctly triggers the "read the live files" fallback.
+    if (opts.intent !== "reasoning_archive") {
+        applyStalenessDemotion(out, now, cap);
+    }
+    // Recommended live files: only for current_truth and blended, and only
+    // when `current_truth` is empty or so thin that the asker should read
+    // the live files before trusting the answer. The list is sourced from
+    // tracker paths we already saw in hits (so we're naming real, indexed
+    // files), with a small set of canonical fallbacks if none surfaced.
+    if (opts.intent !== "reasoning_archive") {
+        const dominatedByOlder = out.current_truth.length === 0 &&
+            (out.discounted.length > 0 || out.older_memory.length > 0);
+        const veryThin = out.current_truth.length === 0;
+        if (dominatedByOlder || veryThin) {
+            out.recommended_live_files = recommendLiveFiles(seenTrackerPaths, opts.projectRoot, discountedBasenames);
+        }
+    }
+    // v2 hard rule 3 (caveat): `current_truth` is populated but holds no
+    // `live_state`-tier evidence — the best we have is an intentional
+    // tracker, not executable/observable state. Label it honestly.
+    if (opts.intent !== "reasoning_archive" &&
+        out.current_truth.length > 0 &&
+        !out.current_truth.some((c) => c.tier === "live_state")) {
+        out.current_truth_caveat = TRACKER_ONLY_CAVEAT;
+    }
+    // v2 hard rule 4 (surface conflicts): a discounted current-state-shaped
+    // source competing with higher-tier evidence is a disagreement, not a
+    // loser to silently drop. Name the tension; do not adjudicate it.
+    if (opts.intent !== "reasoning_archive") {
+        out.conflicts = buildConflicts(out, opts.claimType ?? "current_state");
+    }
+    return out;
+}
+/**
+ * Move stale trackers out of `current_truth` (hard rule 5). A tracker /
+ * committed_doc card older than the freshest `live_state` card by more
+ * than {@link RECENT_WINDOW_DAYS} is demoted to `older_memory`. No-op
+ * when `current_truth` has no live-state anchor to compare against —
+ * without live evidence we have no basis to call a tracker stale.
+ *
+ * P1 fix: the demotable card's age is its *self-declared* freshness
+ * (`tracker_date`, e.g. PROJECT_STATE.md's `Last touched:`) when present,
+ * not `indexed_at`. A tracker reindexed today but whose own date is weeks
+ * old must still be demotable — `indexed_at` would mask that.
+ */
+function applyStalenessDemotion(out, now, cap) {
+    void now;
+    const liveTimes = out.current_truth
+        .filter((c) => c.tier === "live_state" && c.timestamp)
+        .map((c) => Date.parse(c.timestamp))
+        .filter((t) => !Number.isNaN(t));
+    if (liveTimes.length === 0)
+        return;
+    const freshestLive = Math.max(...liveTimes);
+    const windowMs = RECENT_WINDOW_DAYS * 24 * 60 * 60 * 1000;
+    const kept = [];
+    for (const c of out.current_truth) {
+        const demotable = c.tier === "tracker" || c.tier === "committed_doc";
+        const anchor = c.tracker_date ?? c.timestamp;
+        const t = anchor ? Date.parse(anchor) : NaN;
+        if (demotable && !Number.isNaN(t) && freshestLive - t > windowMs) {
+            pushIfRoom(out.older_memory, c, cap);
+            continue;
+        }
+        kept.push(c);
+    }
+    out.current_truth = kept;
+}
+/**
+ * Build at most one conflict card (v2 restraint — surface the strongest
+ * tension, not every stale doc). Fires when a discounted source exists
+ * and there's higher-trust evidence to supersede it: the top
+ * `current_truth` card, else the first recommended live file. Returns []
+ * when there's nothing discounted, or nothing trustworthy to supersede
+ * it (in which case the honest answer is the recommended-live-files
+ * surface, not a manufactured conflict).
+ */
+function buildConflicts(out, claim) {
+    const loser = out.discounted[0];
+    if (!loser)
+        return [];
+    const winnerCard = out.current_truth[0];
+    if (winnerCard) {
+        const superseded = {
+            title: winnerCard.title,
+            tier: winnerCard.tier ?? "committed_doc",
+        };
+        if (winnerCard.source_path)
+            superseded.source_path = winnerCard.source_path;
+        return [conflictCard(claim, loser, superseded)];
+    }
+    const winnerFile = out.recommended_live_files[0];
+    if (winnerFile) {
+        const superseded = {
+            title: winnerFile.path,
+            tier: assignTrustTier("document", winnerFile.git_state, winnerFile.path),
+            source_path: winnerFile.path,
+        };
+        return [conflictCard(claim, loser, superseded)];
+    }
+    return [];
+}
+function conflictCard(claim, loser, superseded_by) {
+    const discounted = {
+        title: loser.title,
+        reason: loser.reason,
+    };
+    if (loser.source_path)
+        discounted.source_path = loser.source_path;
+    return { claim, discounted, superseded_by };
+}
+function pushIfRoom(arr, item, cap) {
+    if (arr.length >= cap)
+        return;
+    arr.push(item);
+}
+function withReason(card, reason) {
+    return { ...card, reason };
+}
+function buildEvidenceCard(input) {
+    const { ranked, row, kind, gitState } = input;
+    const fullContent = row?.["content"] || ranked.content || "";
+    const summary = row?.["summary"] ||
+        fullContent.split(/\r?\n/).find((l) => l.trim()) ||
+        "";
+    const snippet = truncate(collapseWhitespace(summary), EVIDENCE_SNIPPET_MAX);
+    if (!snippet)
+        return null;
+    const sourcePath = row?.["source_path"] || undefined;
+    const indexedAt = row?.["indexed_at"] || undefined;
+    const source = row?.["source"] || (kind === "document" ? "document" : "conversation");
+    const title = deriveTitle(row, sourcePath, snippet);
+    const card = {
+        id: ranked.id,
+        title,
+        source,
+        snippet,
+    };
+    if (indexedAt)
+        card.timestamp = indexedAt;
+    if (sourcePath)
+        card.source_path = sourcePath;
+    if (gitState)
+        card.git_state = gitState;
+    card.tier = assignTrustTier(kind, gitState, sourcePath);
+    const trackerDate = parseTrackerDate(fullContent);
+    if (trackerDate)
+        card.tracker_date = trackerDate;
+    return card;
+}
+/**
+ * Best-effort parse of a tracker's self-declared freshness from its
+ * content. Currently the `Last touched: YYYY-MM-DD` line that
+ * PROJECT_STATE.md carries near the top. Returns the matched ISO date
+ * string, or undefined when the chunk doesn't contain the marker (the
+ * caller falls back to `indexed_at`). Tolerates optional markdown
+ * bold/list decoration around the label.
+ */
+export function parseTrackerDate(content) {
+    if (!content)
+        return undefined;
+    const m = content.match(/(?:^|\n)\s*(?:[-*]\s*)?(?:\*\*)?Last touched:?(?:\*\*)?\s*:?\s*(\d{4}-\d{2}-\d{2})/i);
+    return m ? m[1] : undefined;
+}
+function deriveTitle(row, sourcePath, snippet) {
+    const meta = row?.["metadata"];
+    if (typeof meta === "string" && meta) {
+        try {
+            const parsed = JSON.parse(meta);
+            const t = parsed["title"];
+            if (typeof t === "string" && t.trim())
+                return truncate(t.trim(), 120);
+        }
+        catch {
+            // ignore
+        }
+    }
+    if (sourcePath) {
+        const base = sourcePath.split("/").filter(Boolean).pop();
+        if (base)
+            return truncate(base, 120);
+    }
+    const topics = row?.["topics"];
+    if (typeof topics === "string" && topics) {
+        try {
+            const arr = JSON.parse(topics);
+            if (Array.isArray(arr) && arr.length > 0) {
+                return truncate(arr.filter((x) => typeof x === "string").slice(0, 3).join(", "), 120);
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    return truncate(firstLine(snippet) || "(item)", 120);
+}
+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 collapseWhitespace(text) {
+    return text.replace(/\s+/g, " ").trim();
+}
+function truncate(text, max) {
+    if (text.length <= max)
+        return text;
+    return text.slice(0, max);
+}
+function basename(p) {
+    const parts = p.split("/").filter(Boolean);
+    return parts[parts.length - 1] ?? p;
+}
+/**
+ * Canonical fallback list when the asker is in current_truth/blended
+ * mode and we have *no* tracker hits to point at. These are the files a
+ * human would open first on this project to check the present-tense
+ * state of things — naming them by hand here is honest because the
+ * caller hasn't actually read them; the phrasing in the markdown
+ * renderer reflects that ("Before trusting this answer, read/check …").
+ */
+const CANONICAL_LIVE_FILES = [
+    { path: "PROJECT_STATE.md", why: "current focus and recent decisions" },
+    { path: "TODO.md", why: "active work" },
+    { path: "package.json", why: "current version" },
+];
+function recommendLiveFiles(seen, projectRoot, discountedBasenames) {
+    if (seen.size > 0) {
+        const out = [];
+        for (const [p, gs] of seen) {
+            const why = describeTrackerPath(p);
+            const card = { path: displayPath(p, projectRoot), why };
+            if (gs)
+                card.git_state = gs;
+            out.push(card);
+            if (out.length >= 3)
+                break;
+        }
+        return out;
+    }
+    // Canonical fallback. Drop any entry whose basename was already
+    // discounted as untracked/deleted in this pack — the partitioner
+    // probed it, decided not to trust it, and the fallback would
+    // otherwise re-recommend it unprobed.
+    return CANONICAL_LIVE_FILES.filter((f) => !discountedBasenames.has(basename(f.path))).map((f) => ({ ...f }));
+}
+function describeTrackerPath(p) {
+    if (/PROJECT_STATE\.md$/i.test(p))
+        return "current focus and recent decisions";
+    if (/TODO\.md$/i.test(p))
+        return "active work";
+    if (/package\.json$/i.test(p))
+        return "current version";
+    if (/README/i.test(p))
+        return "stated install / usage";
+    if (/CLAUDE\.md$/i.test(p))
+        return "project conventions";
+    if (/AGENTS\.md$/i.test(p))
+        return "agent contract";
+    if (/\/src\//.test(p))
+        return "live source";
+    if (/\/scripts\//.test(p))
+        return "live script";
+    return "live file";
+}
+function displayPath(p, projectRoot) {
+    if (projectRoot && p.startsWith(projectRoot)) {
+        const rel = p.slice(projectRoot.length).replace(/^\//, "");
+        return rel || p;
+    }
+    return p;
+}
+//# sourceMappingURL=current-truth.js.map