Merge branch 'main' into feat/standup-query-view

Reviewed-on: #55

apps/desktop/README.md

@@ -0,0 +1,42 @@
+# CommiTea (desktop)
+
+An AI project manager for Gitea, as an Electron desktop app. The token stays in
+the main process (OS keychain via `safeStorage`); the renderer never sees it.
+
+## Develop
+
+```bash
+yarn dev          # electron-vite dev, HMR renderer + main (logs → desktop.log)
+yarn typecheck
+yarn e2e          # builds, then Playwright against the built main (fixtures/demo)
+```
+
+For a live pass against a real Gitea, put a token in `.env.local`
+(`GITEA_TOKEN=…`) and run `GITEA_LIVE=1 yarn e2e live-onboarding`.
+
+## Package (shareable macOS .dmg)
+
+```bash
+yarn pack         # unpacked .app for the host arch (fast sanity check) → dist/
+yarn dist         # arm64 + x64 .dmg → dist/CommiTea-<version>[-arm64].dmg
+```
+
+Config is `electron-builder.yml`. Builds are **unsigned** (no Apple certs, by
+decision) — electron-builder ad-hoc signs so the app can run, but it is not
+notarized. Bump `version` in `package.json` for a new release; keep
+`electronVersion` in `electron-builder.yml` in sync with the `electron`
+devDependency.
+
+### Installing a shared build (teammates)
+
+macOS Gatekeeper blocks unsigned apps on first launch. To open:
+
+1. Open the `.dmg` and drag **CommiTea** to **Applications**.
+2. In Applications, **right-click CommiTea → Open**, then confirm **Open** in the
+   dialog. (Double-clicking the first time just shows "cannot be opened".)
+3. It opens to the connection screen — enter your Gitea base URL, `owner/repo`,
+   and a personal access token (repo scope). Each teammate uses their own token,
+   so activity is attributed correctly. A model URL is optional; chat is disabled
+   until one is configured, everything else works without it.
+
+Grab the `-arm64` dmg on Apple Silicon, the plain one on Intel.

apps/desktop/e2e/live-onboarding.spec.ts

