limn-review 0.1.166 → 0.1.168

package/dist/api/plugins/rate-limit.js

@@ -177,6 +177,15 @@ function tierFor(method, path) {
     // EXACT `===` for the same near-miss.
     if (path === '/api/me/my-turn-settings')
         return [TIERS.read];
+    // PUT /api/me/feature-settings — Settings → Features (which sidebar destinations show). One
+    // validated UPDATE plus DB-only reads; no GitHub, no model. Recorded, EXACT `===`.
+    if (path === '/api/me/feature-settings')
+        return [TIERS.read];
+    // POST /api/me/review-suggestion/dismiss — Pending's one-time AI review card, dismissed for good.
+    // One UPDATE of one account column; no GitHub, no model (the card's Run goes through the review
+    // start route, which keeps its own tier). Recorded, EXACT `===`.
+    if (path === '/api/me/review-suggestion/dismiss')
+        return [TIERS.read];
     // PUT / DELETE /api/my-turn/dismissals/:kind/:id — dismiss or bring back one My Turn entry. One
     // ownership read and one upsert/delete on a tiny table; no GitHub call, no model call. Recorded
     // rather than inherited, and spelled with the `/`-terminated prefix: `/api/my-turn` itself (the
@@ -445,9 +454,16 @@ function tierFor(method, path) {
     // → search + ai + ai_hourly. Spelled EXACTLY here, above the family's `read` line: these GitHub reads
     // never reach the `hitsGithub` alternation below (that is the GitHub WRITE bucket, and this family
     // returns first).
-    if (method === 'POST' && (path === '/api/docs/wiki/preflight' || path === '/api/docs/github/preflight'))
+    // The wizard's "From your repositories" (`POST /api/docs/offers/check`, reference-docs/repo-offers-routes.ts)
+    // looks at up to DOCS_FROM_REPOS_SCAN_MAX repositories' trees on the reader's GitHub quota (a stored scan
+    // is reused) and runs no model → search + read, like the preflights. EXACT `===`.
+    if (method === 'POST' &&
+        (path === '/api/docs/wiki/preflight' || path === '/api/docs/github/preflight' || path === '/api/docs/offers/check'))
         return [TIERS.search, TIERS.read];
-    if (method === 'POST' && path === '/api/docs/github')
+    // THE DOCS OFFERS' ADD (reference-docs/repo-offers-routes.ts): each chosen folder is read on GitHub and
+    // its build queued, exactly as `POST /api/docs/github` → search + ai + ai_hourly. Its "Not now"
+    // (`/api/docs/offers/dismiss`) is DB only and falls to the family's `read` line.
+    if (method === 'POST' && (path === '/api/docs/github' || path === '/api/docs/offers/add'))
         return [TIERS.search, TIERS.ai, TIERS.aiHourly];
     if (path === '/api/docs' || path.startsWith('/api/docs/'))
         return [TIERS.read];

package/dist/api/routes/me.js

@@ -1,6 +1,6 @@
-import { MY_TURN_TOGGLES, validateMyTurnSettings } from '../../shared/index.js';
+import { FEATURE_IDS, MY_TURN_TOGGLES, resolveFeatures, validateMyTurnSettings } from '../../shared/index.js';
 import { config } from '../../config.js';
-import { accountToLocalUser, setBlastRadiusConfig, setLargePrCodeLocThreshold, setMyTurnSettings, } from '../../auth/account.js';
+import { accountToLocalUser, setBlastRadiusConfig, setFeatureSettings, setLargePrCodeLocThreshold, setMyTurnSettings, } from '../../auth/account.js';
 import { resolveLargePrThreshold } from '../../db/code-loc.js';
 import { exportAccountData } from '../../db/export-account.js';
 import { accountIdOf } from '../plugins/auth.js';
@@ -17,6 +17,29 @@ import { aiProviderSettingStatus, ALL_RUN_KINDS, CODEX_NOT_AVAILABLE_MESSAGE, CO
 import { getMyTurn } from '../../db/queries.js';
 import { clearDailyBriefCountsFor } from '../../db/daily-brief.js';
 import { dismissMyTurn, restoreMyTurn } from '../../db/my-turn-dismissals.js';
+import { featureFacts } from '../../db/feature-gates.js';
+import { dismissReviewSuggestion } from '../../db/pending-first-landing.js';
+// SETTINGS → FEATURES: the switches as a whole object (a PUT replaces it). Booleans only, the known
+// keys only; `null` resets every switch to its default.
+const featureSettingsSchema = {
+    body: {
+        type: 'object',
+        required: ['settings'],
+        additionalProperties: false,
+        properties: {
+            settings: {
+                type: ['object', 'null'],
+                additionalProperties: false,
+                properties: Object.fromEntries(FEATURE_IDS.map((k) => [k, { type: 'boolean' }])),
+            },
+        },
+    },
+};
+/** Which sidebar destinations show (shared features.ts). DB reads only. */
+async function featuresFor(accountId, account) {
+    const facts = await featureFacts(accountId, account?.featuresExistingInstall === true);
+    return resolveFeatures(account?.featureSettings ?? null, facts);
+}
 // The LARGE-PR FLAG's threshold. `null` is a first-class value meaning "reset to the product
 // default", so the type is the union — NOT an optional key, which would make "clear it" and
 // "don't change it" the same request. The bounds are validation, not taste: `minimum: 1` because a
@@ -272,6 +295,8 @@ export async function meRoutes(app) {
             // The MY TURN settings, RAW and nullable (the stored overrides) — the `blastRadius` rule: the
             // SPA resolves them through the ONE `resolveMyTurnSettings`, so nothing is duplicated here.
             myTurnSettings: req.account?.myTurnSettings ?? null,
+            // SETTINGS → FEATURES, resolved (visibility only; a deep link still opens a hidden one).
+            features: await featuresFor(accountId, req.account),
             // Orgs currently SAML-blocked for this account (empty in the normal case).
             authNotices: getAuthNotices(accountId),
         };
@@ -357,6 +382,27 @@ export async function meRoutes(app) {
         const body = { status: 'ok', myTurnSettings: stored };
         return body;
     });
+    // SETTINGS → FEATURES — the fourth ONE-PER-ACCOUNT setting: which sidebar destinations show.
+    // A PUT of the WHOLE switches object (null resets all); echoes what was STORED and the resolved
+    // result, so the sidebar and Settings agree without waiting for /api/me. Visibility only: no
+    // sync, read or scoring changes. Rate tier `read` (pinned in rate-limit.test.ts): one validated
+    // UPDATE plus the DB-only facts, no GitHub and no model.
+    app.put('/api/me/feature-settings', { schema: featureSettingsSchema }, async (req) => {
+        const accountId = accountIdOf(req);
+        const { settings } = req.body;
+        const stored = await setFeatureSettings(accountId, settings);
+        const features = await featuresFor(accountId, { ...req.account, featureSettings: stored });
+        const body = { status: 'ok', featureSettings: stored, features };
+        return body;
+    });
+    // PENDING'S ONE-TIME AI REVIEW SUGGESTION — dismissed for good (db/pending-first-landing.ts). One
+    // UPDATE of one account column, stamped once (a second press keeps the first time). Rate tier
+    // `read` (pinned in rate-limit.test.ts): no GitHub, no model.
+    app.post('/api/me/review-suggestion/dismiss', async (req) => {
+        await dismissReviewSuggestion(accountIdOf(req));
+        const body = { status: 'ok' };
+        return body;
+    });
     // Access + portability: the whole account as one JSON document (db/export-account.ts). Erasure
     // is deleting the local database file.
     app.get('/api/me/export', async (req, reply) => {

package/dist/api/routes/repos.js

@@ -22,6 +22,7 @@ const createRepoSchema = {
         properties: {
             owner: { type: 'string', minLength: 1 },
             name: { type: 'string', minLength: 1 },
+            firstRun: { type: 'boolean' },
         },
     },
 };
@@ -316,7 +317,7 @@ export async function repoRoutes(app) {
         return body;
     });
     app.post('/api/repos', { schema: createRepoSchema }, async (req, reply) => {
-        const { owner, name } = req.body;
+        const { owner, name, firstRun } = req.body;
         const accountId = accountIdOf(req);
         let resp;
         try {
@@ -350,7 +351,10 @@ export async function repoRoutes(app) {
         }
         const canonOwner = resp.repository.owner.login;
         const canonName = resp.repository.name;
-        const repoId = await upsertRepo(canonOwner, canonName, resp.repository.id, null, accountId);
+        const repoId = await upsertRepo(canonOwner, canonName, resp.repository.id, null, accountId, undefined, undefined, 
+        // The reader's add: decides the first-onboarding mark (My Turn's 7-day lookback, Pending's
+        // summary window) inside the same transaction as the insert.
+        { firstRun: firstRun === true });
         // No second visibility axis to set: `upsertRepo` gives the repo its workspace membership
         // in the same transaction, and a repo in a workspace is fully live — Feed, Activity, My
         // Turn and Bots all cover it. (The old `setRepoInboxWatch(accountId, repoId, true)` call
@@ -385,7 +389,7 @@ export async function repoRoutes(app) {
         // when its turn came (the walk's upsertRepo re-creates the row). Cancelling a queued
         // repo is synchronous: it dequeues + clears the progress row, so the delete can go.
         if (isSyncQueued(id))
-            requestSyncCancel(id);
+            requestSyncCancel(id, { dropFollowOns: true });
         // A sync in flight would re-create the repo (and its rows) right after we
         // delete them, since the sync's upserts are still running. Refuse until it
         // settles — the cron tick / initial backfill is short.

package/dist/auth/account.js

@@ -1,6 +1,6 @@
 import { execFileSync } from 'node:child_process';
 import { eq } from 'drizzle-orm';
-import { compactMyTurnSettings } from '../shared/index.js';
+import { compactFeatureSettings, compactMyTurnSettings } from '../shared/index.js';
 import { db, schema } from '../db/client.js';
 import { getGithubTokenAsync } from '../github/auth.js';
 const STALE_MS = 24 * 60 * 60 * 1000; // re-fetch the local identity once a day
@@ -35,6 +35,8 @@ function rowToAccount(row) {
         largePrCodeLocThreshold: row.largePrCodeLocThreshold ?? null,
         blastRadiusConfig: row.blastRadiusConfig ?? null,
         myTurnSettings: row.myTurnSettings ?? null,
+        featureSettings: row.featureSettings ?? null,
+        featuresExistingInstall: row.featuresExistingInstall,
     };
 }
 // Module cache of the local account, set by ensureLocalAccount() at startup so
@@ -294,6 +296,22 @@ export async function setMyTurnSettings(accountId, settings) {
     await refreshLocalAccountCache(accountId);
     return value;
 }
+/**
+ * SETTINGS → FEATURES: store the reader's switches (overrides only, compacted; null resets every
+ * switch to its default). Returns what was stored.
+ */
+export async function setFeatureSettings(accountId, settings) {
+    const { accounts } = schema;
+    const value = compactFeatureSettings(settings);
+    await db
+        .update(accounts)
+        .set({ featureSettings: value })
+        .where(eq(accounts.id, accountId))
+        .execute();
+    // ⚠ The settings rule above: without the refresh, /api/me would hand the old value back.
+    await refreshLocalAccountCache(accountId);
+    return value;
+}
 /**
  * Resolve an account's owner to a row in `users` (by login) if they've appeared
  * in any synced repo. Returns null when "you" haven't authored/acted anywhere

package/dist/coding/story-build/docs.js

@@ -13,14 +13,14 @@ import { pickReviewNonce } from '../../review/claude-review/prompts.js';
 import { buildBuildDocsPrompt, buildDocsAbouts, buildDocsSystemPrompt, buildDocsUntrustedTexts, } from '../../review/story-docs/build-prompts.js';
 import { validateBuildDocs } from '../../review/story-docs/build-validate.js';
 import { inlineSections, storyDocsRoots, storyDocsTurnCap } from '../../review/story-docs/prompts.js';
-import { prefilterSections, runShortlist, wholeLibraryShortlist } from '../../review/story-docs/shortlist.js';
+import { runShortlist, wholeLibraryShortlist } from '../../review/story-docs/shortlist.js';
 import { storyBuildLimits } from './limits.js';
 import { getStoryBuildRow, listStoryBuildRepoRows, updateStoryBuild } from './persist.js';
 // DOCS CONSIDERATION — WORK PACKAGE 3 (docs/STORY-BUILD.md § Docs consideration). THE STORY WINS.
 //
 //   runBuildDocs   the story-docs pipeline's `build` mode over ONE session: the frozen story (seed), the
 //                  gap fold and the CURRENT plan revision → the shortlist (the whole library when it fits,
-//                  else the BM25 prefilter → Haiku) → ONE low-effort read over the inlined sections,
+//                  else full-text search → Haiku) → ONE low-effort read over the inlined sections,
 //                  answering `submit_build_docs` (grounded / superseded / suggestion) → every reference
 //                  checked against the shortlisted documents (an unreferenced item DROPPED) → stored on the
 //                  SESSION's row (`docs_json`; never `story_docs_alignments`, so the per-story check's
@@ -137,11 +137,12 @@ export const runBuildDocs = async (ctx, { accountId, buildId, force, onProgress,
     const budgetLeft = storyBuildBudgetLeftUsd(row, await listStoryBuildRepoRows(ctx, accountId, buildId));
     if (budgetLeft < STORY_BUILD_MIN_BUDGET_LEFT_USD)
         return finish({ docsStatus: 'failed', docsError: BUILD_DOCS_TEXT.budget });
-    const [{ loadLibrarySnapshot }, { readIndex }, { libraryDir }, { shortlistDocsOf }] = await Promise.all([
+    const [{ loadLibrarySnapshot }, { readIndex }, { libraryDir }, { shortlistDocsOf }, { storyDocsCandidates }] = await Promise.all([
         import('../../reference-docs/context.js'),
         import('../../reference-docs/library.js'),
         import('../../reference-docs/paths.js'),
         import('../../review/story-docs/manager.js'),
+        import('../../review/story-docs/candidates.js'),
     ]);
     const [index, lib] = await Promise.all([readIndex(accountId, row.workspaceId), loadLibrarySnapshot(accountId, row.workspaceId)]);
     // 1. THE SHORTLIST — every section when the library fits, else the prefilter's candidates → Haiku.
@@ -163,7 +164,7 @@ export const runBuildDocs = async (ctx, { accountId, buildId, force, onProgress,
                 criteria: queryCriteria,
                 index,
                 docs,
-                candidates: prefilterSections({ story: storyText, criteria: queryCriteria }, docs),
+                candidates: await storyDocsCandidates({ accountId, workspaceId: row.workspaceId }, { story: storyText, criteria: queryCriteria }, docs),
             },
             lib,
             ...(seams.complete ? { complete: seams.complete } : {}),

package/dist/db/erase-account.js

@@ -189,9 +189,14 @@ export async function eraseAccountData(accountId) {
         // Wiki sources (migration 0140): the page rows (before their documents — composite FK) and the
         // sealed wiki credential. Both cascade too, and are explicit anyway.
         await tx.delete(schema.referenceDocWikiPages).where(eq(schema.referenceDocWikiPages.accountId, accountId)).execute();
+        // Full-text passages (migration 0152): derived from the files, before their documents (composite FK).
+        // The FTS5 index follows by trigger. They cascade too, and are explicit anyway.
+        await tx.delete(schema.referenceDocChunks).where(eq(schema.referenceDocChunks.accountId, accountId)).execute();
         await tx.delete(schema.workspaceWikiCredentials).where(eq(schema.workspaceWikiCredentials.accountId, accountId)).execute();
         // Figure descriptions (migration 0143): the account's image-description cache.
         await tx.delete(schema.referenceDocFigureDescriptions).where(eq(schema.referenceDocFigureDescriptions.accountId, accountId)).execute();
+        // Docs offers (migration 0155): cascade from workspaces and repos too, and are explicit anyway.
+        await tx.delete(schema.referenceDocRepoOffers).where(eq(schema.referenceDocRepoOffers.accountId, accountId)).execute();
         await tx.delete(schema.referenceDocs).where(eq(schema.referenceDocs.accountId, accountId)).execute();
         // Story docs checks (migration 0121 / pg 0108): cascade from workspaces too, and are explicit anyway.
         await tx.delete(schema.storyDocsAlignments).where(eq(schema.storyDocsAlignments.accountId, accountId)).execute();
@@ -375,6 +380,10 @@ export function accountScopedTables() {
         },
         // Wiki sources (migration 0140), erased explicitly above; `workspaceWikiCredentials` holds a credential.
         { name: 'referenceDocWikiPages', col: schema.referenceDocWikiPages.accountId, table: schema.referenceDocWikiPages },
+        // Full-text passages (migration 0152), erased explicitly above. Derived, so not exported.
+        { name: 'referenceDocChunks', col: schema.referenceDocChunks.accountId, table: schema.referenceDocChunks },
+        // Docs offers (migration 0155), erased explicitly above.
+        { name: 'referenceDocRepoOffers', col: schema.referenceDocRepoOffers.accountId, table: schema.referenceDocRepoOffers },
         // Figure descriptions (migration 0143), erased explicitly above.
         {
             name: 'referenceDocFigureDescriptions',

package/dist/db/export-account.js

@@ -53,6 +53,9 @@ export async function exportAccountData(accountId) {
         largePrCodeLocThreshold: accounts.largePrCodeLocThreshold,
         blastRadiusConfig: accounts.blastRadiusConfig,
         myTurnSettings: accounts.myTurnSettings,
+        featureSettings: accounts.featureSettings,
+        featuresExistingInstall: accounts.featuresExistingInstall,
+        reviewSuggestionDismissedAt: accounts.reviewSuggestionDismissedAt,
         aiBudgetSettings: accounts.aiBudgetSettings,
         aiBudgetReading: accounts.aiBudgetReading,
         lastLoginAt: accounts.lastLoginAt,
@@ -162,6 +165,22 @@ export async function exportAccountData(accountId) {
         .from(schema.referenceDocFigureDescriptions)
         .where(eq(schema.referenceDocFigureDescriptions.accountId, accountId))
         .execute();
+    const repoOfferRows = await db
+        .select({
+        workspaceId: schema.referenceDocRepoOffers.workspaceId,
+        repoId: schema.referenceDocRepoOffers.repoId,
+        path: schema.referenceDocRepoOffers.path,
+        docCount: schema.referenceDocRepoOffers.docCount,
+        wordEstimate: schema.referenceDocRepoOffers.wordEstimate,
+        tooLarge: schema.referenceDocRepoOffers.tooLarge,
+        state: schema.referenceDocRepoOffers.state,
+        docId: schema.referenceDocRepoOffers.docId,
+        detectedAt: schema.referenceDocRepoOffers.detectedAt,
+        decidedAt: schema.referenceDocRepoOffers.decidedAt,
+    })
+        .from(schema.referenceDocRepoOffers)
+        .where(eq(schema.referenceDocRepoOffers.accountId, accountId))
+        .execute();
     const docChatRows = await db
         .select({
         workspaceId: schema.referenceDocChatMessages.workspaceId,
@@ -386,6 +405,7 @@ export async function exportAccountData(accountId) {
         // ⚠ PRESENCE ONLY — never the stored token, in any form.
         workspaceWikiCredentials: wikiCredentialRows.map((t) => ({ ...t, hasToken: t.hasToken != null && t.hasToken !== '' })),
         referenceDocFigureDescriptions: figureRows,
+        referenceDocRepoOffers: repoOfferRows,
         repoRelations: repoRelationRows,
         sprintCodeJudgements: capped('sprintCodeJudgements', codeJudgementRows),
         referenceDocChatMessages: capped('referenceDocChatMessages', docChatRows),

package/dist/db/feature-gates.js

@@ -0,0 +1,80 @@
+import { and, eq, inArray, isNotNull } from 'drizzle-orm';
+import { db, schema } from './client.js';
+// SETTINGS → FEATURES — the facts behind the defaults (shared features.ts `resolveFeatures`). Read on
+// every GET /api/me, so each is ONE small indexed DB read: no tracker call, no GitHub call. Every
+// query predicates on accountId.
+/** At least one of the account's repositories has finished its 90-day backfill (docs/SYNC.md: a
+ *  repo stays "never fully synced" until phase 2 ends, so `last_full_sync_at` is that moment). */
+export async function hasCompletedBackfill(accountId) {
+    const { repos, syncState } = schema;
+    const rows = await db
+        .select({ id: repos.id })
+        .from(syncState)
+        .innerJoin(repos, eq(repos.id, syncState.repoId))
+        .where(and(eq(repos.accountId, accountId), isNotNull(syncState.lastFullSyncAt)))
+        .limit(1)
+        .execute();
+    return rows.length > 0;
+}
+/** Is this stored sprint-read source a real sprint (not the status fallback)? */
+export function isSprintSource(source) {
+    if (source == null)
+        return false;
+    switch (source.kind) {
+        case 'sprint':
+        case 'cycle':
+        case 'iteration':
+            return true;
+        case 'milestone':
+            // Only a milestone with a due date makes a sprint.
+            return source.dueOn != null;
+        case 'status_fallback':
+            return false;
+    }
+}
+/** The trackers whose configuration names sprints or cycles (GitHub Issues is the automatic default
+ *  in most workspaces, so its configuration alone says nothing). */
+const SPRINT_TRACKERS = ['jira', 'linear', 'notion'];
+/**
+ * Does any workspace of this account have a sprint source? True when:
+ *  - the workspace's last sprint read found a sprint, a cycle, a GitHub Projects iteration (the
+ *    current one, docs/TRACKERS.md § GitHub Projects iterations) or a milestone with a due date; or
+ *  - the workspace has no successful read yet and the tracker worker's SPRINT-SOURCE PROBE (GitHub
+ *    Issues workspaces only, tracker/sprint/probe.ts — never run by a view) found a current
+ *    iteration or a dated milestone; or
+ *  - the workspace has a Jira, Linear or Notion tracker configured and no read has said otherwise
+ *    yet (the read runs once This Sprint is opened; until then, a configured tracker counts).
+ *
+ * ⚠ THE EXTENSION POINT for a further source: add it to `isSprintSource`, and the Features default
+ * follows.
+ */
+export async function hasSprintSource(accountId) {
+    const sr = schema.sprintReads;
+    const reads = await db
+        .select({ workspaceId: sr.workspaceId, source: sr.sourceJson, readAt: sr.readAt, probe: sr.probeSourceJson })
+        .from(sr)
+        .where(eq(sr.accountId, accountId))
+        .execute();
+    if (reads.some((r) => isSprintSource(r.source)))
+        return true;
+    // The probe's answer counts only until a read exists: a read's own source is the answer then.
+    if (reads.some((r) => r.readAt == null && isSprintSource(r.probe)))
+        return true;
+    const readWorkspaces = new Set(reads.filter((r) => r.readAt != null && r.source != null).map((r) => r.workspaceId));
+    const wt = schema.workspaceTrackers;
+    const trackers = await db
+        .select({ workspaceId: wt.workspaceId })
+        .from(wt)
+        .where(and(eq(wt.accountId, accountId), inArray(wt.provider, [...SPRINT_TRACKERS])))
+        .execute();
+    return trackers.some((t) => !readWorkspaces.has(t.workspaceId));
+}
+/** Everything `resolveFeatures` needs, for one account. */
+export async function featureFacts(accountId, existingInstall) {
+    // An existing install shows everything whatever the facts say: skip the reads.
+    if (existingInstall)
+        return { existingInstall, reportsReady: true, sprintSource: true };
+    const [reportsReady, sprintSource] = await Promise.all([hasCompletedBackfill(accountId), hasSprintSource(accountId)]);
+    return { existingInstall, reportsReady, sprintSource };
+}
+//# sourceMappingURL=feature-gates.js.map

package/dist/db/migrations/0152_reference_doc_chunks.sql

@@ -0,0 +1,45 @@
+-- FULL-TEXT SEARCH OVER THE REFERENCE LIBRARY (2026-11-01; docs/DOCS-RAG.md, docs/REFERENCE-DOCS.md
+-- § Retrieval). CORE, local only. Additive.
+--
+--   reference_doc_chunks       NEW: a built document's section text cut into passages of ≤ 220 words,
+--                              each prefixed with "Document › trail › section" and the section's
+--                              one-line summary. Rewritten whole by every build (reference-docs/chunks.ts);
+--                              DERIVED from the files on disk, so a missing row is rebuilt at boot.
+--                              Composite FKs onto the document and the workspace; cascades.
+--   reference_doc_chunks_fts   NEW FTS5 index over the chunks' text (external content, porter + unicode61).
+--                              ⚠ Drizzle cannot declare a virtual table or a trigger: they live HERE only.
+--                              The three triggers keep it in step on every insert, update and delete —
+--                              including the FK cascades from a deleted document, workspace or account.
+CREATE TABLE `reference_doc_chunks` (
+	`id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+	`account_id` integer NOT NULL,
+	`workspace_id` integer NOT NULL,
+	`doc_id` integer NOT NULL,
+	`built_at` integer NOT NULL,
+	`section_path` text NOT NULL,
+	`anchor` text,
+	`ordinal` integer NOT NULL,
+	`text` text NOT NULL,
+	FOREIGN KEY (`account_id`) REFERENCES `accounts`(`id`) ON UPDATE no action ON DELETE cascade,
+	CONSTRAINT `reference_doc_chunks_doc_account_fk` FOREIGN KEY (`doc_id`,`account_id`) REFERENCES `reference_docs`(`id`,`account_id`) ON UPDATE no action ON DELETE cascade,
+	CONSTRAINT `reference_doc_chunks_workspace_account_fk` FOREIGN KEY (`workspace_id`,`account_id`) REFERENCES `workspaces`(`id`,`account_id`) ON UPDATE no action ON DELETE cascade
+);
+--> statement-breakpoint
+CREATE INDEX `reference_doc_chunks_scope` ON `reference_doc_chunks` (`account_id`,`workspace_id`,`doc_id`);
+--> statement-breakpoint
+CREATE INDEX `reference_doc_chunks_doc` ON `reference_doc_chunks` (`doc_id`,`account_id`);
+--> statement-breakpoint
+CREATE VIRTUAL TABLE `reference_doc_chunks_fts` USING fts5(`text`, content='reference_doc_chunks', content_rowid='id', tokenize='porter unicode61');
+--> statement-breakpoint
+CREATE TRIGGER `reference_doc_chunks_fts_ai` AFTER INSERT ON `reference_doc_chunks` BEGIN
+	INSERT INTO `reference_doc_chunks_fts`(rowid, `text`) VALUES (new.`id`, new.`text`);
+END;
+--> statement-breakpoint
+CREATE TRIGGER `reference_doc_chunks_fts_ad` AFTER DELETE ON `reference_doc_chunks` BEGIN
+	INSERT INTO `reference_doc_chunks_fts`(`reference_doc_chunks_fts`, rowid, `text`) VALUES ('delete', old.`id`, old.`text`);
+END;
+--> statement-breakpoint
+CREATE TRIGGER `reference_doc_chunks_fts_au` AFTER UPDATE ON `reference_doc_chunks` BEGIN
+	INSERT INTO `reference_doc_chunks_fts`(`reference_doc_chunks_fts`, rowid, `text`) VALUES ('delete', old.`id`, old.`text`);
+	INSERT INTO `reference_doc_chunks_fts`(rowid, `text`) VALUES (new.`id`, new.`text`);
+END;

package/dist/db/migrations/0153_feature_visibility.sql

@@ -0,0 +1,16 @@
+-- SETTINGS → FEATURES (2026-11-01; docs/FRONTEND.md § Features shown, shared features.ts). CORE,
+-- additive, visibility only.
+--
+--   accounts.feature_settings           NEW: the reader's switches, overrides only (JSON). NULL = every
+--                                       default applies. Written only by PUT /api/me/feature-settings.
+--   accounts.features_existing_install  NEW: 1 for an account that already had repositories when this
+--                                       migration ran — its defaults show every destination, so an
+--                                       existing install looks exactly as before. A new install
+--                                       (an account created later, or one with no repos yet) is 0 and
+--                                       starts with Bots Monitoring and Feed hidden.
+ALTER TABLE `accounts` ADD `feature_settings` text;
+--> statement-breakpoint
+ALTER TABLE `accounts` ADD `features_existing_install` integer DEFAULT 0 NOT NULL;
+--> statement-breakpoint
+UPDATE `accounts` SET `features_existing_install` = 1
+  WHERE EXISTS (SELECT 1 FROM `repos` WHERE `repos`.`account_id` = `accounts`.`id`);

package/dist/db/migrations/0154_first_landing.sql

@@ -0,0 +1,15 @@
+-- PENDING ON THE FIRST LANDING (2026-11-01; docs/BACKEND.md § My Turn — The first-onboarding
+-- lookback, docs/FRONTEND.md § Pending on the first landing). CORE, additive, no backfill.
+--
+--   repos.first_onboarding                   NEW: 1 for a repo added while the account had no repos,
+--                                            or in that same first-run batch. Its My Turn floor is
+--                                            its add time minus FIRST_ONBOARDING_LOOKBACK_DAYS; a
+--                                            repo added later keeps its add time. Written once, at
+--                                            insert (sync/upsert.ts upsertRepo), never updated.
+--   accounts.review_suggestion_dismissed_at  NEW: when the reader dismissed Pending's one-time
+--                                            "Review your PR with Claude" card. NULL = never.
+--
+-- Existing repos stay 0: an install that already has repos is past its first landing.
+ALTER TABLE `repos` ADD `first_onboarding` integer DEFAULT 0 NOT NULL;
+--> statement-breakpoint
+ALTER TABLE `accounts` ADD `review_suggestion_dismissed_at` integer;

package/dist/db/migrations/0155_repo_docs_offers.sql

@@ -0,0 +1,36 @@
+-- DOCS OFFERED FROM THE REPOSITORIES (2026-11-01; docs/REFERENCE-DOCS.md § Docs offered from your
+-- repositories). CORE, additive, no backfill.
+--
+--   reference_doc_repo_offers   NEW: one row per (workspace, repository, folder) found to look like a docs
+--                               collection. `state` = 'offered' (waiting for the reader), 'declined'
+--                               ("Not now": never offered again) or 'added' (a document was queued;
+--                               `doc_id` names it, kept after the document is removed so the folder is
+--                               not offered again). Nothing is built from a row until the reader presses
+--                               Add. Composite FKs onto the workspace and the repository; both cascade,
+--                               and repos' delete clears it explicitly too.
+--   repos.docs_offer_scanned_at NEW: when the repository's tree was last looked at for docs folders.
+--                               NULL = never; looked at again after DOCS_OFFER_RESCAN_DAYS.
+CREATE TABLE `reference_doc_repo_offers` (
+	`id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+	`account_id` integer NOT NULL,
+	`workspace_id` integer NOT NULL,
+	`repo_id` integer NOT NULL,
+	`path` text NOT NULL,
+	`doc_count` integer NOT NULL,
+	`word_estimate` integer NOT NULL,
+	`page_count` integer NOT NULL,
+	`too_large` integer DEFAULT 0 NOT NULL,
+	`state` text DEFAULT 'offered' NOT NULL,
+	`doc_id` integer,
+	`detected_at` integer NOT NULL,
+	`decided_at` integer,
+	FOREIGN KEY (`account_id`) REFERENCES `accounts`(`id`) ON UPDATE no action ON DELETE cascade,
+	CONSTRAINT `reference_doc_repo_offers_workspace_account_fk` FOREIGN KEY (`workspace_id`,`account_id`) REFERENCES `workspaces`(`id`,`account_id`) ON UPDATE no action ON DELETE cascade,
+	CONSTRAINT `reference_doc_repo_offers_repo_account_fk` FOREIGN KEY (`repo_id`,`account_id`) REFERENCES `repos`(`id`,`account_id`) ON UPDATE no action ON DELETE cascade
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX `reference_doc_repo_offers_folder` ON `reference_doc_repo_offers` (`account_id`,`workspace_id`,`repo_id`,`path`);
+--> statement-breakpoint
+CREATE INDEX `reference_doc_repo_offers_scope` ON `reference_doc_repo_offers` (`account_id`,`workspace_id`,`state`);
+--> statement-breakpoint
+ALTER TABLE `repos` ADD `docs_offer_scanned_at` integer;

package/dist/db/migrations/0156_ci_history_pending.sql

@@ -0,0 +1,9 @@
+-- THE CI-HISTORY "STILL OWED" STAMP (2026-11-02; docs/SYNC.md § The CI-history backfill is owed
+-- until it ran). CORE, additive, no backfill.
+--
+--   sync_state.ci_history_pending_at   NEW: set when a completed FULL walk owes the one-time
+--                                      CI-history backfill (before it is run or parked in the
+--                                      in-memory queue); cleared once the backfill ran. A
+--                                      non-NULL value at boot, or at the repo's next walk, runs
+--                                      it then. NULL = nothing owed.
+ALTER TABLE `sync_state` ADD `ci_history_pending_at` integer;

package/dist/db/migrations/0157_sprint_source_probe.sql

@@ -0,0 +1,17 @@
+-- THE SPRINT-SOURCE PROBE (2026-11-02; docs/TRACKERS.md § The sprint-source probe). CORE, additive, no
+-- backfill.
+--
+--   sprint_reads.probe_checked_at   NEW: when the tracker worker last asked GitHub whether this GitHub
+--                                   Issues workspace has a current Projects iteration or an open
+--                                   milestone with a due date. NULL = never. Asked again after
+--                                   SPRINT_PROBE_INTERVAL_MS, and never once a sprint read exists.
+--   sprint_reads.probe_source_json  NEW: what the probe found (a `SprintSource`, kind 'iteration' or
+--                                   'milestone'), NULL = nothing. Read ONLY by `hasSprintSource` (the
+--                                   This Sprint default in Settings → Features), and only while the
+--                                   workspace has no successful sprint read — a read's own source wins.
+--
+-- A probe may CREATE the workspace's row (`viewed_at` = epoch 0, `next_read_at` = epoch 0): the demand
+-- gate is unchanged — a row whose tab was never opened is never read.
+ALTER TABLE `sprint_reads` ADD `probe_checked_at` integer;
+--> statement-breakpoint
+ALTER TABLE `sprint_reads` ADD `probe_source_json` text;

package/dist/db/migrations/0158_repo_docs_unreadable.sql

@@ -0,0 +1,12 @@
+-- A REPOSITORY WHOSE FILES CAN'T BE READ (2026-11-02; docs/REFERENCE-DOCS.md § A repository whose files
+-- can't be read). CORE, additive, no backfill.
+--
+--   repos.docs_offer_failed_at   NEW: when the docs-offer look at the repository's tree last FAILED. NULL =
+--                                the last look succeeded (or none failed). While set, the repository is not
+--                                looked at again until DOCS_OFFER_FAILURE_RETRY_HOURS have passed (then at
+--                                most once a day). Cleared by the next look that succeeds.
+--   repos.docs_offer_failure     NEW: why, as a code: 'no_access' | 'empty' | 'not_found' | 'unavailable'.
+--                                Set and cleared with `docs_offer_failed_at`. Never touches the PR sync.
+ALTER TABLE `repos` ADD `docs_offer_failed_at` integer;
+--> statement-breakpoint
+ALTER TABLE `repos` ADD `docs_offer_failure` text;

package/dist/db/migrations/meta/_journal.json

@@ -1065,6 +1065,55 @@
       "when": 1792224054016,
       "tag": "0151_limn_finding_bots",
       "breakpoints": true
+    },
+    {
+      "idx": 152,
+      "version": "6",
+      "when": 1792224055016,
+      "tag": "0152_reference_doc_chunks",
+      "breakpoints": true
+    },
+    {
+      "idx": 153,
+      "version": "6",
+      "when": 1792224056016,
+      "tag": "0153_feature_visibility",
+      "breakpoints": true
+    },
+    {
+      "idx": 154,
+      "version": "6",
+      "when": 1792224057016,
+      "tag": "0154_first_landing",
+      "breakpoints": true
+    },
+    {
+      "idx": 155,
+      "version": "6",
+      "when": 1792224058016,
+      "tag": "0155_repo_docs_offers",
+      "breakpoints": true
+    },
+    {
+      "idx": 156,
+      "version": "6",
+      "when": 1792224059016,
+      "tag": "0156_ci_history_pending",
+      "breakpoints": true
+    },
+    {
+      "idx": 157,
+      "version": "6",
+      "when": 1792224060016,
+      "tag": "0157_sprint_source_probe",
+      "breakpoints": true
+    },
+    {
+      "idx": 158,
+      "version": "6",
+      "when": 1792224061016,
+      "tag": "0158_repo_docs_unreadable",
+      "breakpoints": true
     }
   ]
 }

package/dist/db/my-turn-floor.js

@@ -0,0 +1,18 @@
+// ── MY TURN'S ONBOARDING FLOOR (docs/BACKEND.md § My Turn — The first-onboarding lookback) ──────
+//
+// An event before a repo's floor never summons anyone: without it, adding a repo and its 90-day
+// backfill would surface two months of old replies, mentions and pushes at once. The floor is the
+// repo's add time (`repos.createdAt`) — except for a repo of the account's FIRST onboarding
+// (`repos.first_onboarding`), whose floor sits `FIRST_ONBOARDING_LOOKBACK_DAYS` earlier, so the
+// first landing on Pending shows the last week's open business instead of nothing.
+//
+// ⚠ ONE spelling: `getMyTurn` builds its per-repo floor map through this and every rule that reads
+// the floor (S2, S3c, S3d, S5, S6) reads that map. Never re-derive it from `createdAt` elsewhere.
+import { FIRST_ONBOARDING_LOOKBACK_DAYS } from '../shared/index.js';
+const DAY_MS = 86_400_000;
+export function myTurnFloorOf(repo) {
+    if (!repo.firstOnboarding)
+        return repo.createdAt;
+    return new Date(repo.createdAt.getTime() - FIRST_ONBOARDING_LOOKBACK_DAYS * DAY_MS);
+}
+//# sourceMappingURL=my-turn-floor.js.map