Purity / rebuild guarantee test (#30)

The cache is a rebuildable index over gitea, never a source of truth (D4).
Two tests lock that invariant where the durable cache actually lives:

- packages/core: cache-purity-v0.test.ts — file-backed node:sqlite. Build the
  SQLite mirror from a gitea snapshot, capture every re-derived field, delete the
  .sqlite file, rebuild from the same snapshot, assert byte-identical. Plus a
  structural D4 guard: every issues-table column must map to a gitea field, so a
  future user-authored column can't silently break rebuild-ability.

- apps/desktop: snapshot-store.test.ts — the shipped durable cache is the JSON
  snapshot-store. Delete the file → loadSnapshot returns null (degrades to
  no-cache, never throws), which is what forces the next getSnapshot to reconcile
  fresh from gitea. Corrupt/partial files are likewise treated as no-cache.
  Stands up vitest for the desktop main process (first unit tests there);
  electron is mocked, snapshot path is injected.

No native better-sqlite3 shipped: the SQLite mirror has no consumer on any hot
path yet, so wiring it into main (native module + asarUnpack + dmg re-verify)
would add packaging risk for no runtime benefit. The purity invariant is proven
at the seam for both caches; the native driver migration is deferred until
SQLite becomes load-bearing.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

apps/desktop/package.json

@@ -11,6 +11,7 @@
     "build": "electron-vite build",
     "start": "electron-vite preview",
     "typecheck": "tsc --noEmit",
+    "test": "vitest run",
     "e2e": "electron-vite build && playwright test",
     "e2e:only": "playwright test",
     "e2e:report": "playwright show-report e2e/.artifacts/report",

apps/desktop/src/main/snapshot-store.test.ts

@@ -0,0 +1,86 @@
+/**
+ * Purity / rebuild guarantee for the *shipped* durable cache (#30, D4). The app's
+ * on-disk reconcile cache is this JSON snapshot-store. The invariant: delete it
+ * and lose nothing — the durable truth is in gitea, the file is only a boot/offline
+ * mirror. This test deletes the real file and asserts the store degrades to
+ * "no cache" (null), which is what forces the next `getSnapshot` to reconcile
+ * fresh from gitea rather than serve stale or missing data.
+ */
+import { existsSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+// electron can't be imported outside the Electron runtime; the store only needs
+// app.getPath for its default path, which every test overrides with an injected path.
+vi.mock('electron', () => ({ app: { getPath: () => tmpdir() } }))
+
+import { loadSnapshot, type PersistedSnapshot, saveSnapshot } from './snapshot-store.js'
+
+const SNAP: Omit<PersistedSnapshot, 'savedAt'> = {
+  issues: [{ number: 1, title: 'An issue', state: 'open', labels: ['est/5d', 'p/1'] }],
+  milestones: [{ id: 7, title: 'P2' }],
+  deps: [{ issue: 1, dependsOn: 2 }],
+  timelines: { 1: [{ type: 'opened', at: '2026-07-01T00:00:00Z' }] },
+}
+
+describe('snapshot-store purity (#30)', () => {
+  let dir: string | null = null
+  const path = () => {
+    if (!dir) dir = mkdtempSync(join(tmpdir(), 'commitea-snap-'))
+    return join(dir, 'commitea-snapshot.json')
+  }
+  afterEach(() => {
+    if (dir) rmSync(dir, { recursive: true, force: true })
+    dir = null
+  })
+
+  it('round-trips a saved snapshot', () => {
+    const p = path()
+    saveSnapshot(SNAP, '2026-07-09T00:00:00Z', p)
+    const back = loadSnapshot(p)
+    expect(back).toEqual({ ...SNAP, savedAt: '2026-07-09T00:00:00Z' })
+  })
+
+  it('delete the cache file → load returns null (degrades to no-cache, not a crash)', () => {
+    const p = path()
+    saveSnapshot(SNAP, '2026-07-09T00:00:00Z', p)
+    expect(loadSnapshot(p)).not.toBeNull()
+
+    rmSync(p) // delete the durable cache
+    expect(existsSync(p)).toBe(false)
+
+    // The store must NOT throw and must report "no cache" so the next reconcile
+    // rebuilds from gitea. If this ever returned stale data or threw, D4 breaks.
+    expect(loadSnapshot(p)).toBeNull()
+  })
+
+  it('a corrupt / partial file is treated as no-cache, never a crash', () => {
+    const p = path()
+    writeFileSync(p, '{ this is not json', 'utf8')
+    expect(loadSnapshot(p)).toBeNull()
+    // valid JSON but wrong shape (no issues array) is also rejected
+    writeFileSync(p, JSON.stringify({ savedAt: 'x' }), 'utf8')
+    expect(loadSnapshot(p)).toBeNull()
+  })
+
+  it('re-saving after a delete restores the cache — the rebuild is lossless', () => {
+    const p = path()
+    saveSnapshot(SNAP, '2026-07-09T00:00:00Z', p)
+    const before = loadSnapshot(p)
+
+    rmSync(p)
+    expect(loadSnapshot(p)).toBeNull()
+
+    // a resync would call saveSnapshot again with the freshly reconciled data
+    saveSnapshot(SNAP, '2026-07-09T01:00:00Z', p)
+    const after = loadSnapshot(p)
+
+    // same durable payload, only the savedAt marker differs
+    expect(after!.issues).toEqual(before!.issues)
+    expect(after!.milestones).toEqual(before!.milestones)
+    expect(after!.deps).toEqual(before!.deps)
+    expect(after!.timelines).toEqual(before!.timelines)
+  })
+})

apps/desktop/src/main/snapshot-store.ts

@@ -26,10 +26,15 @@ function snapshotPath(): string {
   return join(app.getPath('userData'), 'commitea-snapshot.json')
 }
 
-/** Load the last persisted snapshot, or null if absent/corrupt. Never throws. */
+/**
-export function loadSnapshot(): PersistedSnapshot | null {
+ * Load the last persisted snapshot, or null if absent/corrupt. Never throws — a
+ * deleted or unreadable cache degrades to "no cache" (the purity guarantee, D4:
+ * the next reconcile rebuilds it from gitea). `path` is injectable for tests;
+ * production always uses the userData file.
+ */
+export function loadSnapshot(path: string = snapshotPath()): PersistedSnapshot | null {
   try {
-    const parsed = JSON.parse(readFileSync(snapshotPath(), 'utf8')) as PersistedSnapshot
+    const parsed = JSON.parse(readFileSync(path, 'utf8')) as PersistedSnapshot
     if (parsed && Array.isArray(parsed.issues)) return parsed
     return null
   } catch {
@@ -38,9 +43,9 @@ export function loadSnapshot(): PersistedSnapshot | null {
 }
 
 /** Persist a freshly reconciled snapshot. Best-effort — a write failure never breaks a reconcile. */
-export function saveSnapshot(snap: Omit<PersistedSnapshot, 'savedAt'>, savedAt: string): void {
+export function saveSnapshot(snap: Omit<PersistedSnapshot, 'savedAt'>, savedAt: string, path: string = snapshotPath()): void {
   try {
-    writeFileSync(snapshotPath(), JSON.stringify({ ...snap, savedAt }), 'utf8')
+    writeFileSync(path, JSON.stringify({ ...snap, savedAt }), 'utf8')
   } catch {
     // disk full / permissions — the in-memory cache still works this session
   }

apps/desktop/vitest.config.ts

@@ -0,0 +1,14 @@
+import { defineConfig } from 'vitest/config'
+
+/**
+ * Unit tests for the Electron main process. Node environment only — renderer
+ * (React) is covered by the Playwright e2e suite, not here. `electron` is a
+ * native module that can't be imported outside the Electron runtime, so tests
+ * that touch it mock it (see snapshot-store.test.ts).
+ */
+export default defineConfig({
+  test: {
+    environment: 'node',
+    include: ['src/main/**/*.test.ts'],
+  },
+})

packages/core/src/agent/agent-tools.ts

@@ -17,10 +17,11 @@ export const QUERY_PROJECT_TOOL: ToolDecl = {
     properties: {
       view: {
         type: 'string',
-        enum: ['focus', 'board', 'calibration', 'issue', 'search'],
+        enum: ['focus', 'board', 'calibration', 'issue', 'search', 'standup'],
         description:
           'focus = Now/Next/Later; board = issues by lifecycle column; calibration = estimate-vs-actual; ' +
-          'issue = one issue (needs filters.issueId); search = issues matching filters.query.',
+          'issue = one issue (needs filters.issueId); search = issues matching filters.query; ' +
+          "standup = today's plan + overnight drift + the stalest blocker.",
       },
       filters: {
         type: 'object',

packages/core/src/agent/agent.test.ts

@@ -276,6 +276,7 @@ describe('buildProjectView', () => {
   })
 
   it('unbuilt views return a notImplemented marker, not fabricated data', () => {
-    expect(buildProjectView('standup', undefined, snap, asOf)).toEqual({ notImplemented: 'standup' })
+    expect(buildProjectView('milestone', undefined, snap, asOf)).toEqual({ notImplemented: 'milestone' })
+    expect(buildProjectView('runway', undefined, snap, asOf)).toEqual({ notImplemented: 'runway' })
   })
 })

packages/core/src/agent/query-project.test.ts

@@ -0,0 +1,74 @@
+import { describe, expect, it } from 'vitest'
+
+import { extractLabelFacts } from '../labels/label-schema.js'
+import type { LifecycleEvent } from '../lifecycle/lifecycle-v0.js'
+import type { GiteaIssue } from '../gitea/types.js'
+import { buildProjectView, type ProjectSnapshot } from './query-project.js'
+
+const asOf = new Date('2026-02-12T00:00:00Z')
+
+function issue(over: Partial<GiteaIssue>): GiteaIssue {
+  const labels = over.labels ?? ['est/2d']
+  return {
+    number: 1,
+    title: '#1',
+    body: '',
+    state: 'open',
+    labels,
+    facts: extractLabelFacts(labels),
+    milestone: null,
+    assignee: null,
+    assignees: [],
+    createdAt: '2026-02-02T09:00:00Z',
+    updatedAt: '2026-02-02T09:00:00Z',
+    closedAt: null,
+    url: '',
+    ...over,
+  }
+}
+
+describe('buildProjectView: standup (#28)', () => {
+  it('surfaces schedule drift + a stale blocker, with a per-person plan', () => {
+    // #7 started work 6 working days ago (steeping) and blocks #8; est is 2d → past estimate.
+    const steeping = issue({ number: 7, labels: ['est/2d', 'p/1'], assignee: 'christian' })
+    const blocked = issue({ number: 8, labels: ['est/3d', 'p/2'], assignee: 'stephen' })
+    const timelines: Record<number, LifecycleEvent[]> = {
+      7: [{ type: 'commit', at: '2026-02-04T09:00:00Z' }],
+    }
+    const snap: ProjectSnapshot = { issues: [steeping, blocked], timelines, deps: [{ issue: 8, dependsOn: 7 }] }
+
+    const v = buildProjectView('standup', undefined, snap, asOf) as {
+      plan: { who: string; issue: number; why: string }[]
+      drift: { issue: number; note: string }[]
+      nag: { issue: number; steepingDays: number; blocks: number[] } | null
+    }
+
+    // a stale blocker is nagged, and it's the steeping one that blocks another
+    expect(v.nag).not.toBeNull()
+    expect(v.nag!.issue).toBe(7)
+    expect(v.nag!.steepingDays).toBeGreaterThan(0)
+    expect(v.nag!.blocks).toContain(8)
+
+    // drift caught the past-estimate steep
+    expect(v.drift.some((d) => d.issue === 7)).toBe(true)
+
+    // plan gives an earliest pick per person (both assignees represented)
+    expect(v.plan.map((p) => p.who)).toEqual(expect.arrayContaining(['christian', 'stephen']))
+    // #7 leads its person's plan on the critical path
+    expect(v.plan.find((p) => p.issue === 7)?.why).toContain('critical')
+  })
+
+  it('is calm when nothing is steeping (no nag, empty drift)', () => {
+    const snap: ProjectSnapshot = {
+      issues: [issue({ number: 1, labels: ['est/2d'] })],
+      timelines: {},
+      deps: [],
+    }
+    const v = buildProjectView('standup', undefined, snap, asOf) as {
+      drift: unknown[]
+      nag: unknown | null
+    }
+    expect(v.nag).toBeNull()
+    expect(v.drift).toEqual([])
+  })
+})

packages/core/src/agent/query-project.ts

@@ -4,9 +4,9 @@
  * deterministic code (scheduler, lifecycle inference, calibration); the model
  * only requests a shape and narrates it — it never computes (decisions.md).
  *
- * v0 serves focus / board / calibration / issue. The remaining views
+ * Serves focus / board / calibration / issue / search / standup. The remaining
- * (milestone / runway / standup / search) return a `notImplemented` marker so
+ * views (milestone / runway) return a `notImplemented` marker so the model
- * the model degrades honestly instead of inventing data.
+ * degrades honestly instead of inventing data.
  */
 
 import { fitCalibration, calibrationSamples } from '../calibration/calibration-v0.js'
@@ -121,6 +121,62 @@ function searchView(snap: ProjectSnapshot, filters: QueryFilters) {
   }
 }
 
+/**
+ * Standup — the morning ritual as a compact, model-narratable payload: today's
+ * plan (the scheduler's earliest pick per person), overnight drift (real
+ * anomalies — issues sitting in review or steeping past their estimate), and the
+ * single stalest blocker to nag about. All from deterministic code; the model
+ * narrates it. Satisfies #28's "surfaces schedule drift + at least one stale blocker".
+ */
+function standupView(snap: ProjectSnapshot, asOf: Date) {
+  const plan = schedule(toSchedulable(snap.issues), snap.deps)
+  const open = snap.issues.filter((i) => i.state === 'open')
+  const infOf = (i: GiteaIssue) => inferLifecycle(i, snap.timelines[i.number] ?? [], asOf)
+
+  // plan: the earliest scheduled pick per assignee (dependency + priority order)
+  const seen = new Set<string>()
+  const planPicks: { who: string; issue: number; title: string; why: string }[] = []
+  for (const item of plan.items) {
+    const who = open.find((i) => i.number === item.number)?.assignee ?? 'unassigned'
+    if (seen.has(who)) continue
+    seen.add(who)
+    planPicks.push({
+      who,
+      issue: item.number,
+      title: item.title,
+      why: item.critical
+        ? 'on the critical path'
+        : item.blocks.length
+          ? `blocks ${item.blocks.map((b) => `#${b}`).join(', ')}`
+          : 'next by dependency + priority',
+    })
+  }
+
+  // drift: real overnight anomalies (review-sitting, steeping past estimate)
+  const drift: { issue: number; note: string }[] = []
+  for (const i of open) {
+    const inf = infOf(i)
+    if (inf.column === 'review') drift.push({ issue: i.number, note: `#${i.number} is sitting in review` })
+    else if (inf.steepingDays != null && inf.steepingDays > (i.facts.estimateDays ?? 2))
+      drift.push({
+        issue: i.number,
+        note: `#${i.number} has steeped ${inf.steepingDays}d past its ${i.facts.estimateDays ?? 2}d estimate`,
+      })
+  }
+
+  // nag: the single longest-steeping open issue + what it blocks
+  let nag: { issue: number; steepingDays: number; blocks: number[] } | null = null
+  for (const i of open) {
+    const inf = infOf(i)
+    if (inf.steepingDays == null) continue
+    if (!nag || inf.steepingDays > nag.steepingDays) {
+      nag = { issue: i.number, steepingDays: inf.steepingDays, blocks: plan.items.find((it) => it.number === i.number)?.blocks ?? [] }
+    }
+  }
+
+  return { date: asOf.toISOString().slice(0, 10), plan: planPicks.slice(0, 5), drift: drift.slice(0, 5), nag }
+}
+
 /** Build the compact payload for one view. Unknown/unbuilt views return a marker. */
 export function buildProjectView(
   view: ProjectView,
@@ -140,6 +196,8 @@ export function buildProjectView(
       return issueView(snap, f, asOf)
     case 'search':
       return searchView(snap, f)
+    case 'standup':
+      return standupView(snap, asOf)
     default:
       return { notImplemented: view }
   }

packages/core/src/cache/cache-purity-v0.test.ts

@@ -0,0 +1,191 @@
+/**
+ * Purity / rebuild guarantee (#30, D4). The SQLite cache is a *rebuildable index*
+ * over the durable truth in gitea — never a source of truth. This test enforces
+ * that invariant the only way that matters: nuke the database file on disk and
+ * rebuild it from the same gitea snapshot, then assert nothing was lost.
+ *
+ * If a future change ever stores a fact that lives only in the cache (a
+ * user-authored note, a locally-computed field that isn't re-derived from the
+ * label set), the delete→resync round-trip would drop it and this test fails.
+ * That is the whole point: the cache must survive being deleted.
+ *
+ * Uses a real on-disk SQLite file via node:sqlite (present in the test runtime;
+ * main binds better-sqlite3 to the same CacheDriver seam), so "delete the SQLite
+ * file" is literal `rm`, not a metaphor.
+ */
+import { DatabaseSync } from 'node:sqlite'
+import { mkdtempSync, existsSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import { afterEach, describe, expect, it } from 'vitest'
+
+import type { GiteaIssue } from '../gitea/types.js'
+import { extractLabelFacts } from '../labels/label-schema.js'
+import { type CacheDriver, initCache, readIssue, upsertIssue } from './cache-v0.js'
+
+/** Adapt a file-backed node:sqlite handle to the CacheDriver seam, returning the path too. */
+function fileDriver(path: string): { driver: CacheDriver; close: () => void } {
+  const db = new DatabaseSync(path)
+  const driver: CacheDriver = {
+    exec: (sql) => db.exec(sql),
+    run: (sql, params = []) => {
+      db.prepare(sql).run(...(params as never[]))
+    },
+    get: (sql, params = []) => db.prepare(sql).get(...(params as never[])) as Record<string, unknown> | undefined,
+    all: (sql, params = []) => db.prepare(sql).all(...(params as never[])) as Record<string, unknown>[],
+  }
+  return { driver, close: () => db.close() }
+}
+
+function issue(over: Partial<GiteaIssue> = {}): GiteaIssue {
+  const labels = over.labels ?? ['est/5d', 'p/1']
+  return {
+    number: 1,
+    title: 'An issue',
+    body: 'body',
+    state: 'open',
+    labels,
+    facts: extractLabelFacts(labels),
+    milestone: null,
+    assignee: 'christian',
+    assignees: ['christian'],
+    createdAt: '2026-07-01T00:00:00Z',
+    updatedAt: '2026-07-02T00:00:00Z',
+    closedAt: null,
+    url: 'https://gitea/christian/commitea/issues/1',
+    ...over,
+  }
+}
+
+/** A representative reconciled backlog: open + closed, milestones, reassignment, no-milestone, empty labels. */
+const GITEA_TRUTH: GiteaIssue[] = [
+  issue({
+    number: 42,
+    title: 'Monte Carlo engine',
+    labels: ['est/8d', 'p/1', 'deadline/hard'],
+    milestone: { id: 7, title: 'P2 — Scheduler', dueOn: '2026-09-01T00:00:00Z' },
+    assignee: 'christian',
+    assignees: ['christian'],
+  }),
+  issue({
+    number: 43,
+    title: 'Calibration honesty',
+    labels: ['est/3d', 'p/2'],
+    state: 'closed',
+    closedAt: '2026-07-05T00:00:00Z',
+    milestone: { id: 7, title: 'P2 — Scheduler', dueOn: '2026-09-01T00:00:00Z' },
+    assignee: 'stephen',
+    assignees: ['stephen'],
+  }),
+  issue({ number: 44, title: 'No milestone, no labels', labels: [], milestone: null, assignee: null, assignees: [] }),
+]
+
+/** Rebuild a cache from scratch out of the gitea snapshot — exactly what a resync does. */
+function rebuildFrom(driver: CacheDriver, truth: GiteaIssue[]): void {
+  initCache(driver)
+  for (const i of truth) upsertIssue(driver, i)
+}
+
+/** The complete durable state we can read back — every issue, fully re-derived. */
+function readAll(driver: CacheDriver, truth: GiteaIssue[]): (GiteaIssue | null)[] {
+  return truth.map((i) => readIssue(driver, i.number))
+}
+
+describe('cache purity / rebuild (#30)', () => {
+  let dir: string | null = null
+  afterEach(() => {
+    if (dir) rmSync(dir, { recursive: true, force: true })
+    dir = null
+  })
+
+  it('delete the SQLite file → resync → no durable truth is lost', () => {
+    dir = mkdtempSync(join(tmpdir(), 'commitea-cache-'))
+    const dbPath = join(dir, 'cache.sqlite')
+
+    // 1. Build the cache from gitea and capture everything we can read back.
+    const first = fileDriver(dbPath)
+    rebuildFrom(first.driver, GITEA_TRUTH)
+    const before = readAll(first.driver, GITEA_TRUTH)
+    first.close()
+    expect(existsSync(dbPath)).toBe(true)
+    // sanity: the snapshot actually holds derived facts, not just rows
+    expect(before[0]!.facts).toEqual(extractLabelFacts(['est/8d', 'p/1', 'deadline/hard']))
+    expect(before[0]!.facts.estimateDays).toBe(8)
+
+    // 2. Delete the SQLite file. This is the durable cache, gone.
+    rmSync(dbPath)
+    // node:sqlite also drops a -journal/-wal sidecar in some modes; clear the dir of any residue.
+    expect(existsSync(dbPath)).toBe(false)
+
+    // 3. Resync: a brand-new empty DB rebuilt from the *same* gitea snapshot.
+    const second = fileDriver(dbPath)
+    rebuildFrom(second.driver, GITEA_TRUTH)
+    const after = readAll(second.driver, GITEA_TRUTH)
+    second.close()
+
+    // 4. Nothing was lost — the rebuilt cache is identical, field for field.
+    expect(after).toEqual(before)
+  })
+
+  it('a re-reconcile that changes gitea updates in place — the rebuild reflects truth, never stale rows', () => {
+    dir = mkdtempSync(join(tmpdir(), 'commitea-cache-'))
+    const dbPath = join(dir, 'cache.sqlite')
+
+    const first = fileDriver(dbPath)
+    rebuildFrom(first.driver, GITEA_TRUTH)
+    first.close()
+
+    // gitea moved on: #42 re-estimated + reassigned, #43 reopened.
+    const NEW_TRUTH: GiteaIssue[] = [
+      issue({ ...GITEA_TRUTH[0], labels: ['est/2d', 'p/3'], assignee: 'stephen', assignees: ['stephen'] }),
+      issue({ ...GITEA_TRUTH[1], state: 'open', closedAt: null }),
+      GITEA_TRUTH[2],
+    ]
+
+    // resync over the existing file (upsert-by-number), not a fresh DB
+    const second = fileDriver(dbPath)
+    initCache(second.driver)
+    for (const i of NEW_TRUTH) upsertIssue(second.driver, i)
+    const rowCount = second.driver.all('SELECT number FROM issues')
+    const back42 = readIssue(second.driver, 42)!
+    const back43 = readIssue(second.driver, 43)!
+    second.close()
+
+    expect(rowCount).toHaveLength(3) // upsert in place — no duplicate rows accreted across reconciles
+    expect(back42.facts).toEqual(extractLabelFacts(['est/2d', 'p/3']))
+    expect(back42.facts.estimateDays).toBe(2)
+    expect(back42.assignee).toBe('stephen')
+    expect(back43.state).toBe('open')
+    expect(back43.closedAt).toBeNull()
+  })
+
+  it('the cache stores no column that is not re-derivable from gitea (structural D4 guard)', () => {
+    dir = mkdtempSync(join(tmpdir(), 'commitea-cache-'))
+    const dbPath = join(dir, 'cache.sqlite')
+    const { driver, close } = fileDriver(dbPath)
+    initCache(driver)
+
+    // Every issues-table column must map to a field carried on the gitea issue
+    // (or be a re-derivable mirror of one). If someone adds a user-authored
+    // column, it won't be in this allow-list and this guard fails — forcing a
+    // deliberate decision about durability instead of silently breaking D4.
+    const cols = driver.all('PRAGMA table_info(issues)').map((r) => r.name as string)
+    const FROM_GITEA = new Set([
+      'number',
+      'title',
+      'body',
+      'state',
+      'labels', // facts are re-derived from this on read, never stored
+      'milestone_id',
+      'assignee',
+      'assignees',
+      'created_at',
+      'updated_at',
+      'closed_at',
+      'url',
+    ])
+    close()
+    expect(cols.filter((c) => !FROM_GITEA.has(c))).toEqual([])
+  })
+})

packages/core/src/cache/cache-v0.test.ts

@@ -0,0 +1,92 @@
+import { DatabaseSync } from 'node:sqlite'
+
+import { describe, expect, it } from 'vitest'
+
+import type { GiteaIssue } from '../gitea/types.js'
+import { extractLabelFacts } from '../labels/label-schema.js'
+import { type CacheDriver, initCache, readIssue, upsertIssue } from './cache-v0.js'
+
+/** Adapt node:sqlite's DatabaseSync to the CacheDriver seam (main uses better-sqlite3). */
+function memoryDriver(): CacheDriver {
+  const db = new DatabaseSync(':memory:')
+  return {
+    exec: (sql) => db.exec(sql),
+    run: (sql, params = []) => {
+      db.prepare(sql).run(...(params as never[]))
+    },
+    get: (sql, params = []) => db.prepare(sql).get(...(params as never[])) as Record<string, unknown> | undefined,
+    all: (sql, params = []) => db.prepare(sql).all(...(params as never[])) as Record<string, unknown>[],
+  }
+}
+
+function issue(over: Partial<GiteaIssue> = {}): GiteaIssue {
+  const labels = over.labels ?? ['est/5d', 'p/1', 'deadline/hard']
+  return {
+    number: 42,
+    title: 'Monte Carlo engine',
+    body: 'percentile bands',
+    state: 'open',
+    labels,
+    facts: extractLabelFacts(labels),
+    milestone: { id: 7, title: 'P2 — Scheduler', dueOn: '2026-09-01T00:00:00Z' },
+    assignee: 'christian',
+    assignees: ['christian'],
+    createdAt: '2026-07-08T00:00:00Z',
+    updatedAt: '2026-07-08T01:00:00Z',
+    closedAt: null,
+    url: 'https://gitea/christian/commitea/issues/42',
+    ...over,
+  }
+}
+
+describe('cache-v0', () => {
+  it('mirrors one issue and reads its facts back through extractLabelFacts (acceptance)', () => {
+    const d = memoryDriver()
+    initCache(d)
+    upsertIssue(d, issue({ labels: ['est/5d', 'p/1', 'deadline/hard'] }))
+
+    const back = readIssue(d, 42)!
+    expect(back.labels).toEqual(['est/5d', 'p/1', 'deadline/hard'])
+    // facts are re-derived on read, not stored
+    expect(back.facts.estimateDays).toBe(5)
+    expect(back.facts.priority).toBe(1)
+    expect(back.facts.hardDeadline).toBe(true)
+    // the rest of the domain shape round-trips
+    expect(back.milestone).toEqual({ id: 7, title: 'P2 — Scheduler', dueOn: '2026-09-01T00:00:00Z' })
+    expect(back.assignee).toBe('christian')
+    expect(back.state).toBe('open')
+  })
+
+  it('re-derives facts from the current labels after a re-reconcile (upsert in place, no dup)', () => {
+    const d = memoryDriver()
+    initCache(d)
+    upsertIssue(d, issue({ labels: ['est/2d', 'p/3'] }))
+    // reconcile again with changed labels + closed
+    upsertIssue(d, issue({ labels: ['est/8d', 'p/1'], state: 'closed', closedAt: '2026-07-09T00:00:00Z' }))
+
+    expect(d.all('SELECT number FROM issues')).toHaveLength(1) // upsert by number, not a second row
+    const back = readIssue(d, 42)!
+    expect(back.facts.estimateDays).toBe(8)
+    expect(back.facts.priority).toBe(1)
+    expect(back.facts.hardDeadline).toBe(false) // deadline/hard dropped
+    expect(back.state).toBe('closed')
+    expect(back.closedAt).toBe('2026-07-09T00:00:00Z')
+  })
+
+  it('reads an issue with no milestone / empty labels', () => {
+    const d = memoryDriver()
+    initCache(d)
+    upsertIssue(d, issue({ number: 9, labels: [], milestone: null, assignee: null, assignees: [] }))
+    const back = readIssue(d, 9)!
+    expect(back.milestone).toBeNull()
+    expect(back.labels).toEqual([])
+    expect(back.facts.estimateDays).toBeNull()
+    expect(back.assignee).toBeNull()
+  })
+
+  it('returns null for an uncached issue', () => {
+    const d = memoryDriver()
+    initCache(d)
+    expect(readIssue(d, 999)).toBeNull()
+  })
+})

packages/core/src/cache/cache-v0.ts

@@ -0,0 +1,159 @@
+/**
+ * SQLite cache, v0 (#3) — a rebuildable local mirror of the reconciled backlog.
+ * It is an index over the durable truth in gitea, never the source of truth (D4):
+ * delete it, resync, lose nothing. This module owns the schema + the pure
+ * row<->domain mappers; the actual SQLite handle is injected as a `CacheDriver`,
+ * so core stays free of any native driver (better-sqlite3 lives in main; tests
+ * use node:sqlite). Facts are never stored — they are re-derived from the label
+ * set on read via `extractLabelFacts`, so the mirror can't drift from the label
+ * semantics.
+ */
+
+import type { GiteaIssue, GiteaMilestoneRef } from '../gitea/types.js'
+import { extractLabelFacts } from '../labels/label-schema.js'
+
+/**
+ * The injected IO boundary: a thin synchronous SQL executor. Core writes the SQL;
+ * the host binds a real driver (better-sqlite3 in the desktop main process,
+ * node:sqlite in tests). Kept minimal on purpose — no ORM, no query builder.
+ */
+export interface CacheDriver {
+  /** Run one or more DDL/utility statements (no params, no result). */
+  exec(sql: string): void
+  /** Execute a single parameterized write. */
+  run(sql: string, params?: readonly unknown[]): void
+  /** First row of a parameterized query, or undefined. */
+  get(sql: string, params?: readonly unknown[]): Record<string, unknown> | undefined
+  /** All rows of a parameterized query. */
+  all(sql: string, params?: readonly unknown[]): Record<string, unknown>[]
+}
+
+/** The cache schema — five tables mirroring gitea's shape. Regenerable; drop and rebuild freely. */
+export const CACHE_SCHEMA = `
+CREATE TABLE IF NOT EXISTS milestones (
+  id       INTEGER PRIMARY KEY,
+  title    TEXT NOT NULL,
+  state    TEXT,
+  due_on   TEXT
+);
+CREATE TABLE IF NOT EXISTS issues (
+  number       INTEGER PRIMARY KEY,
+  title        TEXT NOT NULL,
+  body         TEXT NOT NULL DEFAULT '',
+  state        TEXT NOT NULL,
+  labels       TEXT NOT NULL DEFAULT '[]',  -- JSON array of label names; facts re-derived on read
+  milestone_id INTEGER,
+  assignee     TEXT,
+  assignees    TEXT NOT NULL DEFAULT '[]',  -- JSON array of logins
+  created_at   TEXT,
+  updated_at   TEXT,
+  closed_at    TEXT,
+  url          TEXT,
+  FOREIGN KEY (milestone_id) REFERENCES milestones(id)
+);
+CREATE TABLE IF NOT EXISTS labels (
+  id    INTEGER PRIMARY KEY,
+  name  TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS comments (
+  id            INTEGER PRIMARY KEY,
+  issue_number  INTEGER NOT NULL,
+  author        TEXT,
+  body          TEXT NOT NULL DEFAULT '',
+  created_at    TEXT
+);
+CREATE TABLE IF NOT EXISTS issue_events (
+  id            INTEGER PRIMARY KEY AUTOINCREMENT,
+  issue_number  INTEGER NOT NULL,
+  type          TEXT NOT NULL,
+  at            TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_issue_events_number ON issue_events(issue_number);
+CREATE INDEX IF NOT EXISTS idx_comments_number ON comments(issue_number);
+`
+
+/** Create the schema if absent. Idempotent. */
+export function initCache(driver: CacheDriver): void {
+  driver.exec(CACHE_SCHEMA)
+}
+
+const UPSERT_ISSUE = `
+INSERT INTO issues (number, title, body, state, labels, milestone_id, assignee, assignees, created_at, updated_at, closed_at, url)
+VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+ON CONFLICT(number) DO UPDATE SET
+  title = excluded.title, body = excluded.body, state = excluded.state, labels = excluded.labels,
+  milestone_id = excluded.milestone_id, assignee = excluded.assignee, assignees = excluded.assignees,
+  created_at = excluded.created_at, updated_at = excluded.updated_at, closed_at = excluded.closed_at, url = excluded.url
+`
+
+const UPSERT_MILESTONE = `
+INSERT INTO milestones (id, title, state, due_on) VALUES (?, ?, ?, ?)
+ON CONFLICT(id) DO UPDATE SET title = excluded.title, state = excluded.state, due_on = excluded.due_on
+`
+
+/**
+ * Mirror one reconciled issue into the cache (and its milestone, if any). Upsert
+ * by `number`, so re-reconciling the same issue updates in place — never duplicates.
+ */
+export function upsertIssue(driver: CacheDriver, issue: GiteaIssue): void {
+  if (issue.milestone) {
+    driver.run(UPSERT_MILESTONE, [issue.milestone.id, issue.milestone.title, null, issue.milestone.dueOn])
+  }
+  driver.run(UPSERT_ISSUE, [
+    issue.number,
+    issue.title,
+    issue.body,
+    issue.state,
+    JSON.stringify(issue.labels),
+    issue.milestone?.id ?? null,
+    issue.assignee,
+    JSON.stringify(issue.assignees),
+    issue.createdAt,
+    issue.updatedAt,
+    issue.closedAt,
+    issue.url,
+  ])
+}
+
+const READ_ISSUE = `
+SELECT i.*, m.title AS m_title, m.due_on AS m_due
+FROM issues i LEFT JOIN milestones m ON m.id = i.milestone_id
+WHERE i.number = ?
+`
+
+function str(v: unknown): string {
+  return typeof v === 'string' ? v : ''
+}
+
+/**
+ * Read one mirrored issue back as a domain object, re-deriving `facts` from the
+ * stored label set (so the mirror can't disagree with the label semantics).
+ * Returns null when the issue isn't cached.
+ */
+export function readIssue(driver: CacheDriver, number: number): GiteaIssue | null {
+  const row = driver.get(READ_ISSUE, [number])
+  if (!row) return null
+
+  const labels = (JSON.parse(str(row.labels) || '[]') as string[]) ?? []
+  const assignees = (JSON.parse(str(row.assignees) || '[]') as string[]) ?? []
+  const milestone: GiteaMilestoneRef | null =
+    row.milestone_id != null
+      ? { id: Number(row.milestone_id), title: str(row.m_title), dueOn: (row.m_due as string | null) ?? null }
+      : null
+
+  return {
+    number: Number(row.number),
+    title: str(row.title),
+    body: str(row.body),
+    state: row.state === 'closed' ? 'closed' : 'open',
+    labels,
+    facts: extractLabelFacts(labels),
+    milestone,
+    assignee: (row.assignee as string | null) ?? null,
+    assignees,
+    createdAt: str(row.created_at),
+    updatedAt: str(row.updated_at),
+    closedAt: (row.closed_at as string | null) ?? null,
+    url: str(row.url),
+  }
+}

packages/core/src/index.ts

@@ -23,6 +23,10 @@ export type {
   GiteaRequestInit,
 } from './gitea/types.js'
 
+export { CACHE_SCHEMA, initCache, readIssue, upsertIssue } from './cache/cache-v0.js'
+export type { CacheDriver } from './cache/cache-v0.js'
+export { affectedIssues, coalesceKey, enqueueWrite, pendingWrites, replayQueue } from './queue/write-queue-v0.js'
+export type { QueuedWrite } from './queue/write-queue-v0.js'
 export { describeChange, isLabelChange, planIssueChange, proposalsFor, summarizeChange } from './changes/apply-changes-v0.js'
 export type {
   ChangeProposal,

packages/core/src/perf/perf.test.ts

@@ -0,0 +1,75 @@
+/**
+ * Performance pass (#32). The deterministic compute path must stay well under the
+ * PLAN.md targets on representative fixtures:
+ *   - scheduler + Monte Carlo forecast < 1s @ 200 open issues.
+ *   - scaling stays roughly linear (no accidental O(n²) in the hot path).
+ *
+ * Reconcile-<5s@500 is network-bound (~2N gitea calls) and is covered by the live
+ * reconcile, not here — this file benchmarks the pure compute the app runs each
+ * turn. Bounds are the actual targets with comfortable headroom so timing jitter
+ * can't flake the suite; actuals are logged.
+ */
+import { describe, expect, it } from 'vitest'
+
+import { forecast } from '../forecast/forecast-v0.js'
+import { type DependencyEdge, schedule, type SchedulableIssue } from '../scheduler/scheduler-v0.js'
+import { scheduleWithCapacity, type Worker } from '../scheduler/scheduler-capacity-v0.js'
+
+const EST = [1, 2, 3, 5, 8]
+const WORKERS: Worker[] = [
+  { person: 'a', speed: 0.8 },
+  { person: 'b', speed: 0.6 },
+  { person: 'c', speed: 1.0 },
+]
+
+/** A representative open backlog: varied estimates/priorities/assignees + a light dependency web. */
+function backlog(n: number): { issues: SchedulableIssue[]; edges: DependencyEdge[] } {
+  const issues: SchedulableIssue[] = Array.from({ length: n }, (_, i) => ({
+    number: i + 1,
+    title: `Issue ${i + 1} with a representative title of some length`,
+    labels: [`est/${EST[i % EST.length]}d`, `p/${(i % 4) + 1}`],
+    estimateDays: EST[i % EST.length],
+    priority: (i % 4) + 1,
+    assignee: WORKERS[i % WORKERS.length].person,
+  }))
+  // ~1 dependency per 3 issues, always on a lower-numbered issue (acyclic)
+  const edges: DependencyEdge[] = []
+  for (let i = 3; i < n; i += 3) edges.push({ issue: i + 1, dependsOn: i - 1 })
+  return { issues, edges }
+}
+
+function ms(fn: () => void): number {
+  const t0 = performance.now()
+  fn()
+  return performance.now() - t0
+}
+
+describe('perf (#32)', () => {
+  it('scheduler + Monte Carlo forecast < 1s @ 200 open issues', () => {
+    const { issues, edges } = backlog(200)
+    const elapsed = ms(() => {
+      schedule(issues, edges)
+      scheduleWithCapacity(issues, edges, WORKERS)
+      forecast(issues, edges, { workers: WORKERS }) // 2000 trials (default)
+    })
+    // eslint-disable-next-line no-console
+    console.log(`[perf] schedule+capacity+forecast @200 = ${elapsed.toFixed(1)}ms`)
+    expect(elapsed).toBeLessThan(1000)
+  })
+
+  it('scales roughly linearly — 400 issues is well under 4x the 100-issue time', () => {
+    const small = backlog(100)
+    const big = backlog(400)
+    const run = (b: typeof small) => () => {
+      schedule(b.issues, b.edges)
+      forecast(b.issues, b.edges, { workers: WORKERS })
+    }
+    // warm up (JIT) so the ratio reflects steady state
+    run(small)()
+    const t100 = Math.max(ms(run(small)), 0.1)
+    const t400 = ms(run(big))
+    // eslint-disable-next-line no-console
+    console.log(`[perf] @100 = ${t100.toFixed(1)}ms · @400 = ${t400.toFixed(1)}ms · ratio ${(t400 / t100).toFixed(1)}x`)
+    expect(t400).toBeLessThan(t100 * 8) // generous: rules out O(n²), tolerant of jitter
+  })
+})

packages/core/src/queue/write-queue-v0.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, it, vi } from 'vitest'
+
+import type { IssueChange } from '../changes/apply-changes-v0.js'
+import { affectedIssues, coalesceKey, enqueueWrite, pendingWrites, replayQueue, type QueuedWrite } from './write-queue-v0.js'
+
+const reest = (issue: number, estimate: string): IssueChange =>
+  ({ kind: 'reestimate', issue, estimate }) as IssueChange
+const assign = (issue: number, assignee: string | null): IssueChange => ({ kind: 'assign', issue, assignee })
+
+describe('write-queue-v0 (#33)', () => {
+  it('coalesces repeat writes to the same (issue, axis) — replay applies the latest once', () => {
+    let q: QueuedWrite[] = []
+    q = enqueueWrite(q, reest(7, 'est/2d'), '2026-02-10T09:00:00Z')
+    q = enqueueWrite(q, reest(7, 'est/5d'), '2026-02-10T09:05:00Z') // supersedes est/2d
+    q = enqueueWrite(q, assign(7, 'christian'), '2026-02-10T09:06:00Z') // different axis — kept
+
+    expect(q).toHaveLength(2)
+    const pending = pendingWrites(q)
+    expect(pending).toEqual([
+      { kind: 'reestimate', issue: 7, estimate: 'est/5d' },
+      { kind: 'assign', issue: 7, assignee: 'christian' },
+    ])
+    expect(coalesceKey(reest(7, 'est/2d'))).toBe('7:reestimate')
+  })
+
+  it('keeps writes to different issues and axes distinct', () => {
+    let q: QueuedWrite[] = []
+    q = enqueueWrite(q, reest(7, 'est/2d'), 't1')
+    q = enqueueWrite(q, reest(8, 'est/3d'), 't2')
+    q = enqueueWrite(q, assign(8, null), 't3')
+    expect(q).toHaveLength(3)
+    expect(affectedIssues(q)).toEqual([7, 8])
+  })
+
+  it('a burst of edits then reconnect lands the final state without duplicating', async () => {
+    let q: QueuedWrite[] = []
+    // offline: three edits to #7's estimate, one assign
+    q = enqueueWrite(q, reest(7, 'est/1d'), 't1')
+    q = enqueueWrite(q, reest(7, 'est/2d'), 't2')
+    q = enqueueWrite(q, reest(7, 'est/8d'), 't3')
+    q = enqueueWrite(q, assign(7, 'stephen'), 't4')
+
+    const apply = vi.fn(async () => ({ ok: true }))
+    const { drained, remaining } = await replayQueue(q, apply)
+
+    // only the final estimate + the assign are applied — not three estimate writes
+    expect(apply).toHaveBeenCalledTimes(2)
+    expect(apply).toHaveBeenNthCalledWith(1, { kind: 'reestimate', issue: 7, estimate: 'est/8d' })
+    expect(apply).toHaveBeenNthCalledWith(2, { kind: 'assign', issue: 7, assignee: 'stephen' })
+    expect(remaining).toHaveLength(0)
+    expect(drained).toHaveLength(2)
+  })
+
+  it('keeps writes that still fail on reconnect queued (never throws)', async () => {
+    let q: QueuedWrite[] = []
+    q = enqueueWrite(q, reest(7, 'est/2d'), 't1')
+    q = enqueueWrite(q, reest(8, 'est/3d'), 't2')
+    // #7 applies, #8 rejects (still unreachable) — and one apply throws
+    const apply = vi.fn(async (c: IssueChange) => {
+      if (c.issue === 8) throw new Error('offline')
+      return { ok: true }
+    })
+    const { drained, remaining } = await replayQueue(q, apply)
+    expect(drained.map((w) => w.change.issue)).toEqual([7])
+    expect(remaining.map((w) => w.change.issue)).toEqual([8])
+  })
+})

packages/core/src/queue/write-queue-v0.ts

@@ -0,0 +1,71 @@
+/**
+ * Offline write-queue, v0 (#33). While gitea is unreachable, propose-approved
+ * writes are queued instead of lost; on reconnect they replay in order and
+ * resolve against a fresh reconcile. The one hard requirement is *no duplication*:
+ * replaying must not apply the same intent twice.
+ *
+ * The mechanism is coalescing by axis. Every write targets one field of one issue
+ * (its estimate, priority, assignee, or milestone). Queuing a second write to the
+ * same (issue, axis) supersedes the first — only the latest intent survives — so
+ * a burst of edits replays as one final write, and a replay is idempotent (the
+ * apply path no-ops a change already reflected server-side).
+ */
+
+import type { IssueChange } from '../changes/apply-changes-v0.js'
+
+export interface QueuedWrite {
+  change: IssueChange
+  /** ISO time the write was queued (for display + stable ordering). */
+  queuedAt: string
+}
+
+/**
+ * The coalescing key: one field of one issue. Two writes with the same key are
+ * the same intent expressed twice — the later wins. Each `IssueChange.kind` maps
+ * to exactly one axis, so `issue:kind` is the axis identity.
+ */
+export function coalesceKey(change: IssueChange): string {
+  return `${change.issue}:${change.kind}`
+}
+
+/**
+ * Queue a write, superseding any pending write to the same (issue, axis). The
+ * superseding write moves to the tail so replay order reflects latest intent.
+ */
+export function enqueueWrite(queue: readonly QueuedWrite[], change: IssueChange, queuedAt: string): QueuedWrite[] {
+  const key = coalesceKey(change)
+  return [...queue.filter((w) => coalesceKey(w.change) !== key), { change, queuedAt }]
+}
+
+/** The changes to replay, in order — one per (issue, axis) by construction. */
+export function pendingWrites(queue: readonly QueuedWrite[]): IssueChange[] {
+  return queue.map((w) => w.change)
+}
+
+/** Distinct issues touched by the queue — what a post-replay reconcile should re-read. */
+export function affectedIssues(queue: readonly QueuedWrite[]): number[] {
+  return [...new Set(queue.map((w) => w.change.issue))]
+}
+
+/**
+ * Replay the queue through an apply function (the same guarded write path used
+ * online), in order. Returns the writes that failed (still unreachable / rejected)
+ * so they stay queued; everything else drains. Never throws — a failure is data.
+ */
+export async function replayQueue(
+  queue: readonly QueuedWrite[],
+  apply: (change: IssueChange) => Promise<{ ok: boolean }>,
+): Promise<{ drained: QueuedWrite[]; remaining: QueuedWrite[] }> {
+  const drained: QueuedWrite[] = []
+  const remaining: QueuedWrite[] = []
+  for (const w of queue) {
+    let ok = false
+    try {
+      ok = (await apply(w.change)).ok
+    } catch {
+      ok = false
+    }
+    ;(ok ? drained : remaining).push(w)
+  }
+  return { drained, remaining }
+}