@@ -38,6 +38,11 @@ test.describe('live onboarding', () => {
     const win = await app.firstWindow()
     await win.waitForLoadState('domcontentloaded')
 
+    // Any uncaught render error in a real-data view builder must fail the test —
+    // this is the "it actually works on real data" guarantee.
+    const pageErrors: string[] = []
+    win.on('pageerror', (e) => pageErrors.push(e.message))
+
     // the connection gate, not the app
     await expect(win.getByText(/Connect your Gitea/)).toBeVisible({ timeout: 15000 })
     await win.getByPlaceholder('your-org').fill('christian')
@@ -45,11 +50,35 @@ test.describe('live onboarding', () => {
     await win.getByPlaceholder(/gitea PAT/).fill(token!)
     await win.getByRole('button', { name: 'Connect' }).click()
 
-    // it validated + saved + reconciled into the real board — real issue titles prove it
     const rail = win.getByRole('navigation', { name: 'Primary' })
+    const realTitle = /Model router|SQLite cache bootstrap|Purity\/rebuild/
+
+    // Board (real reconciled columns) — real issue titles prove the sync landed.
     await rail.getByRole('button', { name: 'The pot' }).click()
-    await expect(win.getByText(/Model router|SQLite cache bootstrap|Purity\/rebuild/).first()).toBeVisible({ timeout: 30000 })
+    await expect(win.getByText(realTitle).first()).toBeVisible({ timeout: 30000 })
+
+    // Gantt tab — scheduler-derived bars over the real open backlog.
+    await win.getByRole('tab', { name: 'Gantt' }).click()
+    await expect(win.getByText(realTitle).first()).toBeVisible()
+
+    // Dependencies tab — real dep graph. Just needs to render without throwing.
+    await win.getByRole('tab', { name: 'Dependencies' }).click()
+    await win.waitForTimeout(300)
+
+    // Issue drill-in — the machine-derived sidecar (lifecycle/forecast/deps) on a real issue.
+    await win.getByRole('tab', { name: 'Board' }).click()
+    await win.getByText(realTitle).first().click()
+    await expect(win.getByText('Machine-derived')).toBeVisible()
+    await win.getByRole('button', { name: 'Back' }).click()
+
+    // Standup + Inbox — scheduler plan / nag / inbox feed over real data.
+    await rail.getByRole('button', { name: 'Standup' }).click()
+    await expect(win.getByRole('heading', { name: 'Morning standup' })).toBeVisible()
+    await rail.getByRole('button', { name: 'Inbox' }).click()
+    await expect(win.getByRole('heading', { name: 'Inbox' })).toBeVisible()
+
     await win.screenshot({ path: join(here, '.artifacts', 'screens', 'live-onboarding.png'), fullPage: true, animations: 'disabled' })
+    expect(pageErrors, `uncaught render errors: ${pageErrors.join(' · ')}`).toEqual([])
 
     await app.close()
   })

apps/desktop/electron-builder.yml

@@ -0,0 +1,51 @@
+appId: io.stephenmann.commitea
+productName: CommiTea
+copyright: © CommiTea
+
+# Pinned because electron is hoisted by the yarn workspace and declared with a
+# caret range, which electron-builder can't resolve on its own. Keep in sync with
+# the electron devDependency.
+electronVersion: 34.5.8
+
+directories:
+  buildResources: build
+  output: dist
+
+# The renderer, preload, and main are already bundled into out/ by electron-vite
+# (@commitea/core, react, react-dom are all inlined). So the packaged app needs
+# nothing from node_modules except the Electron runtime that electron-builder
+# supplies — ship only the build output.
+files:
+  - out/**
+  - '!**/*.map'
+npmRebuild: false
+electronLanguages:
+  - en
+
+mac:
+  target:
+    - target: dmg
+      arch:
+        - arm64
+        - x64
+  category: public.app-category.developer-tools
+  icon: build/icon.png
+  # Unsigned, per the distribution decision (macOS, no certs). Teammates
+  # right-click → Open the first time to get past Gatekeeper.
+  identity: null
+  # Keep hardened-runtime off — it only matters for signed/notarized builds
+  # and can block an unsigned app from launching.
+  hardenedRuntime: false
+  gatekeeperAssess: false
+
+dmg:
+  title: CommiTea ${version}
+  # A plain drag-to-Applications layout.
+  contents:
+    - x: 130
+      y: 220
+      type: file
+    - x: 410
+      y: 220
+      type: link
+      path: /Applications

apps/desktop/package.json

@@ -1,5 +1,8 @@
 {
   "name": "@commitea/desktop",
+  "version": "0.1.0",
+  "description": "CommiTea — an AI project manager for Gitea",
+  "author": "CommiTea",
   "private": true,
   "type": "module",
   "main": "./out/main/index.js",
@@ -10,7 +13,9 @@
     "typecheck": "tsc --noEmit",
     "e2e": "electron-vite build && playwright test",
     "e2e:only": "playwright test",
-    "e2e:report": "playwright show-report e2e/.artifacts/report"
+    "e2e:report": "playwright show-report e2e/.artifacts/report",
+    "pack": "electron-vite build && electron-builder --dir",
+    "dist": "electron-vite build && electron-builder --mac"
   },
   "dependencies": {
     "@commitea/core": "workspace:*",
@@ -25,9 +30,11 @@
     "@vitejs/plugin-react": "^4.3.4",
     "autoprefixer": "^10.4.20",
     "electron": "^34.0.0",
+    "electron-builder": "^25",
     "electron-vite": "^3.1.0",
     "postcss": "^8.5.1",
     "tailwindcss": "^3.4.17",
+    "tsx": "^4",
     "typescript": "^5.7.3",
     "vite": "^6.1.0"
   }

apps/desktop/scripts/dogfood-report.ts

@@ -0,0 +1,142 @@
+/**
+ * Dogfood (#31): run CommiTea's own deterministic engine against the live
+ * christian/commitea backlog and print the project report each screen derives —
+ * board, critical path, schedule, Monte Carlo forecast, per-milestone runway.
+ *
+ * This is the core brain (schedule + forecast + capacity), the exact code the
+ * desktop app runs. Read-only. Run:  yarn tsx scripts/dogfood-report.ts
+ */
+import { readFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+import {
+  createGiteaClient,
+  forecast,
+  inferLifecycle,
+  parseCapacityConfig,
+  capacityPerWorkday,
+  scheduleWithCapacity,
+  type GiteaIssue,
+  type DependencyEdge,
+  type Worker,
+} from '@commitea/core'
+
+const here = dirname(fileURLToPath(import.meta.url))
+
+function token(): string {
+  let dir = here
+  for (let i = 0; i < 6; i++) {
+    try {
+      const m = /^GITEA_TOKEN\s*=\s*(.+?)\s*$/m.exec(readFileSync(join(dir, '.env.local'), 'utf8'))
+      if (m) return m[1].trim()
+    } catch {
+      /* keep walking up */
+    }
+    dir = dirname(dir)
+  }
+  throw new Error('no GITEA_TOKEN in any .env.local up the tree')
+}
+
+/** working-day offset → calendar date (skip Sat/Sun), then a short label. */
+function addWorkingDays(base: Date, n: number): Date {
+  const d = new Date(base)
+  let left = Math.ceil(n)
+  while (left > 0) {
+    d.setDate(d.getDate() + 1)
+    const day = d.getDay()
+    if (day !== 0 && day !== 6) left--
+  }
+  return d
+}
+const fmt = (d: Date) => d.toLocaleDateString('en-US', { month: 'short', day: 'numeric' })
+
+async function main() {
+  const client = createGiteaClient(
+    { baseUrl: 'https://gitea.stephenmann.io', owner: 'christian', repo: 'commitea', token: token() },
+    fetch,
+  )
+
+  const all = await client.listIssues({ state: 'all' })
+  const open = all.filter((i) => i.state === 'open')
+  const closed = all.filter((i) => i.state === 'closed')
+
+  // Real dependency edges (open issues only — the scheduler drops out-of-scope endpoints anyway).
+  const edges: DependencyEdge[] = []
+  for (const i of open) {
+    for (const dep of await client.getIssueDependencies(i.number)) edges.push({ issue: i.number, dependsOn: dep })
+  }
+
+  // Capacity lanes from the pm-state repo (a separate repo, exactly like the app's
+  // pmStateClient — NOT the managed repo).
+  const pmClient = createGiteaClient(
+    { baseUrl: 'https://gitea.stephenmann.io', owner: 'christian', repo: 'commitea-pm-state', token: token() },
+    fetch,
+  )
+  let workers: Worker[] = []
+  try {
+    const f = await pmClient.getFile('capacity/members.json')
+    if (f) {
+      const members = parseCapacityConfig(JSON.parse(Buffer.from(f.contentBase64, 'base64').toString('utf8')))
+      workers = members.map((m) => ({ person: m.person, speed: capacityPerWorkday(m) }))
+    }
+  } catch {
+    /* no capacity → single serial worker */
+  }
+
+  const toSchedulable = (issues: GiteaIssue[]) =>
+    issues.map((i) => ({
+      number: i.number,
+      title: i.title,
+      labels: i.labels,
+      estimateDays: i.facts.estimateDays,
+      priority: i.facts.priority,
+      assignee: i.assignee,
+    }))
+
+  const plan = scheduleWithCapacity(toSchedulable(open), edges, workers)
+  const today = new Date()
+  const f = forecast(toSchedulable(open), edges, { workers })
+
+  const bar = '─'.repeat(64)
+  console.log(`\n${bar}\n CommiTea, on itself — ${fmt(today)} ${today.getFullYear()}\n${bar}`)
+  console.log(` Board: ${open.length} open · ${closed.length} done`)
+  console.log(` Team:  ${workers.length ? workers.map((w) => `${w.person} (${w.speed.toFixed(2)}/day)`).join(', ') : 'single serial worker'}`)
+  const unassigned = open.filter((i) => !i.assignee).length
+  if (unassigned) console.log(` ⚠  ${unassigned}/${open.length} open issues have no assignee`)
+
+  console.log(`\n Schedule (dependency + priority order, ${workers.length || 1} lane${workers.length === 1 ? '' : 's'}):`)
+  for (const it of plan.items) {
+    const crit = it.critical ? ' ★crit' : ''
+    const lane = it.worker ? ` [${it.worker}]` : ''
+    const blocks = it.blocks.length ? `  blocks ${it.blocks.map((b) => '#' + b).join(',')}` : ''
+    console.log(
+      `  #${String(it.number).padEnd(3)} ${fmt(addWorkingDays(today, it.startDay))}→${fmt(addWorkingDays(today, it.endDay))}${crit.padEnd(7)}${lane} ${it.title.slice(0, 38)}${blocks}`,
+    )
+  }
+  if (plan.cycle) console.log(`  ⚠ dependency cycle: ${plan.cycle.join(' → ')}`)
+
+  const p90 = f.curve.length ? f.curve[f.curve.length - 1].p90Day : f.p95Day
+  console.log(`\n Forecast (Monte Carlo, ${f.trials} trials, ${f.coldStart ? 'cold-start priors' : 'fitted'}):`)
+  console.log(`  whole backlog lands  p50 ${fmt(addWorkingDays(today, f.p50Day))} · p80 ${fmt(addWorkingDays(today, f.p80Day))} · p90 ${fmt(addWorkingDays(today, p90))}`)
+
+  // Per-milestone runway.
+  const ms = await client.listMilestones()
+  console.log(`\n Runway (per open milestone):`)
+  for (const m of ms.filter((x) => x.state === 'open')) {
+    const scope = open.filter((i) => i.milestone?.id === m.id)
+    if (!scope.length) continue
+    const mf = forecast(toSchedulable(scope), edges, { workers })
+    const mp90 = mf.curve.length ? mf.curve[mf.curve.length - 1].p90Day : mf.p95Day
+    const due = m.dueOn ? fmt(new Date(m.dueOn)) : 'no due date'
+    console.log(
+      `  ${m.title.padEnd(28)} ${scope.length} open · p50 ${fmt(addWorkingDays(today, mf.p50Day))}–p90 ${fmt(addWorkingDays(today, mp90))}  (due: ${due})`,
+    )
+  }
+  console.log(`\n${bar}\n`)
+}
+
+main().catch((e) => {
+  console.error(e)
+  process.exit(1)
+})

apps/desktop/src/renderer/src/components/screens/board-screen.tsx

@@ -1,6 +1,6 @@
 import React from 'react'
 
-import { COLUMNS, type BoardColumn, type BoardIssue, type IssueRef } from '../../data/fixtures.js'
+import { COLUMNS, type BoardColumn, type BoardIssue, type DepsData, type GanttData, type IssueRef } from '../../data/fixtures.js'
 import { Card, Tag, Badge, Tabs, IconButton, Input, Icon } from '../ui/index.js'
 import { EmptyState } from '../shell/states.js'
 import { GanttView } from './gantt-view.js'
@@ -12,10 +12,14 @@ import { DepsGraph } from './deps-graph.js'
 export function BoardScreen({
   onOpenIssue,
   columns = COLUMNS,
+  gantt,
+  deps,
   loading = false,
 }: {
   onOpenIssue: (issue: IssueRef) => void
   columns?: BoardColumn[]
+  gantt?: GanttData
+  deps?: DepsData
   loading?: boolean
 }) {
   const [tab, setTab] = React.useState('board');
@@ -90,9 +94,9 @@ export function BoardScreen({
           </div>
         )
       ) : tab === 'deps' ? (
-        <DepsGraph onOpenIssue={onOpenIssue} />
+        <DepsGraph onOpenIssue={onOpenIssue} data={deps} />
       ) : (
-        <GanttView onOpenIssue={onOpenIssue} />
+        <GanttView onOpenIssue={onOpenIssue} data={gantt} />
       )}
     </div>
   );

apps/desktop/src/renderer/src/components/screens/calibration-screen.tsx

@@ -178,6 +178,9 @@ export function CalibrationScreen({ onBack, data }: { onBack: () => void; data?:
               {c.active
                 ? 'You are not bad at estimating; you are optimistic in a very stable way. Stable, I can work with.'
                 : 'Not enough closed history yet — I’m forecasting from cold-start priors and widening the cone to stay honest. The curve takes over at 20.'}
+              {!c.active && c.excludedSameDay > 0
+                ? ` And ${c.excludedSameDay} closed ${c.excludedSameDay === 1 ? 'issue' : 'issues'} closed the same day they were started — 0 working days can’t calibrate, so they don’t count toward the 20.`
+                : ''}
             </p>
           </Card>
         </div>

apps/desktop/src/renderer/src/components/screens/deps-graph.tsx

@@ -1,11 +1,11 @@
 import React from 'react'
 
-import { DEPS, type IssueRef } from '../../data/fixtures.js'
+import { DEPS, type DepsData, type IssueRef } from '../../data/fixtures.js'
 import { Tag, Icon } from '../ui/index.js'
 
 // Dependency graph drill-in — layered DAG, critical path in spruce
-export function DepsGraph({ onOpenIssue }: { onOpenIssue: (issue: IssueRef) => void }) {
-  const g = DEPS
+export function DepsGraph({ onOpenIssue, data }: { onOpenIssue: (issue: IssueRef) => void; data?: DepsData }) {
+  const g = data ?? DEPS
 
   const PAD = 14, COLW = 206, ROWH = 106, NW = 176, NH = 84
   const X = (c: number) => PAD + c * COLW

apps/desktop/src/renderer/src/components/screens/gantt-view.tsx

@@ -1,11 +1,11 @@
 import React from 'react'
 
-import { GANTT, type IssueRef } from '../../data/fixtures.js'
+import { GANTT, type GanttData, type IssueRef } from '../../data/fixtures.js'
 import { Icon } from '../ui/index.js'
 
 // Gantt drill-in — scheduler-derived bars, critical chain, 80% forecast tails
-export function GanttView({ onOpenIssue }: { onOpenIssue: (issue: IssueRef) => void }) {
-  const g = GANTT;
+export function GanttView({ onOpenIssue, data }: { onOpenIssue: (issue: IssueRef) => void; data?: GanttData }) {
+  const g = data ?? GANTT;
 
   const LABELW = 232, DAYW = 21, ROWH = 36, HEADH = 30;
   const chartW = g.days * DAYW;

apps/desktop/src/renderer/src/components/screens/inbox-screen.tsx

@@ -9,13 +9,15 @@ export function InboxScreen({
   onOpenDirectives,
   readIds,
   setReadIds,
+  data,
 }: {
   onOpenIssue: (issue: IssueRef) => void
   onOpenDirectives: () => void
   readIds: number[]
   setReadIds: React.Dispatch<React.SetStateAction<number[]>>
+  data?: InboxItem[]
 }) {
-  const all = INBOX
+  const all = data ?? INBOX
   const [tab, setTab] = React.useState('all')
 
   const isRead = (n: InboxItem) => !n.unread || readIds.includes(n.id)

apps/desktop/src/renderer/src/components/screens/issue-screen.tsx

@@ -17,6 +17,7 @@ const NONE = '—'
 
 export function IssueScreen({
   issue,
+  detail,
   onBack,
   onOpenIssue,
   canWrite = false,
@@ -27,6 +28,7 @@ export function IssueScreen({
   currentMilestoneId = null,
 }: {
   issue: IssueRef
+  detail?: IssueDetail
   onBack: () => void
   onOpenIssue: (issue: IssueRef) => void
   canWrite?: boolean
@@ -36,7 +38,7 @@ export function IssueScreen({
   currentAssignee?: string | null
   currentMilestoneId?: number | null
 }) {
-  const det: IssueDetail = ISSUE_DETAIL[issue.id] || {
+  const det: IssueDetail = detail ?? ISSUE_DETAIL[issue.id] ?? {
     state: 'triage',
     assignee: 'Stephen',
     milestone: 'Beta',
@@ -317,7 +319,7 @@ export function IssueScreen({
                       <span style={{ font: '400 11px var(--font-mono)', color: 'var(--ink-3)' }}>blocks</span>
                       {det.blocks.map((b) => (
                         <button key={b} type="button"
-                          onClick={() => onOpenIssue({ id: b, title: b === 91 ? 'Webhook listener: reconcile on reconnect' : 'Monte Carlo engine: percentile bands', labels: b === 91 ? ['est/3d', 'p/2'] : ['est/5d', 'p/1'] })}
+                          onClick={() => onOpenIssue({ id: b })}
                           style={{ font: '500 11px var(--font-mono)', color: 'var(--accent-text)', background: 'var(--spruce-1)', border: '1px solid var(--spruce-2)', borderRadius: 'var(--radius-1)', padding: '2px 7px', cursor: 'pointer' }}>
                           #{b}
                         </button>

apps/desktop/src/renderer/src/components/screens/runway-screen.tsx

@@ -17,7 +17,7 @@ export function RunwayScreen({
 }: {
   onOpenCalibration: () => void
   onOpenMilestone: (id?: number) => void
-  calibration?: { n: number; coldStart: boolean }
+  calibration?: { n: number; coldStart: boolean; excludedSameDay?: number }
   milestones?: RunwayMilestone[]
   capacity?: CapacityMember[]
 }) {
@@ -30,9 +30,11 @@ export function RunwayScreen({
           hours: `${capacityPerWorkday(m).toFixed(2)} pd/day`,
         }))
       : CAPACITY
+  const excluded = calibration?.excludedSameDay ?? 0
   const calibNote = calibration
     ? calibration.coldStart
-      ? `cold-start priors · ${calibration.n}/20 closed issues estimated`
+      ? `cold-start priors · ${calibration.n}/20 closed issues estimated` +
+        (excluded > 0 ? ` · ${excluded} same-day close${excluded === 1 ? '' : 's'} can’t calibrate` : '')
       : `calibrated on ${calibration.n} closed ${calibration.n === 1 ? 'issue' : 'issues'}`
     : 'calibrated on 27 closed issues'
   return (

apps/desktop/src/renderer/src/components/screens/standup-screen.tsx

@@ -1,6 +1,6 @@
 import React from 'react'
 
-import { type IssueRef, STANDUP } from '../../data/fixtures.js'
+import { type IssueRef, STANDUP, type StandupData } from '../../data/fixtures.js'
 import { Badge, Button, Icon } from '../ui/index.js'
 
 const standupCSS = `
@@ -36,15 +36,15 @@ const toneColor: Record<string, string> = {
 export function StandupScreen({
   onBegin,
   onOpenIssue,
+  data,
 }: {
   onBegin: () => void
   onOpenIssue: (issue: IssueRef) => void
+  data?: StandupData
 }) {
-  const s = STANDUP
+  const s = data ?? STANDUP
   const NAG_REF: IssueRef = {
     id: s.nag.id,
-    title: 'Fix lifecycle inference on merge events',
-    labels: ['est/2d', 'p/1'],
     days: s.nag.days,
   }
 

apps/desktop/src/renderer/src/components/shell/app-shell.tsx

@@ -17,6 +17,12 @@ import {
 } from '../../lib/backlog.js'
 import { useBacklog } from '../../lib/use-backlog.js'
 import { useCapacity } from '../../lib/use-capacity.js'
+import { depsGraphView } from '../../lib/views/deps-graph.js'
+import { ganttView } from '../../lib/views/gantt-view.js'
+import { inboxView } from '../../lib/views/inbox-view.js'
+import { issueDetailView } from '../../lib/views/issue-detail.js'
+import type { ProjectData } from '../../lib/views/project-data.js'
+import { standupView } from '../../lib/views/standup-view.js'
 import { PrimitivesGallery } from '../gallery.js'
 import { BoardScreen } from '../screens/board-screen.js'
 import { CalibrationScreen } from '../screens/calibration-screen.js'
@@ -100,6 +106,7 @@ export function AppShell() {
   const [readIds, setReadIds] = useState<number[]>([])
   const [milestoneId, setMilestoneId] = useState<number | null>(null)
   const [gate, setGate] = useState<'checking' | 'connect' | 'ready'>('checking')
+  const [demo, setDemo] = useState(false)
   const [pubConfig, setPubConfig] = useState<PublicConfig | null>(null)
   const [collaborators, setCollaborators] = useState<{ login: string; name: string }[]>([])
   const [backlog, refetchBacklog] = useBacklog()
@@ -133,6 +140,41 @@ export function AppShell() {
         ) ?? undefined)
       : undefined
 
+  // The uniform input every real-data view builder consumes. Assembled once from
+  // the reconciled backlog + capacity; undefined until the first reconcile lands.
+  const projectData: ProjectData | undefined =
+    backlog.status === 'ready'
+      ? {
+          issues: backlog.issues,
+          milestones: backlog.milestones,
+          deps: backlog.deps,
+          timelines: backlog.timelines,
+          calibration: calibration?.model,
+          workers,
+          today: new Date(),
+        }
+      : undefined
+  const issueDetail =
+    projectData && issue ? (issueDetailView(issue.id, projectData) ?? undefined) : undefined
+  const standup = projectData ? standupView(projectData) : undefined
+  const inbox = projectData ? inboxView(projectData) : undefined
+  const gantt = projectData ? ganttView(projectData) : undefined
+  const depsGraph = projectData ? depsGraphView(projectData) : undefined
+  // The rail's unread badge tracks the real inbox once reconciled (still-unread
+  // minus what's been opened); demo shows the fixture count.
+  const inboxUnread = inbox
+    ? inbox.filter((n) => n.unread && !readIds.includes(n.id)).length
+    : INBOX_UNREAD
+
+  // The real connected host (from the saved config), for the rail's status line.
+  const hostLabel = (() => {
+    try {
+      return pubConfig?.baseUrl ? new URL(pubConfig.baseUrl).host : 'gitea'
+    } catch {
+      return pubConfig?.baseUrl ?? 'gitea'
+    }
+  })()
+
   useEffect(() => {
     document.documentElement.setAttribute('data-theme', dark ? 'dark' : 'light')
   }, [dark])
@@ -142,7 +184,10 @@ export function AppShell() {
   useEffect(() => {
     window.commitea.gitea
       .status()
-      .then((s) => setGate(s.demo || s.configured ? 'ready' : 'connect'))
+      .then((s) => {
+        setDemo(s.demo)
+        setGate(s.demo || s.configured ? 'ready' : 'connect')
+      })
       .catch(() => setGate('connect'))
     window.commitea.config.get().then(setPubConfig).catch(() => {})
     // Assignable people for the Adjust dialog's assignee picker (empty when demo/unconfigured).
@@ -158,7 +203,15 @@ export function AppShell() {
 
   const openIssue = (ref: IssueRef) => {
     if (view !== 'issue') setPrevView(view)
-    setIssue(ref)
+    // Callers into the sidecar (e.g. a "blocks #N" chip) may know only the id.
+    // Backfill the real title + labels from the reconciled backlog so the header
+    // isn't blank; fall back to whatever the caller passed (demo fixtures).
+    let full = ref
+    if (backlog.status === 'ready' && (!ref.title || !ref.labels)) {
+      const found = backlog.issues.find((i) => i.number === ref.id)
+      if (found) full = { ...ref, id: found.number, title: found.title, labels: found.labels }
+    }
+    setIssue(full)
     setView('issue')
   }
 
@@ -176,7 +229,7 @@ export function AppShell() {
   const NAV: NavEntry[] = [
     { id: 'standup', label: 'Standup', icon: 'sun' },
     { id: 'focus', label: 'Morning service', icon: 'coffee' },
-    { id: 'inbox', label: 'Inbox', icon: 'bell', count: INBOX_UNREAD || null },
+    { id: 'inbox', label: 'Inbox', icon: 'bell', count: inboxUnread || null },
     { id: 'capture', label: 'Capture', icon: 'plus' },
     { id: 'board', label: 'The pot', icon: 'square-kanban' },
     { id: 'runway', label: 'Runway', icon: 'chart-line' },
@@ -234,12 +287,14 @@ export function AppShell() {
       case 'focus':
         return <FocusScreen onOpenIssue={openIssue} focus={focus} forecast={forecast} />
       case 'standup':
-        return <StandupScreen onBegin={() => setView('focus')} onOpenIssue={openIssue} />
+        return <StandupScreen onBegin={() => setView('focus')} onOpenIssue={openIssue} data={standup} />
       case 'board':
         return (
           <BoardScreen
             onOpenIssue={openIssue}
             columns={boardColumns}
+            gantt={gantt}
+            deps={depsGraph}
             loading={backlog.status === 'loading'}
           />
         )
@@ -251,7 +306,15 @@ export function AppShell() {
               setMilestoneId(id ?? null)
               setView('milestone')
             }}
-            calibration={calibration ? { n: calibration.model.n, coldStart: calibration.model.coldStart } : undefined}
+            calibration={
+              calibration
+                ? {
+                    n: calibration.model.n,
+                    coldStart: calibration.model.coldStart,
+                    excludedSameDay: calibration.coverage.excludedSameDay,
+                  }
+                : undefined
+            }
             milestones={runwayMilestones}
             capacity={capacityMembers}
           />
@@ -267,6 +330,7 @@ export function AppShell() {
             onOpenDirectives={() => setView('directives')}
             readIds={readIds}
             setReadIds={setReadIds}
+            data={inbox}
           />
         )
       case 'capture':
@@ -292,6 +356,7 @@ export function AppShell() {
         return issue ? (
           <IssueScreen
             issue={issue}
+            detail={issueDetail}
             onBack={() => setView(prevView)}
             onOpenIssue={openIssue}
             canWrite={backlog.status === 'ready'}
@@ -370,9 +435,15 @@ export function AppShell() {
 
         <div style={{ borderTop: '1px solid var(--line-1)', margin: '10px 8px' }} />
         <NavItem item={{ id: 'settings', label: 'Settings', icon: 'settings-2' }} />
-        <NavItem item={{ id: 'firstrun', label: 'First run', icon: 'play' }} />
-        <NavItem item={{ id: 'states', label: 'States', icon: 'circle-dashed' }} />
-        <NavItem item={{ id: 'primitives', label: 'Primitives', icon: 'layers' }} />
+        {/* Dev-only surfaces (fixture galleries / onboarding preview) — shown in dev
+            and in demo/e2e mode; hidden in a real configured, packaged app. */}
+        {import.meta.env.DEV || demo ? (
+          <>
+            <NavItem item={{ id: 'firstrun', label: 'First run', icon: 'play' }} />
+            <NavItem item={{ id: 'states', label: 'States', icon: 'circle-dashed' }} />
+            <NavItem item={{ id: 'primitives', label: 'Primitives', icon: 'layers' }} />
+          </>
+        ) : null}
 
         <div style={{ marginTop: 'auto', padding: '0 12px', display: 'flex', flexDirection: 'column', gap: 12 }}>
           <button
@@ -402,7 +473,7 @@ export function AppShell() {
                 display: 'inline-block',
               }}
             />
-            gitea.stephenmann.io
+            {hostLabel}
           </button>
           <Switch
             label={<span style={{ font: 'var(--text-caption)' }}>Evening service</span>}

apps/desktop/src/renderer/src/data/fixtures.ts

@@ -361,11 +361,14 @@ export interface CalibrationData {
   scatter: number[][]
   fit: number
   effect: { raw: string; banded: string; p50: string }
+  /** Closed+estimated issues that can't calibrate (same-day / 0-day closes). */
+  excludedSameDay: number
 }
 
 export const CALIBRATION: CalibrationData = {
   n: 27,
   active: true,
+  excludedSameDay: 0,
   labels: [
     { label: 'est/1d', n: 8, median: '1.1d', bias: 8 },
     { label: 'est/2d', n: 9, median: '2.4d', bias: 18 },

apps/desktop/src/renderer/src/lib/backlog.ts

@@ -1,6 +1,8 @@
 import {
+  type CalibrationCoverage,
   type CalibrationModel,
   type CalibrationSample,
+  calibrationCoverage,
   calibrationSamples,
   type CapacityMember,
   capacityPerWorkday,
@@ -171,10 +173,11 @@ export function backlogCalibration(
   issues: GiteaIssue[],
   timelines: Timelines = {},
   asOf: Date = new Date(),
-): { model: CalibrationModel; data: CalibrationData } {
+): { model: CalibrationModel; data: CalibrationData; coverage: CalibrationCoverage } {
   const samples = calibrationSamples(issues, timelines, asOf)
   const model = fitCalibration(samples)
-  return { model, data: calibrationData(model, samples, issues) }
+  const coverage = calibrationCoverage(issues, timelines, asOf)
+  return { model, coverage, data: calibrationData(model, samples, issues, coverage.excludedSameDay) }
 }
 
 const pctFromMu = (mu: number) => Math.round((Math.exp(mu) - 1) * 100)
@@ -188,6 +191,7 @@ export function calibrationData(
   model: CalibrationModel,
   samples: CalibrationSample[],
   openIssues: GiteaIssue[],
+  excludedSameDay = 0,
 ): CalibrationData {
   const labels = PRIOR_BUCKETS.map((b) => {
     const inBucket = samples.filter((s) => s.bucket === b)
@@ -227,6 +231,7 @@ export function calibrationData(
     scatter: samples.map((s) => [s.estimateDays, s.actualWorkingDays]),
     fit: Number(Math.exp(model.global.mu).toFixed(2)),
     effect,
+    excludedSameDay,
   }
 }
 

apps/desktop/src/renderer/src/lib/views/deps-graph.ts

@@ -0,0 +1,195 @@
+import { inferLifecycle, schedule } from '@commitea/core'
+
+import type { DepEdge, DepNode, DepsData } from '../../data/fixtures.js'
+import { formatShort } from '../dates.js'
+import type { ProjectData } from './project-data.js'
+
+/** Copy of backlog.ts's private toSchedulable — open issues → scheduler input. Not exported there. */
+function toSchedulable(issues: ProjectData['issues']) {
+  return issues
+    .filter((i) => i.state === 'open')
+    .map((i) => ({
+      number: i.number,
+      title: i.title,
+      labels: i.labels,
+      estimateDays: i.facts.estimateDays,
+      priority: i.facts.priority,
+      assignee: i.assignee,
+    }))
+}
+
+function median(values: number[]): number {
+  if (values.length === 0) return 0
+  const sorted = [...values].sort((a, b) => a - b)
+  const mid = Math.floor(sorted.length / 2)
+  return sorted.length % 2 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2
+}
+
+/**
+ * Real Deps-graph view: dependency topology of every issue that appears in a
+ * real gitea dependency edge, laid out into columns (longest dependency depth)
+ * and rows (index within its column, ordered by issue number). Critical path
+ * comes from the deterministic scheduler over the open backlog — closed issues
+ * never schedule, so they can't be critical, which is honest (they're done).
+ * The milestone node is the open milestone with the most open in-scope issues;
+ * when nothing links to a real milestone we fall back to the first open one,
+ * then to a bare '—' placeholder — never a fabricated name/date.
+ */
+export function depsGraphView(d: ProjectData): DepsData {
+  const byNumber = new Map(d.issues.map((i) => [i.number, i]))
+
+  // Participating set: anything that shows up as either end of a real edge,
+  // restricted to issues we actually have (dangling refs to unknown issues
+  // are dropped — nothing honest to draw for them).
+  const participating = new Set<number>()
+  for (const e of d.deps) {
+    if (byNumber.has(e.issue)) participating.add(e.issue)
+    if (byNumber.has(e.dependsOn)) participating.add(e.dependsOn)
+  }
+
+  if (participating.size === 0) {
+    const fallback = d.milestones.find((m) => m.state === 'open')
+    return {
+      nodes: [],
+      milestone: fallback
+        ? { name: fallback.title, due: fallback.dueOn ? formatShort(new Date(fallback.dueOn)) : 'no date', col: 0, row: 0 }
+        : { name: '—', due: 'no date', col: 0, row: 0 },
+      edges: [],
+      critical: [],
+      unattached: [],
+    }
+  }
+
+  // In-scope deps: both endpoints participating.
+  const depsMap = new Map<number, number[]>() // issue -> its dependencies
+  const dependentsMap = new Map<number, number[]>() // issue -> who depends on it
+  for (const id of participating) {
+    depsMap.set(id, [])
+    dependentsMap.set(id, [])
+  }
+  for (const e of d.deps) {
+    if (participating.has(e.issue) && participating.has(e.dependsOn)) {
+      depsMap.get(e.issue)!.push(e.dependsOn)
+      dependentsMap.get(e.dependsOn)!.push(e.issue)
+    }
+  }
+
+  // Column = longest dependency depth. Cycle-guarded (shouldn't happen — real
+  // gitea deps are DAG-shaped in practice — but recursion must not hang).
+  const colMemo = new Map<number, number>()
+  function colOf(id: number, visiting: Set<number>): number {
+    const cached = colMemo.get(id)
+    if (cached != null) return cached
+    if (visiting.has(id)) return 0 // cycle guard: treat as a root
+    visiting.add(id)
+    const deps = depsMap.get(id) ?? []
+    const col = deps.length === 0 ? 0 : 1 + Math.max(...deps.map((dep) => colOf(dep, visiting)))
+    visiting.delete(id)
+    colMemo.set(id, col)
+    return col
+  }
+  for (const id of participating) colOf(id, new Set())
+
+  // Row = index within column, ordered deterministically by issue number.
+  const byCol = new Map<number, number[]>()
+  for (const id of participating) {
+    const col = colMemo.get(id)!
+    if (!byCol.has(col)) byCol.set(col, [])
+    byCol.get(col)!.push(id)
+  }
+  const rowOf = new Map<number, number>()
+  for (const ids of byCol.values()) {
+    ids.sort((a, b) => a - b)
+    ids.forEach((id, i) => rowOf.set(id, i))
+  }
+
+  const maxCol = Math.max(...[...colMemo.values()])
+
+  // Critical path from the real scheduler over the open backlog.
+  const plan = schedule(toSchedulable(d.issues), d.deps)
+  const critical = new Set(plan.items.filter((i) => i.critical).map((i) => i.number))
+  const scheduledByNumber = new Map(plan.items.map((i) => [i.number, i]))
+
+  const nodes: DepNode[] = [...participating].sort((a, b) => a - b).map((id) => {
+    const issue = byNumber.get(id)!
+    const inf = inferLifecycle(issue, d.timelines[id] ?? [], d.today)
+    const scheduled = scheduledByNumber.get(id)
+    return {
+      id,
+      title: issue.title,
+      tags: issue.labels,
+      state: inf.column,
+      days: inf.steepingDays != null ? `${inf.steepingDays}d` : undefined,
+      col: colMemo.get(id)!,
+      row: rowOf.get(id)!,
+      // Reuse the scheduler's own rationale where one exists (open issues
+      // only) — never invented commentary for closed/unscheduled nodes.
+      rationale: scheduled?.rationale,
+    }
+  })
+
+  // Nearest open milestone with the most open in-scope issues.
+  const openMilestones = d.milestones.filter((m) => m.state === 'open')
+  let chosenMilestoneId: number | null = null
+  let milestone: DepsData['milestone']
+  const medianRow = median(nodes.map((n) => n.row))
+  if (openMilestones.length === 0) {
+    milestone = { name: '—', due: 'no date', col: maxCol + 1, row: medianRow }
+  } else {
+    let best: { id: number; title: string; dueOn: string | null | undefined; count: number } | null = null
+    for (const m of openMilestones) {
+      const count = [...participating].filter((id) => {
+        const issue = byNumber.get(id)!
+        return issue.milestone?.id === m.id && issue.state === 'open'
+      }).length
+      if (
+        best === null ||
+        count > best.count ||
+        (count === best.count && dueRank(m.dueOn) < dueRank(best.dueOn))
+      ) {
+        best = { id: m.id, title: m.title, dueOn: m.dueOn, count }
+      }
+    }
+    // best is non-null since openMilestones.length > 0
+    chosenMilestoneId = best!.count > 0 ? best!.id : null
+    milestone = {
+      name: best!.title,
+      due: best!.dueOn ? formatShort(new Date(best!.dueOn)) : 'no date',
+      col: maxCol + 1,
+      row: medianRow,
+    }
+  }
+
+  const edges: DepEdge[] = []
+  for (const e of d.deps) {
+    if (!participating.has(e.issue) || !participating.has(e.dependsOn)) continue
+    const crit = critical.has(e.dependsOn) && critical.has(e.issue)
+    edges.push(crit ? { from: e.dependsOn, to: e.issue, crit: true } : { from: e.dependsOn, to: e.issue })
+  }
+
+  // Terminal nodes (nothing in scope depends on them) that belong to the
+  // chosen milestone's scope get an edge into it.
+  if (chosenMilestoneId != null) {
+    for (const id of participating) {
+      const dependents = dependentsMap.get(id) ?? []
+      if (dependents.length > 0) continue
+      const issue = byNumber.get(id)!
+      if (issue.milestone?.id !== chosenMilestoneId) continue
+      edges.push(critical.has(id) ? { from: id, to: 'ms', crit: true } : { from: id, to: 'ms' })
+    }
+  }
+
+  const linked = new Set<number>()
+  for (const e of edges) {
+    linked.add(e.from)
+    if (e.to !== 'ms') linked.add(e.to)
+  }
+  const unattached = [...participating].filter((id) => !linked.has(id)).sort((a, b) => a - b)
+
+  return { nodes, milestone, edges, critical: [...critical], unattached }
+}
+
+/** Rank a due date for "nearest" comparisons; undated milestones sort last. */
+function dueRank(dueOn: string | null | undefined): number {
+  return dueOn ? new Date(dueOn).getTime() : Number.POSITIVE_INFINITY
+}

apps/desktop/src/renderer/src/lib/views/gantt-view.ts

@@ -0,0 +1,130 @@
+import { forecast, inferLifecycle, scheduleWithCapacity, workingDaysBetween } from '@commitea/core'
+
+import type { GanttData, GanttRow, GanttWeek } from '../../data/fixtures.js'
+import { addWorkingDays, formatShort } from '../dates.js'
+import type { ProjectData } from './project-data.js'
+
+/** Same 2-char scheme as backlog.ts's `initials()`; copied inline (not exported there). */
+function initials(login: string): string {
+  return login.slice(0, 2).toUpperCase()
+}
+
+/** Copy of backlog.ts's private `toSchedulable` — not exported, so mirrored here. */
+function toSchedulable(issues: ProjectData['issues']) {
+  return issues
+    .filter((i) => i.state === 'open')
+    .map((i) => ({
+      number: i.number,
+      title: i.title,
+      labels: i.labels,
+      estimateDays: i.facts.estimateDays,
+      priority: i.facts.priority,
+      assignee: i.assignee,
+    }))
+}
+
+const roundUpToWeek = (n: number): number => Math.ceil(Math.max(n, 1) / 7) * 7
+
+/**
+ * Real Gantt: the capacity-aware scheduler's lane layout over the open backlog
+ * (startDay/endDay/critical/worker) — the SAME layout the Monte Carlo forecast
+ * runs each trial on, so the bars you see match what's forecast. Plus a handful
+ * of recently-closed issues shown as already-done bars. No per-issue Monte Carlo
+ * exists at this grain, so `p80` is a rough single-issue buffer (endDay padded by
+ * half its own duration) rather than a simulated percentile — flagged below.
+ */
+export function ganttView(d: ProjectData): GanttData {
+  const plan = scheduleWithCapacity(toSchedulable(d.issues), d.deps, d.workers)
+  const issueByNumber = new Map(d.issues.map((i) => [i.number, i]))
+
+  const scheduledRows: GanttRow[] = plan.items.map((item) => {
+    const issue = issueByNumber.get(item.number)
+    const inf = issue ? inferLifecycle(issue, d.timelines[item.number] ?? [], d.today) : null
+    const state: GanttRow['state'] =
+      inf?.column === 'done' ? 'done' : inf?.column === 'steeping' ? 'steeping' : inf?.column === 'review' ? 'review' : 'scheduled'
+    return {
+      id: item.number,
+      title: item.title,
+      // The lane it actually landed on (capacity-aware) — falls back to the
+      // assignee, then blank, so an unassigned issue shows the lane doing it.
+      who: initials(item.worker ?? issue?.assignee ?? ''),
+      start: item.startDay,
+      end: item.endDay,
+      crit: item.critical,
+      state,
+      // Rough single-issue buffer (no Monte Carlo at this grain): pad the end
+      // by half its own duration as a stand-in p80.
+      p80: Math.ceil(item.endDay + (item.endDay - item.startDay) * 0.5),
+    }
+  })
+
+  // Recently-closed issues (closed within ~14 calendar days) as already-done bars.
+  const doneRows: GanttRow[] = d.issues
+    .filter((i) => {
+      if (i.state !== 'closed' || !i.closedAt) return false
+      const ageDays = (d.today.getTime() - new Date(i.closedAt).getTime()) / (24 * 60 * 60 * 1000)
+      return ageDays >= 0 && ageDays <= 14
+    })
+    .map((i) => ({
+      id: i.number,
+      title: i.title,
+      who: initials(i.assignee ?? ''),
+      start: 0,
+      end: 1,
+      state: 'done' as const,
+    }))
+
+  const rows = [...doneRows, ...scheduledRows]
+
+  // Nearest open milestone with a due date, for the horizon + `due` marker.
+  const dueCandidates = d.milestones
+    .filter((m) => m.state === 'open' && m.dueOn)
+    .map((m) => ({ m, day: Math.max(0, workingDaysBetween(d.today, new Date(m.dueOn as string))) }))
+    .sort((a, b) => a.day - b.day)
+  const nearestDue = dueCandidates[0] ?? null
+
+  const days = roundUpToWeek(Math.max(7, ...rows.map((r) => r.end), nearestDue?.day ?? 0))
+
+  const weeks: GanttWeek[] = []
+  for (let at = 0; at <= days; at += 7) {
+    weeks.push({ at, label: formatShort(addWorkingDays(d.today, at)) })
+  }
+
+  const due = nearestDue
+    ? { at: nearestDue.day, label: `${nearestDue.m.title} due` }
+    : { at: days, label: 'horizon' }
+
+  // 80% window: forecast the nearest open milestone's open scope, if any has
+  // one; otherwise fall back to a generic band over the last third of the
+  // horizon (no milestone scope to anchor it to).
+  const open = d.issues.filter((i) => i.state === 'open')
+  const milestoneWithScope = d.milestones
+    .filter((m) => m.state === 'open')
+    .map((m) => ({ m, scope: open.filter((i) => i.milestone?.id === m.id) }))
+    .filter((x) => x.scope.length > 0)
+    .sort((a, b) => {
+      const da = a.m.dueOn ? workingDaysBetween(d.today, new Date(a.m.dueOn)) : Number.POSITIVE_INFINITY
+      const db = b.m.dueOn ? workingDaysBetween(d.today, new Date(b.m.dueOn)) : Number.POSITIVE_INFINITY
+      return da - db
+    })[0]
+
+  let band: GanttData['band']
+  if (milestoneWithScope) {
+    const f = forecast(toSchedulable(milestoneWithScope.scope), d.deps, { workers: d.workers })
+    const p90 = f.curve.length ? f.curve[f.curve.length - 1].p90Day : f.p95Day
+    band = { from: Math.round(f.p50Day), to: Math.round(p90), label: '80% window' }
+  } else {
+    // No milestone with open scope to anchor a real forecast to — degrade to
+    // a generic band over the last third of the horizon.
+    band = { from: Math.round((days * 2) / 3), to: days, label: '80% window' }
+  }
+
+  return {
+    days,
+    weeks,
+    today: 0,
+    band,
+    due,
+    rows,
+  }
+}

apps/desktop/src/renderer/src/lib/views/inbox-view.ts

@@ -0,0 +1,112 @@
+import { inferLifecycle } from '@commitea/core'
+
+import type { InboxItem } from '../../data/fixtures.js'
+import type { ProjectData } from './project-data.js'
+
+const CLOSED_CAP = 5
+const TOTAL_CAP = 12
+
+/** "HH:MM" from an ISO timestamp; '—' when absent (never fabricated). */
+function hhmm(iso: string | null | undefined): string {
+  if (!iso) return '—'
+  const d = new Date(iso)
+  const hh = String(d.getHours()).padStart(2, '0')
+  const mm = String(d.getMinutes()).padStart(2, '0')
+  return `${hh}:${mm}`
+}
+
+/**
+ * Real Inbox feed: steeping nags, review-waiting issues, recently-closed
+ * issues, and closed milestones — all derived straight from the reconciled
+ * backlog + inferred lifecycle. No mentions, no outages, no people-activity:
+ * ProjectData carries none of that, so those fixture item `type`s never
+ * appear here (an honest degrade, not an oversight).
+ */
+export function inboxView(d: ProjectData): InboxItem[] {
+  const items: InboxItem[] = []
+  let id = 1
+
+  const open = d.issues.filter((i) => i.state === 'open')
+
+  // 1. Steeping nags — open issues that have sat past first-commit for 2+ working days.
+  for (const issue of open) {
+    const inf = inferLifecycle(issue, d.timelines[issue.number] ?? [], d.today)
+    if (inf.steepingDays == null || inf.steepingDays < 2) continue
+    const blocks = d.deps.filter((e) => e.dependsOn === issue.number).map((e) => e.issue)
+    items.push({
+      id: id++,
+      day: 'Today',
+      type: 'nag',
+      icon: 'clock',
+      tone: 'warn',
+      text: `#${issue.number} is steeping · ${inf.steepingDays}d`,
+      detail: blocks.length ? `blocks ${blocks.map((b) => `#${b}`).join(' and ')}` : 'worth a look',
+      time: hhmm(inf.stages.steeping),
+      unread: true,
+      issue: { id: issue.number, title: issue.title, labels: issue.labels, days: `${inf.steepingDays}d` },
+    })
+  }
+
+  // 2. Review-waiting — open issues whose lifecycle has reached the review column.
+  for (const issue of open) {
+    const inf = inferLifecycle(issue, d.timelines[issue.number] ?? [], d.today)
+    if (inf.column !== 'review') continue
+    items.push({
+      id: id++,
+      day: 'Today',
+      type: 'review',
+      icon: 'git-pull-request',
+      tone: 'info',
+      text: `#${issue.number} awaits review`,
+      detail: issue.title,
+      time: hhmm(inf.stages.review),
+      unread: true,
+      issue: { id: issue.number, title: issue.title, labels: issue.labels },
+    })
+  }
+
+  // 3. Recently shipped — closed issues, newest close first, capped.
+  const closed = d.issues
+    .filter((i) => i.state === 'closed')
+    .slice()
+    .sort((a, b) => {
+      const at = a.closedAt ? new Date(a.closedAt).getTime() : -Infinity
+      const bt = b.closedAt ? new Date(b.closedAt).getTime() : -Infinity
+      return bt - at
+    })
+    .slice(0, CLOSED_CAP)
+  for (const issue of closed) {
+    items.push({
+      id: id++,
+      day: 'Yesterday',
+      type: 'milestone',
+      icon: 'circle-check',
+      tone: 'ok',
+      text: `#${issue.number} shipped`,
+      detail: issue.title,
+      time: hhmm(issue.closedAt),
+      unread: false,
+      issue: { id: issue.number, title: issue.title, labels: issue.labels },
+    })
+  }
+
+  // 4. Milestone completion — milestones gitea reports as closed.
+  for (const m of d.milestones) {
+    if (m.state !== 'closed') continue
+    items.push({
+      id: id++,
+      day: 'Earlier',
+      type: 'milestone',
+      icon: 'milestone',
+      tone: 'ok',
+      // No milestone-close timestamp is available on GiteaMilestone, so time is
+      // left at the honest placeholder rather than borrowed from an issue.
+      text: `${m.title} closed`,
+      detail: 'milestone complete',
+      time: '—',
+      unread: false,
+    })
+  }
+
+  return items.slice(0, TOTAL_CAP)
+}

apps/desktop/src/renderer/src/lib/views/issue-detail.ts

@@ -0,0 +1,72 @@
+import {
+  forecast,
+  inferLifecycle,
+  type LifecycleStages,
+  toDurationModel,
+} from '@commitea/core'
+
+import type { IssueDetail } from '../../data/fixtures.js'
+import { addWorkingDays, formatRange, formatShort } from '../dates.js'
+import type { ProjectData } from './project-data.js'
+
+const MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
+
+/** "Feb 6 · 11:47" from an ISO timestamp; "pending" when absent. */
+function when(iso: string | undefined): string {
+  if (!iso) return 'pending'
+  const d = new Date(iso)
+  const hh = String(d.getHours()).padStart(2, '0')
+  const mm = String(d.getMinutes()).padStart(2, '0')
+  return `${MONTHS[d.getMonth()]} ${d.getDate()} · ${hh}:${mm}`
+}
+
+function lifecycle(stages: LifecycleStages): IssueDetail['lifecycle'] {
+  return [
+    { stage: 'Diagnosis', event: 'issue opened', when: when(stages.opened), icon: 'circle-dot', done: true },
+    { stage: 'Triage', event: 'labeled / milestoned', when: when(stages.triaged), icon: 'tag', done: !!stages.triaged },
+    { stage: 'Work start', event: 'first commit ref', when: when(stages.steeping), icon: 'git-commit-horizontal', done: !!stages.steeping },
+    { stage: 'In review', event: 'PR referenced', when: when(stages.review), icon: 'git-merge', done: !!stages.review },
+    { stage: 'Complete', event: 'issue closed', when: when(stages.done), icon: 'circle-check', done: !!stages.done },
+  ]
+}
+
+/**
+ * Real Issue-detail sidecar: lifecycle timeline (from event inference), a
+ * single-issue forecast range, and the real dependency edges. Returns null for
+ * an unknown id → the screen shows the demo fixture. Comments aren't reconciled,
+ * so they stay empty (the screen degrades gracefully).
+ */
+export function issueDetailView(id: number, d: ProjectData): IssueDetail | null {
+  const issue = d.issues.find((i) => i.number === id)
+  if (!issue) return null
+  const inf = inferLifecycle(issue, d.timelines[id] ?? [], d.today)
+  const blockedBy = d.deps.filter((e) => e.issue === id).map((e) => e.dependsOn)
+  const blocks = d.deps.filter((e) => e.dependsOn === id).map((e) => e.issue)
+
+  let forecastLine = { p80: 'closed', note: 'shipped' }
+  if (issue.state === 'open') {
+    const f = forecast(
+      [{ number: id, title: issue.title, labels: issue.labels, estimateDays: issue.facts.estimateDays, priority: issue.facts.priority, assignee: issue.assignee }],
+      [],
+      { ...(d.calibration ? { model: toDurationModel(d.calibration) } : {}), workers: d.workers },
+    )
+    const p90 = f.curve.length ? f.curve[f.curve.length - 1].p90Day : f.p95Day
+    forecastLine = {
+      p80: `done ${formatRange(addWorkingDays(d.today, f.p50Day), addWorkingDays(d.today, p90))}`,
+      note: d.calibration && !d.calibration.coldStart ? `from your history · n=${d.calibration.n}` : 'cold-start priors',
+    }
+  }
+
+  return {
+    state: inf.column === 'review' ? 'review' : inf.column,
+    assignee: issue.assignee ?? 'unassigned',
+    milestone: issue.milestone?.title ?? '—',
+    body: issue.body,
+    comments: [],
+    lifecycle: lifecycle(inf.stages),
+    forecast: forecastLine,
+    blocks,
+    blockedBy,
+    note: inf.steepingDays != null ? `Steeping ${inf.steepingDays}d.${blocks.length ? ` Blocks ${blocks.map((b) => `#${b}`).join(', ')}.` : ''}` : '',
+  }
+}

apps/desktop/src/renderer/src/lib/views/project-data.ts

@@ -0,0 +1,17 @@
+import type { CalibrationModel, DependencyEdge, GiteaIssue, GiteaMilestone, LifecycleEvent, Worker } from '@commitea/core'
+
+/**
+ * The reconciled backlog + derived config that every real-data view builder
+ * consumes. AppShell assembles it once from the backlog + capacity, so each
+ * screen's builder gets a uniform input. `calibration`/`workers` are optional —
+ * views degrade to cold-start / single-worker when absent.
+ */
+export interface ProjectData {
+  issues: GiteaIssue[]
+  milestones: GiteaMilestone[]
+  deps: DependencyEdge[]
+  timelines: Record<number, LifecycleEvent[]>
+  calibration?: CalibrationModel
+  workers: Worker[]
+  today: Date
+}

apps/desktop/src/renderer/src/lib/views/standup-view.ts

@@ -0,0 +1,157 @@
+import {
+  type DependencyEdge,
+  type GiteaIssue,
+  inferLifecycle,
+  schedule,
+  type ScheduledItem,
+} from '@commitea/core'
+
+import type { DriftItem, Nag, PlanItem, StandupData } from '../../data/fixtures.js'
+import type { ProjectData } from './project-data.js'
+
+/** Same shape as backlog.ts's private toSchedulable — not exported there, so copied inline. */
+function toSchedulable(issues: GiteaIssue[]) {
+  return issues
+    .filter((i) => i.state === 'open')
+    .map((i) => ({
+      number: i.number,
+      title: i.title,
+      labels: i.labels,
+      estimateDays: i.facts.estimateDays,
+      priority: i.facts.priority,
+      assignee: i.assignee,
+    }))
+}
+
+function whyFor(item: ScheduledItem): string {
+  if (item.critical) return 'On the critical path.'
+  if (item.blocks.length) return `Blocks ${item.blocks.map((b) => `#${b}`).join(', ')}.`
+  return 'Next by dependency + priority order.'
+}
+
+/**
+ * Top scheduled pick per distinct assignee. Iterates the (already dependency-
+ * + priority-ordered) plan once, keeping the first item seen per assignee —
+ * that's their earliest-starting pick since the v0 scheduler lays out a single
+ * serial lane (order ascending ⇒ startDay ascending). Ordered by `d.workers`
+ * when present (assignees absent from the roster are appended after the named
+ * workers; unassigned work last), else by discovery order. Capped at 4 people.
+ */
+function buildPlan(d: ProjectData, open: GiteaIssue[], items: ScheduledItem[]): PlanItem[] {
+  const assigneeByNumber = new Map(open.map((i) => [i.number, i.assignee]))
+  const firstPickByPerson = new Map<string, ScheduledItem>()
+  for (const item of items) {
+    const key = assigneeByNumber.get(item.number) ?? 'Unassigned'
+    if (!firstPickByPerson.has(key)) firstPickByPerson.set(key, item)
+  }
+
+  let order: string[]
+  if (d.workers.length) {
+    const workerOrder = d.workers.map((w) => w.person)
+    const known = workerOrder.filter((p) => firstPickByPerson.has(p))
+    const extra = [...firstPickByPerson.keys()].filter((k) => k !== 'Unassigned' && !workerOrder.includes(k))
+    order = [...known, ...extra]
+    if (firstPickByPerson.has('Unassigned')) order.push('Unassigned')
+  } else {
+    order = [...firstPickByPerson.keys()]
+  }
+
+  return order.slice(0, 4).map((who) => {
+    const item = firstPickByPerson.get(who)!
+    return { who, pick: `#${item.number}`, title: item.title, why: whyFor(item) }
+  })
+}
+
+/**
+ * The single longest-steeping open issue (inferLifecycle's steepingDays, whole
+ * working days since first commit ref). `blocks` comes from the scheduler's
+ * in-scope dependents of that same issue. Falls back to a calm, honest nag
+ * when nothing is currently steeping.
+ */
+function buildNag(d: ProjectData, open: GiteaIssue[], items: ScheduledItem[]): Nag {
+  let worst: { issue: GiteaIssue; days: number } | null = null
+  for (const issue of open) {
+    const inf = inferLifecycle(issue, d.timelines[issue.number] ?? [], d.today)
+    if (inf.steepingDays != null && (worst == null || inf.steepingDays > worst.days)) {
+      worst = { issue, days: inf.steepingDays }
+    }
+  }
+  if (!worst) {
+    return { id: 0, days: '0d', blocks: [], text: 'Nothing is over-steeping. The pot is calm.' }
+  }
+
+  const scheduled = items.find((it) => it.number === worst!.issue.number)
+  const blocks = (scheduled?.blocks ?? []).map((n) => `#${n}`)
+  const days = `${worst.days}d`
+  return {
+    id: worst.issue.number,
+    days,
+    blocks,
+    text: `${days} steeping. ${blocks.length ? `Blocks ${blocks.join(', ')}.` : 'Worth a look.'}`,
+  }
+}
+
+/**
+ * Honest drift signals only — ProjectData carries no notification/webhook
+ * stream, so drift is limited to what lifecycle inference can actually see:
+ * open issues sitting in review (age isn't measurable from the data we have,
+ * so every review-column issue is flagged rather than fabricating a duration)
+ * and open issues steeping past their own estimate. Sorted most-severe first
+ * (steeping overage ranks by days over estimate; review-sitting is a flat,
+ * lower severity since it has no measured age) and capped at 4.
+ */
+function buildDrift(d: ProjectData, open: GiteaIssue[]): DriftItem[] {
+  const candidates: (DriftItem & { severity: number })[] = []
+  for (const issue of open) {
+    const inf = inferLifecycle(issue, d.timelines[issue.number] ?? [], d.today)
+    if (inf.column === 'review') {
+      candidates.push({
+        tone: 'warn',
+        text: `#${issue.number} ${issue.title} is sitting in review.`,
+        delta: 'idle in review',
+        severity: 1,
+      })
+    }
+    if (inf.steepingDays != null) {
+      const est = issue.facts.estimateDays ?? 2
+      if (inf.steepingDays > est) {
+        candidates.push({
+          tone: 'warn',
+          text: `#${issue.number} ${issue.title} has steeped past its estimate.`,
+          delta: `${inf.steepingDays}d vs ${est}d est`,
+          severity: inf.steepingDays - est + 1,
+        })
+      }
+    }
+  }
+  return candidates
+    .sort((a, b) => b.severity - a.severity)
+    .slice(0, 4)
+    .map(({ tone, text, delta }) => ({ tone, text, delta }))
+}
+
+/**
+ * Morning-standup sidecar: per-person top pick from the deterministic
+ * scheduler, the single longest-steeping issue as the day's nag, and drift
+ * limited to real lifecycle anomalies (review-sitting, steeping-past-estimate).
+ * Never throws — an empty/cold backlog degrades to an empty plan, empty drift,
+ * and a calm nag.
+ */
+export function standupView(d: ProjectData): StandupData {
+  const date = d.today.toLocaleDateString('en-GB', {
+    weekday: 'long',
+    day: 'numeric',
+    month: 'long',
+    year: 'numeric',
+  })
+  const open = d.issues.filter((i) => i.state === 'open')
+  const deps: DependencyEdge[] = d.deps
+  const { items } = schedule(toSchedulable(open), deps)
+
+  return {
+    date,
+    plan: buildPlan(d, open, items),
+    nag: buildNag(d, open, items),
+    drift: buildDrift(d, open),
+  }
+}

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/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
- * (milestone / runway / standup / search) return a `notImplemented` marker so
- * the model degrades honestly instead of inventing data.
+ * Serves focus / board / calibration / issue / search / standup. The remaining
+ * views (milestone / runway) return a `notImplemented` marker so the model
+ * 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-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/calibration/calibration-v0.test.ts

@@ -5,6 +5,7 @@ import type { LifecycleEvent } from '../lifecycle/lifecycle-v0.js'
 import type { GiteaIssue } from '../gitea/types.js'
 import {
   CALIBRATION_BUCKET_FLOOR,
+  calibrationCoverage,
   calibrationSamples,
   type CalibrationSample,
   COLD_START_THRESHOLD,
@@ -118,4 +119,26 @@ describe('calibrationSamples', () => {
     const noEst = issue({ number: 9, labels: [] })
     expect(calibrationSamples([open, noEst], { ...events(8), ...events(9) }, asOf)).toEqual([])
   })
+
+  it('coverage counts same-day closes as excluded candidates, not as "more closes needed"', () => {
+    // usable: commit Wed 01-07 → close Mon 01-12 = 3 working days
+    const usable = issue({ number: 7, labels: ['est/2d'] })
+    // same-day close: commit and close on the same day = 0 working days → excluded
+    const sameDay = issue({ number: 10, labels: ['est/2d'], createdAt: '2026-01-12T08:00:00Z' })
+    const sameDayEvents = {
+      10: [
+        { type: 'commit', at: '2026-01-12T09:00:00Z' } as LifecycleEvent,
+        { type: 'close', at: '2026-01-12T17:00:00Z' } as LifecycleEvent,
+      ],
+    }
+    const open = issue({ number: 8, state: 'open', labels: ['est/2d'], closedAt: null })
+    const noEst = issue({ number: 9, labels: [] })
+
+    const cov = calibrationCoverage([usable, sameDay, open, noEst], { ...events(7), ...sameDayEvents }, asOf)
+    expect(cov.candidates).toBe(2) // closed + estimated only (usable + sameDay)
+    expect(cov.usable).toBe(1)
+    expect(cov.excludedSameDay).toBe(1)
+    // the honest denominator: usable matches the model's n
+    expect(cov.usable).toBe(calibrationSamples([usable, sameDay, open, noEst], { ...events(7), ...sameDayEvents }, asOf).length)
+  })
 })

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

@@ -125,3 +125,40 @@ export function calibrationSamples(
   }
   return out
 }
+
+/** How the closed+estimated backlog splits into usable samples vs. what can't calibrate. */
+export interface CalibrationCoverage {
+  /** Closed issues carrying an estimate — the calibration candidates. */
+  candidates: number
+  /** Candidates that yielded a usable actual (> 0 working days) → become samples. */
+  usable: number
+  /**
+   * Candidates excluded because the issue closed with 0 working days (same-day
+   * close) or no resolvable actual — real closes that structurally can't
+   * calibrate. Counting them keeps `usable/threshold` honest: it's not "N more
+   * closes away" if some of your closes will never count.
+   */
+  excludedSameDay: number
+}
+
+/**
+ * Coverage of the calibration candidates — how many closed+estimated issues are
+ * usable vs. silently unusable (same-day / 0-day closes). {@link calibrationSamples}
+ * drops the latter; this counts them so the UI can say *why* the sample is thin.
+ */
+export function calibrationCoverage(
+  issues: GiteaIssue[],
+  timelines: Record<number, LifecycleEvent[]>,
+  asOf: Date,
+): CalibrationCoverage {
+  let candidates = 0
+  let usable = 0
+  for (const issue of issues) {
+    if (issue.state !== 'closed') continue
+    if (issue.facts.estimateDays == null) continue
+    candidates++
+    const inf = inferLifecycle(issue, timelines[issue.number] ?? [], asOf)
+    if (inf.actualWorkingDays != null && inf.actualWorkingDays > 0) usable++
+  }
+  return { candidates, usable, excludedSameDay: candidates - usable }
+}

packages/core/src/index.ts

@@ -23,6 +23,8 @@ 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 { describeChange, isLabelChange, planIssueChange, proposalsFor, summarizeChange } from './changes/apply-changes-v0.js'
 export type {
   ChangeProposal,
@@ -80,6 +82,7 @@ export type {
 
 export {
   CALIBRATION_BUCKET_FLOOR,
+  calibrationCoverage,
   calibrationSamples,
   COLD_START_THRESHOLD,
   fitCalibration,
@@ -87,6 +90,7 @@ export {
 } from './calibration/calibration-v0.js'
 export type {
   BucketFit,
+  CalibrationCoverage,
   CalibrationModel,
   CalibrationSample,
   PersonBias,