test: verify record_directive end-to-end + label the ledger in the activity line

The pm-state repo now exists, so the last unverified path is proven: Reginald
records a directive to the real ledger.

- chat panel: the "consulted" activity line names record_directive as "the
  directive ledger" (matching query_project → the project, propose_change → the labels).
- live-directive e2e (gated): a directive typed in chat → Reginald logs it and
  says "recorded", consulting the directive ledger.

Verified live against gemma-4-26b + the commitea-pm-state repo: "freeze scope for
beta, pilots come first" appended to directives/log.jsonl as
{kind: scope, quote: <verbatim>, status: accepted} — logged, never claimed applied.
Reginald is now complete and every tool is verified end-to-end.

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

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

@@ -16,9 +16,13 @@ test.describe('live backlog', () => {
     await win.waitForLoadState('domcontentloaded')
     const rail = win.getByRole('navigation', { name: 'Primary' })
 
-    // The pot — waiting here also lets the reconcile (issues + deps) complete
+    // The pot — waiting here also lets the reconcile (issues + deps + timelines) complete
     await rail.getByRole('button', { name: 'The pot' }).click()
     await expect(win.getByText('Gitea read client behind an injected fetch')).toBeVisible({ timeout: 20000 })
+    // Lifecycle inference (#5): columns come from the real event stream — merged
+    // work lands in Done, so that column is non-empty (proves timelines drove it,
+    // not the three-column fallback which would still show closed issues in Done).
+    await expect(win.getByText('Done', { exact: true })).toBeVisible()
     await win.screenshot({ path: join(here, '.artifacts', 'screens', 'live-board.png'), fullPage: true, animations: 'disabled' })
 
     // Back to Focus — the deterministic scheduler's real Now/Next/Later. These
@@ -30,6 +34,32 @@ test.describe('live backlog', () => {
     await expect(win.getByText(/Cold-start priors/)).toBeVisible()
     await win.screenshot({ path: join(here, '.artifacts', 'screens', 'live-focus.png'), fullPage: true, animations: 'disabled' })
 
+    // Runway → calibration surface, fitted from real closed-issue actuals (#1).
+    // With <20 estimated closes the repo is honestly cold-start; the note proves
+    // the fit ran on real data, not the fixture's "calibrated on 27".
+    await rail.getByRole('button', { name: 'Runway' }).click()
+    await expect(
+      win.getByText(/cold-start priors · \d+\/20 closed issues estimated|calibrated on \d+ closed/),
+    ).toBeVisible()
+    await win.getByRole('button', { name: 'Full report' }).click()
+    await expect(win.getByText(/cold-start · \d+\/20|curve active · n ≥ 20/)).toBeVisible()
+    await win.screenshot({ path: join(here, '.artifacts', 'screens', 'live-calibration.png'), fullPage: true, animations: 'disabled' })
+
+    // Write path (apply_changes): open the top scheduled issue, propose an
+    // estimate change, and confirm the propose-approve diff renders — then CANCEL
+    // so the live run never mutates the real repo (the PUT is unit-tested; a
+    // one-off change→revert verified it against gitea manually).
+    await rail.getByRole('button', { name: 'Morning service' }).click()
+    await win.getByRole('main').getByRole('link').first().click()
+    await expect(win.getByText(/· stephen\/commitea/)).toBeVisible()
+    await win.getByRole('button', { name: 'Adjust' }).click()
+    await expect(win.getByText('Adjust estimate & priority')).toBeVisible()
+    await win.getByRole('combobox').first().selectOption('est/8d')
+    await expect(win.getByText('Proposed label change')).toBeVisible()
+    await expect(win.getByText(/est\/8d/).last()).toBeVisible()
+    await win.screenshot({ path: join(here, '.artifacts', 'screens', 'live-apply-change.png'), fullPage: true, animations: 'disabled' })
+    await win.getByRole('button', { name: 'Cancel' }).click() // no mutation
+
     await app.close()
   })
 })

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

@@ -0,0 +1,37 @@
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+import { _electron as electron, expect, test } from '@playwright/test'
+
+const here = dirname(fileURLToPath(import.meta.url))
+const MAIN = join(here, '..', 'out', 'main', 'index.js')
+
+// Opt-in (GITEA_LIVE=1 + COMMITEA_MODEL_LIVE=1 + a local model on :1234). Launches
+// WITHOUT COMMITEA_E2E so capture_work runs the real decomposition. It Discards at
+// the end so the run never files junk issues (the create-issue POST is unit-tested).
+test.describe('live capture_work', () => {
+  test('decomposes a braindump into a reviewable ticket set', async () => {
+    test.skip(!process.env.GITEA_LIVE || !process.env.COMMITEA_MODEL_LIVE, 'live model test — opt-in')
+    test.setTimeout(300_000)
+    const app = await electron.launch({ args: [MAIN], env: { ...process.env } })
+    const win = await app.firstWindow()
+    await win.waitForLoadState('domcontentloaded')
+    const rail = win.getByRole('navigation', { name: 'Primary' })
+
+    await rail.getByRole('button', { name: 'Capture' }).click()
+    await expect(win.getByRole('heading', { name: 'Capture' })).toBeVisible()
+    // the braindump is prefilled; run the real decomposition
+    await win.getByRole('button', { name: 'Brew tickets' }).click()
+
+    // capture_work → the review tray with a real, estimated ticket set
+    await expect(win.getByText(/tickets · ~\d+d of work/)).toBeVisible({ timeout: 240_000 })
+    await expect(win.getByRole('button', { name: 'Approve all' })).toBeVisible()
+    await win.screenshot({ path: join(here, '.artifacts', 'screens', 'live-capture.png'), fullPage: true, animations: 'disabled' })
+
+    // Discard — never file junk issues into the real repo from a test
+    await win.getByRole('button', { name: 'Discard' }).click()
+    await expect(win.getByRole('button', { name: 'Brew tickets' })).toBeVisible()
+
+    await app.close()
+  })
+})

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

@@ -0,0 +1,32 @@
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+import { _electron as electron, expect, test } from '@playwright/test'
+
+const here = dirname(fileURLToPath(import.meta.url))
+const MAIN = join(here, '..', 'out', 'main', 'index.js')
+
+// Opt-in (GITEA_LIVE=1 + COMMITEA_MODEL_LIVE=1 + a local model + the commitea-pm-state
+// repo). Reginald records a standing directive; it's appended to the real pm-state
+// ledger. The append is idempotent-ish (a fresh line each run); this only reads back
+// that a directive was consulted, and leaves the ledger intact.
+test.describe('live record_directive', () => {
+  test('logs a standing directive to the pm-state ledger', async () => {
+    test.skip(!process.env.GITEA_LIVE || !process.env.COMMITEA_MODEL_LIVE, 'live model test — opt-in')
+    test.setTimeout(300_000)
+    const app = await electron.launch({ args: [MAIN], env: { ...process.env } })
+    const win = await app.firstWindow()
+    await win.waitForLoadState('domcontentloaded')
+    await expect(win.getByText(/· local$/)).toBeVisible({ timeout: 20000 })
+
+    const composer = win.getByPlaceholder(/Tell me what to do/)
+    await composer.fill('Record a standing directive: freeze scope for beta, pilots come first.')
+    await composer.press('Enter')
+
+    // the agent logged it to the ledger (record_directive), not applied a change
+    await expect(win.getByText(/consulted the directive ledger/)).toBeVisible({ timeout: 240_000 })
+    await win.screenshot({ path: join(here, '.artifacts', 'screens', 'live-directive.png'), fullPage: true, animations: 'disabled' })
+
+    await app.close()
+  })
+})

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

@@ -0,0 +1,56 @@
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+import { _electron as electron, expect, test } from '@playwright/test'
+
+const here = dirname(fileURLToPath(import.meta.url))
+const MAIN = join(here, '..', 'out', 'main', 'index.js')
+
+// Opt-in (GITEA_LIVE=1 + COMMITEA_MODEL_LIVE=1 + a local model on :1234). Launches
+// WITHOUT COMMITEA_E2E so Reginald runs the real agent loop against the real repo.
+test.describe('live Reginald', () => {
+  test('answers a question by consulting the real project', async () => {
+    test.skip(!process.env.GITEA_LIVE || !process.env.COMMITEA_MODEL_LIVE, 'live model test — opt-in')
+    test.setTimeout(300_000) // a big local model is slow: ~2 calls/turn + a reconcile
+    const app = await electron.launch({ args: [MAIN], env: { ...process.env } })
+    const win = await app.firstWindow()
+    await win.waitForLoadState('domcontentloaded')
+
+    // model configured → the live greeting + header (the loaded model, not the scripted demo)
+    await expect(win.getByText(/· local$/)).toBeVisible({ timeout: 20000 })
+    await expect(win.getByText(/I check the real board before I answer/)).toBeVisible()
+
+    const composer = win.getByPlaceholder(/Tell me what to do/)
+    await composer.fill('What should I work on right now?')
+    await composer.press('Enter')
+
+    // the agent loop ran end-to-end: it consulted the project, then answered
+    await expect(win.getByText(/consulted the project/)).toBeVisible({ timeout: 240_000 })
+    await win.screenshot({ path: join(here, '.artifacts', 'screens', 'live-reginald.png'), fullPage: true, animations: 'disabled' })
+
+    await app.close()
+  })
+
+  test('proposes an estimate change for inline approval (writes via chat)', async () => {
+    test.skip(!process.env.GITEA_LIVE || !process.env.COMMITEA_MODEL_LIVE, 'live model test — opt-in')
+    test.setTimeout(300_000)
+    const app = await electron.launch({ args: [MAIN], env: { ...process.env } })
+    const win = await app.firstWindow()
+    await win.waitForLoadState('domcontentloaded')
+    await expect(win.getByText(/· local$/)).toBeVisible({ timeout: 20000 })
+
+    const composer = win.getByPlaceholder(/Tell me what to do/)
+    await composer.fill('Set the estimate on issue #3 to est/5d.')
+    await composer.press('Enter')
+
+    // propose_change → an inline propose-approve card (never an auto-write)
+    await expect(win.getByText('Proposed · #3')).toBeVisible({ timeout: 240_000 })
+    await expect(win.getByText(/→ est\/5d/)).toBeVisible()
+    await win.screenshot({ path: join(here, '.artifacts', 'screens', 'live-reginald-propose.png'), fullPage: true, animations: 'disabled' })
+    // Dismiss so the live run never mutates the repo (the write path itself is #41-tested)
+    await win.getByRole('button', { name: 'Dismiss' }).click()
+    await expect(win.getByText(/Left #3 as it was/)).toBeVisible()
+
+    await app.close()
+  })
+})

apps/desktop/src/main/gitea.ts

@@ -6,10 +6,25 @@
  * properly later.
  */
 
+import { randomUUID } from 'node:crypto'
 import { readFileSync } from 'node:fs'
 import { dirname, join } from 'node:path'
 
-import { createGiteaClient, type GiteaConfig } from '@commitea/core'
+import {
+  appendDirective,
+  createGiteaClient,
+  type DirectiveEntry,
+  type GiteaClient,
+  type GiteaConfig,
+  type GiteaLabel,
+  type IssueChange,
+  type LifecycleEvent,
+  makeDirectiveEntry,
+  parseDirectiveLog,
+  planIssueChange,
+  type ProjectSnapshot,
+  type DirectiveInput,
+} from '@commitea/core'
 import { ipcMain } from 'electron'
 
 /** Walk up from cwd looking for a .env.local with a GITEA_TOKEN (dev convenience). */
@@ -43,15 +58,59 @@ function resolveConfig(): GiteaConfig | null {
   }
 }
 
-export function registerGiteaIpc(): void {
+// Memoized client so both the gitea and model bridges share one instance.
+let sharedClient: GiteaClient | null | undefined
+export function getGiteaClient(): GiteaClient | null {
+  if (sharedClient === undefined) {
     const config = resolveConfig()
-  const client = config ? createGiteaClient(config, fetch) : null
+    sharedClient = config ? createGiteaClient(config, fetch) : null
-  const repo = config ? `${config.owner}/${config.repo}` : null
+  }
+  return sharedClient
+}
 
-  ipcMain.handle('gitea:status', () => ({ configured: !!config, repo }))
+// The pm-state repo holds machine-derived state (the directive ledger). Same
+// token/host as the work repo, a different repo (the purity split, decisions D4).
+let pmStateClient: GiteaClient | null | undefined
+export function getPmStateClient(): GiteaClient | null {
+  if (pmStateClient === undefined) {
+    const config = resolveConfig()
+    pmStateClient = config
+      ? createGiteaClient({ ...config, repo: process.env.COMMITEA_PMSTATE_REPO ?? 'commitea-pm-state' }, fetch)
+      : null
+  }
+  return pmStateClient
+}
 
-  ipcMain.handle('gitea:reconcile', async () => {
+const DIRECTIVE_LOG_PATH = 'directives/log.jsonl'
-    if (!client) return { configured: false, issues: [], milestones: [], deps: [] }
+
+async function readDirectiveLog(client: GiteaClient): Promise<{ text: string; sha: string | null }> {
+  const file = await client.getFile(DIRECTIVE_LOG_PATH)
+  if (!file) return { text: '', sha: null }
+  return { text: Buffer.from(file.contentBase64, 'base64').toString('utf8'), sha: file.sha }
+}
+
+/** Record a directive: read the ledger, append, write it back (concatenation merge). */
+export async function appendDirectiveEntry(client: GiteaClient, input: DirectiveInput): Promise<DirectiveEntry> {
+  const entry = makeDirectiveEntry(input, randomUUID(), new Date().toISOString())
+  const { text, sha } = await readDirectiveLog(client)
+  const next = appendDirective(text, entry)
+  await client.putFile(DIRECTIVE_LOG_PATH, {
+    contentBase64: Buffer.from(next, 'utf8').toString('base64'),
+    message: `directive: ${entry.kind}`,
+    sha: sha ?? undefined,
+  })
+  return entry
+}
+
+export async function readDirectives(client: GiteaClient) {
+  const { text } = await readDirectiveLog(client)
+  return parseDirectiveLog(text)
+}
+
+/** Full reconcile: issues + milestones + native deps + lifecycle timelines. */
+export async function reconcileSnapshot(
+  client: GiteaClient,
+): Promise<ProjectSnapshot & { milestones: Awaited<ReturnType<GiteaClient['listMilestones']>> }> {
   const [issues, milestones] = await Promise.all([client.listIssues(), client.listMilestones()])
   // dependency edges among the open scope (the scheduler only plans what's left)
   const open = issues.filter((i) => i.state === 'open')
@@ -59,11 +118,83 @@ export function registerGiteaIpc(): void {
     open.map(async (i) => ({ issue: i.number, dependsOn: await client.getIssueDependencies(i.number) })),
   )
   const deps = perIssue.flatMap(({ issue, dependsOn }) => dependsOn.map((d) => ({ issue, dependsOn: d })))
-    return { configured: true, issues, milestones, deps }
+  // lifecycle timelines for every issue (open → columns/badges, closed → calibration actuals)
+  const timelineEntries = await Promise.all(
+    issues.map(async (i) => [i.number, await client.getIssueTimeline(i.number)] as const),
+  )
+  const timelines: Record<number, LifecycleEvent[]> = Object.fromEntries(timelineEntries)
+  return { issues, milestones, deps, timelines }
+}
+
+export function registerGiteaIpc(): void {
+  const client = getGiteaClient()
+  const repo = client ? `${process.env.GITEA_OWNER ?? 'christian'}/${process.env.GITEA_REPO ?? 'commitea'}` : null
+
+  ipcMain.handle('gitea:status', () => ({ configured: !!client, repo }))
+
+  ipcMain.handle('gitea:reconcile', async () => {
+    if (!client) return { configured: false, issues: [], milestones: [], deps: [], timelines: {} }
+    const snap = await reconcileSnapshot(client)
+    return { configured: true, ...snap }
   })
 
   ipcMain.handle('gitea:getIssue', async (_event, index: number) => {
     if (!client) return null
     return client.getIssue(index)
   })
+
+  // Cached label list for name→id resolution; refreshed on demand if a name misses.
+  let labelCache: GiteaLabel[] | null = null
+  async function resolveLabelIds(names: string[]): Promise<number[]> {
+    if (!client) return []
+    const lookup = () => new Map(labelCache!.map((l) => [l.name, l.id]))
+    if (!labelCache) labelCache = await client.listLabels()
+    let byName = lookup()
+    if (names.some((n) => !byName.has(n))) {
+      labelCache = await client.listLabels() // a name we don't know — refetch once
+      byName = lookup()
+    }
+    return names.map((n) => byName.get(n)).filter((id): id is number => id != null)
+  }
+
+  // The write path (apply_changes). Additive label swaps, applied only after the
+  // renderer's propose-approve. Returns the plan + the freshly-read issue.
+  ipcMain.handle('gitea:applyChange', async (_event, change: IssueChange) => {
+    if (!client) return { ok: false as const, reason: 'unconfigured' as const }
+    const current = await client.getIssue(change.issue)
+    const plan = planIssueChange(current.labels, change)
+    if (plan.noop) return { ok: true as const, plan, issue: current }
+    const ids = await resolveLabelIds(plan.labels)
+    await client.setIssueLabels(change.issue, ids)
+    const issue = await client.getIssue(change.issue)
+    return { ok: true as const, plan, issue }
+  })
+
+  // capture_work filing: open each approved issue with its est/* + p/* labels.
+  // Only touches the CommiTea label namespaces — no invented labels (zero-pollution).
+  ipcMain.handle(
+    'gitea:createIssues',
+    async (_event, issues: { title: string; body?: string; estimate?: string; priority?: string }[]) => {
+      if (!client) return { ok: false as const, reason: 'unconfigured' as const }
+      const created: { number: number; title: string }[] = []
+      for (const it of issues) {
+        const names = [it.estimate, it.priority].filter((n): n is string => !!n)
+        const labelIds = await resolveLabelIds(names)
+        const issue = await client.createIssue({ title: it.title, body: it.body, labelIds })
+        created.push({ number: issue.number, title: issue.title })
+      }
+      return { ok: true as const, created }
+    },
+  )
+
+  // Read the directive ledger from the pm-state repo (for the Directives screen).
+  ipcMain.handle('pmstate:directives', async () => {
+    const pm = getPmStateClient()
+    if (!pm) return { ok: false as const, reason: 'unconfigured' as const }
+    try {
+      return { ok: true as const, directives: await readDirectives(pm) }
+    } catch (e) {
+      return { ok: false as const, reason: 'error' as const, message: e instanceof Error ? e.message : String(e) }
+    }
+  })
 }

apps/desktop/src/main/index.ts

@@ -3,6 +3,7 @@ import { join } from 'node:path'
 import { BrowserWindow, app, shell } from 'electron'
 
 import { registerGiteaIpc } from './gitea.js'
+import { registerModelIpc } from './model.js'
 
 function createWindow(): void {
   const win = new BrowserWindow({
@@ -35,6 +36,7 @@ function createWindow(): void {
 
 void app.whenReady().then(() => {
   registerGiteaIpc()
+  registerModelIpc()
   createWindow()
 
   app.on('activate', () => {

apps/desktop/src/main/model.ts

@@ -0,0 +1,150 @@
+/**
+ * Main-process model bridge — Reginald's brain runs here. Model traffic (like
+ * gitea's) stays in main: the renderer is CSP-locked and never talks to the
+ * LLM directly. On `model:chat` it drives the agent loop against the configured
+ * OpenAI-compatible endpoint, executing `query_project` by reconciling the repo
+ * and building the requested view. v0 is read-only — writes still go through the
+ * propose-approve controls.
+ */
+
+import {
+  buildProjectView,
+  captureWork,
+  type ChangeProposal,
+  type ChatMessage,
+  createChatClient,
+  describeChange,
+  type ModelRouter,
+  type ProjectView,
+  proposalsFor,
+  type ProposeChangeArgs,
+  type QueryFilters,
+  REGINALD_SYSTEM,
+  REGINALD_TOOLS,
+  runAgentTurn,
+  toDirectiveInput,
+} from '@commitea/core'
+import { ipcMain } from 'electron'
+
+import { appendDirectiveEntry, getGiteaClient, getPmStateClient, reconcileSnapshot } from './gitea.js'
+
+/** Small local model for prose + the read tool; big model reserved for later decomposition. */
+function resolveModelRouter(): ModelRouter | null {
+  if (process.env.COMMITEA_E2E === '1') return null // e2e uses the scripted fixture Reginald
+  const baseUrl = process.env.COMMITEA_MODEL_URL ?? 'http://localhost:1234/v1'
+  if (!baseUrl) return null
+  return {
+    small: { baseUrl, model: process.env.COMMITEA_MODEL_SMALL ?? '' },
+    big: { baseUrl, model: process.env.COMMITEA_MODEL_BIG ?? '' },
+  }
+}
+
+/**
+ * Resolve which model to actually ask for. An explicit env override wins;
+ * otherwise ask the server which model is *loaded* (LM Studio's native
+ * `/api/v0/models`) so Reginald follows whatever you load — no config churn on a
+ * model switch. Falls back to the first non-embedding model, then a sane default.
+ */
+async function resolveLoadedModel(baseUrl: string, override: string): Promise<string> {
+  if (override) return override
+  const root = baseUrl.replace(/\/v1\/?$/, '')
+  try {
+    const res = await fetch(`${root}/api/v0/models`)
+    if (res.ok) {
+      const data = (await res.json()) as { data?: { id: string; state?: string; type?: string }[] }
+      const loaded = (data.data ?? []).find((m) => m.state === 'loaded' && m.type !== 'embeddings')
+      if (loaded) return loaded.id
+    }
+  } catch {
+    // native API unavailable — fall through to the OpenAI listing
+  }
+  try {
+    const res = await fetch(`${baseUrl.replace(/\/+$/, '')}/models`)
+    if (res.ok) {
+      const data = (await res.json()) as { data?: { id: string }[] }
+      const first = (data.data ?? []).find((m) => !/embed/i.test(m.id))
+      if (first) return first.id
+    }
+  } catch {
+    // ignore — use the default
+  }
+  return 'google/gemma-4-e4b'
+}
+
+export function registerModelIpc(): void {
+  const router = resolveModelRouter()
+
+  ipcMain.handle('model:status', async () => {
+    if (!router) return { configured: false, model: null }
+    const model = await resolveLoadedModel(router.small.baseUrl, router.small.model)
+    return { configured: true, model }
+  })
+
+  ipcMain.handle('model:chat', async (_event, messages: ChatMessage[]) => {
+    if (!router) return { ok: false as const, reason: 'unconfigured' as const }
+    const client = getGiteaClient()
+    const model = await resolveLoadedModel(router.small.baseUrl, router.small.model)
+    const chat = createChatClient({ ...router.small, model }, fetch)
+
+    // Proposals the model formulates this turn; the renderer approves them (the
+    // write happens through gitea:applyChange, never inside the loop).
+    const proposals: ChangeProposal[] = []
+
+    const execute = async (name: string, args: unknown) => {
+      if (!client) return { error: 'gitea is not configured' }
+      if (name === 'query_project') {
+        const snap = await reconcileSnapshot(client)
+        const a = (args ?? {}) as { view: ProjectView; filters?: QueryFilters }
+        return buildProjectView(a.view, a.filters, snap, new Date())
+      }
+      if (name === 'propose_change') {
+        const a = (args ?? {}) as ProposeChangeArgs
+        const issue = await client.getIssue(a.issue).catch(() => null)
+        if (!issue) return { error: `issue #${a.issue} not found` }
+        const built = proposalsFor(a, issue.labels, issue.title)
+        proposals.push(...built)
+        return built.length
+          ? { proposed: built.map((p) => ({ issue: a.issue, diff: describeChange(p.plan) })) }
+          : { proposed: [], note: 'no change — already at that value' }
+      }
+      if (name === 'record_directive') {
+        const pm = getPmStateClient()
+        if (!pm) return { error: 'pm-state is not configured' }
+        try {
+          const entry = await appendDirectiveEntry(pm, toDirectiveInput(args))
+          return { recorded: { kind: entry.kind, quote: entry.quote } }
+        } catch (e) {
+          return { error: `could not record — is the pm-state repo created? (${e instanceof Error ? e.message : e})` }
+        }
+      }
+      return { error: `unknown tool: ${name}` }
+    }
+
+    try {
+      const turn = await runAgentTurn({
+        complete: (m, t) => chat.complete(m, t),
+        messages: [{ role: 'system', content: REGINALD_SYSTEM }, ...messages],
+        tools: REGINALD_TOOLS,
+        execute,
+      })
+      return { ok: true as const, content: turn.content, steps: turn.steps, proposals }
+    } catch (e) {
+      return { ok: false as const, reason: 'error' as const, message: e instanceof Error ? e.message : String(e) }
+    }
+  })
+
+  // capture_work — braindump → proposed issue set. The big model does the
+  // decomposition (with one loaded local model, that's the loaded one). Returns
+  // a proposal; nothing is filed until the Capture tray approves it.
+  ipcMain.handle('model:capture', async (_event, braindump: string) => {
+    if (!router) return { ok: false as const, reason: 'unconfigured' as const }
+    const model = await resolveLoadedModel(router.big.baseUrl, router.big.model)
+    const chat = createChatClient({ ...router.big, model }, fetch)
+    try {
+      const proposal = await captureWork((m, t) => chat.complete(m, t), braindump)
+      return { ok: true as const, ...proposal }
+    } catch (e) {
+      return { ok: false as const, reason: 'error' as const, message: e instanceof Error ? e.message : String(e) }
+    }
+  })
+}

apps/desktop/src/preload/index.ts

@@ -9,6 +9,22 @@ const api = {
     reconcile: () => ipcRenderer.invoke('gitea:reconcile'),
     /** One issue by index, normalized (or null if unconfigured). */
     getIssue: (index: number) => ipcRenderer.invoke('gitea:getIssue', index),
+    /** Apply an estimate/priority change (the write path); resolves to the plan + fresh issue. */
+    applyChange: (change: unknown) => ipcRenderer.invoke('gitea:applyChange', change),
+    /** File a set of captured issues with their est/* + p/* labels. */
+    createIssues: (issues: unknown) => ipcRenderer.invoke('gitea:createIssues', issues),
+  },
+  pmstate: {
+    /** Read the directive ledger from the pm-state repo. */
+    directives: () => ipcRenderer.invoke('pmstate:directives'),
+  },
+  model: {
+    /** Whether a model endpoint is configured (else the UI keeps the scripted Reginald). */
+    status: () => ipcRenderer.invoke('model:status'),
+    /** One agent turn: messages in, Reginald's prose + the tools it consulted out. */
+    chat: (messages: unknown) => ipcRenderer.invoke('model:chat', messages),
+    /** Decompose a braindump into a proposed issue set (capture_work). */
+    capture: (braindump: string) => ipcRenderer.invoke('model:capture', braindump),
   },
 }
 

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

@@ -1,11 +1,12 @@
 import React from 'react'
 
-import { CALIBRATION } from '../../data/fixtures.js'
+import { CALIBRATION, type CalibrationData } from '../../data/fixtures.js'
 import { Badge, Card, Icon } from '../ui/index.js'
 
-// Calibration report — estimate-vs-actual evidence behind the cones
+// Calibration report — estimate-vs-actual evidence behind the cones.
-export function CalibrationScreen({ onBack }: { onBack: () => void }) {
+// `data` (real fit from closed-issue actuals) overrides the demo fixture.
-  const c = CALIBRATION
+export function CalibrationScreen({ onBack, data }: { onBack: () => void; data?: CalibrationData }) {
+  const c = data ?? CALIBRATION
 
   // scatter chart geometry
   const W = 420,
@@ -68,7 +69,11 @@ export function CalibrationScreen({ onBack }: { onBack: () => void }) {
             <h1 style={{ font: 'var(--text-display)', color: 'var(--ink-1)', margin: 0 }}>Calibration</h1>
             <p style={{ font: 'var(--text-data)', color: 'var(--ink-3)', margin: '6px 0 0', whiteSpace: 'nowrap' }}>{c.n} closed issues with estimates · evidence, not opinion</p>
           </div>
+          {c.active ? (
             <Badge tone="ok" dot>curve active · n ≥ 20</Badge>
+          ) : (
+            <Badge tone="warn" dot>cold-start · {c.n}/20</Badge>
+          )}
         </header>
       </div>
 
@@ -170,7 +175,9 @@ export function CalibrationScreen({ onBack }: { onBack: () => void }) {
               <span style={{ font: '500 12.5px var(--font-mono)', color: 'var(--ink-1)', whiteSpace: 'nowrap' }}>{c.effect.banded}</span>
             </div>
             <p style={{ font: 'var(--text-agent)', color: 'var(--ink-2)', margin: '10px 0 0' }}>
-              You are not bad at estimating; you are optimistic in a very stable way. Stable, I can work with.
+              {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.'}
             </p>
           </Card>
         </div>

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

@@ -1,8 +1,12 @@
 import React from 'react'
 
+import type { ProposedIssue } from '@commitea/core'
+
 import { Badge, Button, Card, Icon, Select, Tag } from '../ui/index.js'
 
-// Capture interview — braindump → interview → approved ticket set (< 2 min)
+// Capture interview — braindump → interview → approved ticket set (< 2 min).
+// With a model configured, "Brew tickets" runs real capture_work decomposition
+// and "Approve all" files the issues in gitea; otherwise the scripted demo runs.
 
 interface Ticket {
   title: string
@@ -30,6 +34,64 @@ export function CaptureScreen({ onDone }: { onDone: () => void }) {
   const [webEst, setWebEst] = React.useState<string | null>(null)
   const [secs, setSecs] = React.useState(0)
 
+  // live capture_work path (real model + gitea writes)
+  const [live, setLive] = React.useState(false)
+  const [brewing, setBrewing] = React.useState(false)
+  const [liveTickets, setLiveTickets] = React.useState<ProposedIssue[] | null>(null)
+  const [filedCount, setFiledCount] = React.useState(0)
+  const [error, setError] = React.useState<string | null>(null)
+
+  React.useEffect(() => {
+    let alive = true
+    window.commitea.model.status().then((s) => { if (alive) setLive(s.configured) }).catch(() => {})
+    return () => { alive = false }
+  }, [])
+
+  const editTicket = (i: number, field: 'estimate' | 'priority', value: string) =>
+    setLiveTickets((ts) => (ts ? ts.map((t, j) => (j === i ? { ...t, [field]: value } : t)) : ts))
+
+  // Decide live-vs-scripted at click time: re-check status if it hasn't resolved
+  // yet, so a configured model never falls into the scripted interview by a race.
+  const onBrew = async () => {
+    const configured = live || (await window.commitea.model.status().then((s) => s.configured).catch(() => false))
+    if (configured) {
+      setLive(true)
+      brew()
+    } else {
+      setStage('interview')
+    }
+  }
+
+  const brew = () => {
+    setError(null)
+    setBrewing(true)
+    window.commitea.model
+      .capture(dump)
+      .then((res) => {
+        setBrewing(false)
+        if (res.ok && res.issues.length) {
+          setLiveTickets(res.issues)
+          setStage('review')
+        } else {
+          setError(res.ok ? 'I could not find concrete work in that — try a bit more detail.' : `Capture failed: ${res.reason === 'error' ? res.message : 'no model'}`)
+        }
+      })
+      .catch(() => { setBrewing(false); setError('I could not reach the model.') })
+  }
+
+  const fileLive = () => {
+    if (!liveTickets) return
+    setBrewing(true)
+    window.commitea.gitea
+      .createIssues(liveTickets)
+      .then((res) => {
+        setBrewing(false)
+        if (res.ok) { setFiledCount(res.created.length); setStage('filed') }
+        else setError('Filing failed — gitea is not configured.')
+      })
+      .catch(() => { setBrewing(false); setError('Filing failed.') })
+  }
+
   const running = stage === 'interview' || stage === 'review'
   React.useEffect(() => {
     if (!running) return
@@ -63,19 +125,23 @@ export function CaptureScreen({ onDone }: { onDone: () => void }) {
     else setStage('review')
   }
 
-  // draft tickets build as the interview progresses
+  // draft tickets build as the interview progresses (scripted demo path)
-  const tickets: Ticket[] = []
+  const scripted: Ticket[] = []
   if (split === true) {
-    tickets.push({ title: 'Token refresh: retry with backoff', est: 'est/2d', p: 'p/2' })
+    scripted.push({ title: 'Token refresh: retry with backoff', est: 'est/2d', p: 'p/2' })
-    tickets.push({ title: 'Session storage: stale reads on wake', est: 'est/1d', p: 'p/3' })
+    scripted.push({ title: 'Session storage: stale reads on wake', est: 'est/1d', p: 'p/3' })
   } else if (split === false) {
-    tickets.push({ title: 'Auth: token refresh + session storage', est: 'est/3d', p: 'p/2' })
+    scripted.push({ title: 'Auth: token refresh + session storage', est: 'est/3d', p: 'p/2' })
   }
-  if (webEst) tickets.push({ title: 'Webhook debounce: double-fire guard', est: webEst, p: 'p/1', dep: 'blocked by auth work' })
+  if (webEst) scripted.push({ title: 'Webhook debounce: double-fire guard', est: webEst, p: 'p/1', dep: 'blocked by auth work' })
-  if (stage === 'review' || stage === 'filed') {
+  if (!live && (stage === 'review' || stage === 'filed')) {
-    tickets.push({ title: 'Docs: auth setup guide', est: 'est/1d', p: 'p/4', byReginald: true })
+    scripted.push({ title: 'Docs: auth setup guide', est: 'est/1d', p: 'p/4', byReginald: true })
   }
-  const totalDays = tickets.reduce((n, t) => n + parseInt(t.est.replace('est/', '')), 0)
+  // real capture_work output overrides the scripted set when present
+  const tickets: Ticket[] = liveTickets
+    ? liveTickets.map((i) => ({ title: i.title, est: i.estimate ?? 'est/2d', p: i.priority ?? 'p/3' }))
+    : scripted
+  const totalDays = tickets.reduce((n, t) => n + parseInt(t.est.replace('est/', ''), 10), 0)
 
   const estOptions = ['est/1d', 'est/2d', 'est/3d', 'est/5d', 'est/8d'].map((v) => ({ value: v, label: v }))
   const pOptions = ['p/1', 'p/2', 'p/3', 'p/4'].map((v) => ({ value: v, label: v }))
@@ -96,8 +162,20 @@ export function CaptureScreen({ onDone }: { onDone: () => void }) {
             <div style={{ display: 'flex', alignItems: 'center', gap: 8, flexWrap: 'wrap' }}>
               {editable ? (
                 <>
-                  <Select options={estOptions} defaultValue={t.est} style={{ width: 96 }} />
+                  <Select
-                  <Select options={pOptions} defaultValue={t.p} style={{ width: 76 }} />
+                    options={estOptions}
+                    value={liveTickets ? t.est : undefined}
+                    defaultValue={liveTickets ? undefined : t.est}
+                    onChange={(e) => editTicket(i, 'estimate', e.target.value)}
+                    style={{ width: 96 }}
+                  />
+                  <Select
+                    options={pOptions}
+                    value={liveTickets ? t.p : undefined}
+                    defaultValue={liveTickets ? undefined : t.p}
+                    onChange={(e) => editTicket(i, 'priority', e.target.value)}
+                    style={{ width: 76 }}
+                  />
                 </>
               ) : (
                 <>
@@ -144,7 +222,12 @@ export function CaptureScreen({ onDone }: { onDone: () => void }) {
           <p style={{ font: 'var(--text-agent)', color: 'var(--ink-2)', margin: '10px 0 14px' }}>
             Sentences, fragments, grievances — all welcome. I'll sort it into tickets and only ask what I can't infer.
           </p>
-          <Button icon="sparkles" onClick={() => setStage('interview')}>Brew tickets</Button>
+          <Button icon="sparkles" onClick={() => void onBrew()} disabled={brewing}>
+            {brewing ? 'Brewing…' : 'Brew tickets'}
+          </Button>
+          {error ? (
+            <p style={{ font: 'var(--text-agent)', color: 'var(--danger)', margin: '10px 0 0' }}>{error}</p>
+          ) : null}
         </Card>
       ) : null}
 
@@ -174,15 +257,26 @@ export function CaptureScreen({ onDone }: { onDone: () => void }) {
         <div style={{ display: 'grid', gridTemplateColumns: '1fr 1.1fr', gap: 14, alignItems: 'start' }}>
           <Card overline="Consequence" title={`${tickets.length} tickets · ~${totalDays}d of work`} jade
                 footer={<>
-                  <Button onClick={() => setStage('filed')}>Approve all</Button>
+                  <Button onClick={() => (live ? fileLive() : setStage('filed'))} disabled={brewing}>
-                  <Button variant="ghost" onClick={() => { setStage('dump'); setQi(0); setLog([]); setSplit(null); setWebEst(null); setSecs(0); }}>Discard</Button>
+                    {brewing ? 'Filing…' : 'Approve all'}
+                  </Button>
+                  <Button variant="ghost" onClick={() => { setStage('dump'); setQi(0); setLog([]); setSplit(null); setWebEst(null); setSecs(0); setLiveTickets(null); setError(null); }}>Discard</Button>
                 </>}>
+            {live ? (
+              <p style={{ font: 'var(--text-agent)', color: 'var(--ink-2)', margin: 0 }}>
+                {tickets.length} issue{tickets.length === 1 ? '' : 's'} from your braindump, estimated and prioritized.
+                Adjust the labels, then approve — I'll open them in gitea with only est/* and p/* labels.
+              </p>
+            ) : (
+              <>
                 <p style={{ font: 'var(--text-body)', margin: '0 0 8px' }}>
                   Beta's 80% window moves <span style={{ font: 'var(--text-data)' }}>Mar 3–12 → Mar 5–14</span>. Capacity absorbs the rest.
                 </p>
                 <p style={{ font: 'var(--text-agent)', color: 'var(--ink-2)', margin: 0 }}>
                   I added the docs ticket you mentioned and wired the dependency. Shall I make it so?
                 </p>
+              </>
+            )}
           </Card>
           <Tray editable />
         </div>
@@ -195,7 +289,7 @@ export function CaptureScreen({ onDone }: { onDone: () => void }) {
               <Icon name="circle-check" size={22} /> Filed
             </span>
             <p style={{ font: 'var(--text-body)', margin: 0 }}>
-              {tickets.length} issues opened in gitea with <span style={{ font: 'var(--text-data)' }}>est/*</span> and <span style={{ font: 'var(--text-data)' }}>p/*</span> labels — nothing else touched.
+              {live ? filedCount : tickets.length} issues opened in gitea with <span style={{ font: 'var(--text-data)' }}>est/*</span> and <span style={{ font: 'var(--text-data)' }}>p/*</span> labels — nothing else touched.
             </p>
             <p style={{ font: 'var(--text-agent)', color: 'var(--ink-2)', margin: 0 }}>
               Elapsed {clock} — under budget. No bot comments, no synthetic issues; your repo remains yours.

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

@@ -8,6 +8,35 @@ export function DirectivesScreen() {
   const [pending, setPending] = React.useState<DirectivePending | null>(DIRECTIVES.pending)
   const [entries, setEntries] = React.useState<DirectiveEntry[]>(DIRECTIVES.entries)
 
+  // Real ledger from the pm-state repo, when it exists — else the fixture demo.
+  React.useEffect(() => {
+    let alive = true
+    window.commitea.pmstate
+      .directives()
+      .then((r) => {
+        if (!alive || !r.ok || r.directives.length === 0) return
+        setPending(null)
+        setEntries(
+          r.directives
+            .slice()
+            .reverse()
+            .map((d) => ({
+              seq: d.seq,
+              who: 'You',
+              when: new Date(d.ts).toLocaleDateString(),
+              what: d.quote,
+              why: d.rationale ?? '',
+              status: d.status === 'accepted' ? 'applied' : d.status === 'withdrawn' ? 'withdrawn' : 'superseded',
+              consequence: '',
+            })),
+        )
+      })
+      .catch(() => {})
+    return () => {
+      alive = false
+    }
+  }, [])
+
   const resolve = (status: string) => {
     setEntries((e) => [{
       seq: pending!.seq, who: pending!.who, when: pending!.when, what: pending!.what, why: 'pilot demo on the 14th',

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

@@ -109,7 +109,9 @@ export function FocusScreen({
         <BurnUpCone data={forecast?.cone} />
         <p style={{ font: 'var(--text-agent)', color: 'var(--ink-2)', margin: '10px 0 0' }}>
           {forecast
-            ? `${forecast.scope} open ${forecast.scope === 1 ? 'issue' : 'issues'} in scope. Cold-start priors — the cone tightens as the team closes work.`
+            ? forecast.coldStart
+              ? `${forecast.scope} open ${forecast.scope === 1 ? 'issue' : 'issues'} in scope. Cold-start priors — ${forecast.calibratedN}/20 estimated closes so far; the cone tightens as the team closes work.`
+              : `${forecast.scope} open ${forecast.scope === 1 ? 'issue' : 'issues'} in scope, calibrated on ${forecast.calibratedN} closed ${forecast.calibratedN === 1 ? 'issue' : 'issues'} of your own.`
             : 'The cone has narrowed since Friday. I’m quietly pleased.'}
         </p>
       </Card>

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

@@ -1,17 +1,33 @@
 // Issue detail — human intent (gitea) on the left, machine-derived (pm-state) on the right
-import React from 'react'
+import React, { useState } from 'react'
+
+import {
+  describeChange,
+  type EstimateLabel,
+  ESTIMATE_LABELS,
+  type IssueChange,
+  planIssueChange,
+  type PriorityLabel,
+  PRIORITY_LABELS,
+} from '@commitea/core'
 
 import { ISSUE_DETAIL, type IssueDetail, type IssueRef } from '../../data/fixtures.js'
-import { Badge, Button, Card, Icon, Tag } from '../ui/index.js'
+import { Badge, Button, Card, Dialog, Icon, Select, Tag } from '../ui/index.js'
+
+const NONE = '—'
 
 export function IssueScreen({
   issue,
   onBack,
   onOpenIssue,
+  canWrite = false,
+  onApplyChange,
 }: {
   issue: IssueRef
   onBack: () => void
   onOpenIssue: (issue: IssueRef) => void
+  canWrite?: boolean
+  onApplyChange?: (change: IssueChange) => Promise<{ ok: boolean }>
 }) {
   const det: IssueDetail = ISSUE_DETAIL[issue.id] || {
     state: 'triage',
@@ -40,6 +56,44 @@ export function IssueScreen({
     } as Record<string, { tone: 'warn' | 'neutral' | 'info' | 'ok'; label: string }>
   )[det.state] || { tone: 'neutral', label: det.state }
 
+  // ---- propose-approve write path (apply_changes) ----
+  const labels = issue.labels ?? []
+  const curEstimate = labels.find((l) => l.startsWith('est/')) ?? ''
+  const curPriority = labels.find((l) => l.startsWith('p/')) ?? ''
+  const [adjustOpen, setAdjustOpen] = useState(false)
+  const [estimate, setEstimate] = useState(curEstimate)
+  const [priority, setPriority] = useState(curPriority)
+  const [applying, setApplying] = useState(false)
+
+  const openAdjust = () => {
+    setEstimate(curEstimate)
+    setPriority(curPriority)
+    setAdjustOpen(true)
+  }
+
+  // the concrete changes this dialog would apply, one per axis that differs
+  const pendingChanges: IssueChange[] = []
+  if (estimate !== curEstimate)
+    pendingChanges.push({ kind: 'reestimate', issue: issue.id, estimate: (estimate || null) as EstimateLabel | null })
+  if (priority !== curPriority)
+    pendingChanges.push({ kind: 'reprioritize', issue: issue.id, priority: (priority || null) as PriorityLabel | null })
+
+  const diffs = pendingChanges.map((c) => describeChange(planIssueChange(labels, c)))
+
+  const apply = async () => {
+    if (!onApplyChange || pendingChanges.length === 0) return
+    setApplying(true)
+    try {
+      for (const c of pendingChanges) await onApplyChange(c)
+      setAdjustOpen(false)
+    } finally {
+      setApplying(false)
+    }
+  }
+
+  const estOptions = [{ value: '', label: NONE }, ...ESTIMATE_LABELS.map((l) => ({ value: l, label: l }))]
+  const prioOptions = [{ value: '', label: NONE }, ...PRIORITY_LABELS.map((l) => ({ value: l, label: l }))]
+
   return (
     <div style={{ display: 'flex', flexDirection: 'column', gap: 16 }}>
       {/* breadcrumb + header */}
@@ -65,10 +119,69 @@ export function IssueScreen({
               </span>
             </div>
           </div>
+          <div style={{ display: 'flex', gap: 8, flexShrink: 0 }}>
+            {canWrite ? (
+              <Button variant="secondary" icon="pencil" onClick={openAdjust}>
+                Adjust
+              </Button>
+            ) : null}
             <Button variant="secondary" icon="arrow-up-right">Open in Gitea</Button>
+          </div>
         </header>
       </div>
 
+      <Dialog
+        open={adjustOpen}
+        onClose={() => setAdjustOpen(false)}
+        title="Adjust estimate & priority"
+        footer={
+          <>
+            <Button variant="ghost" onClick={() => setAdjustOpen(false)}>
+              Cancel
+            </Button>
+            <Button onClick={apply} disabled={pendingChanges.length === 0 || applying}>
+              {applying ? 'Applying…' : 'Apply to gitea'}
+            </Button>
+          </>
+        }
+      >
+        <div style={{ display: 'flex', gap: 14 }}>
+          <Select
+            label="Estimate"
+            options={estOptions}
+            value={estimate}
+            onChange={(e) => setEstimate(e.target.value)}
+          />
+          <Select
+            label="Priority"
+            options={prioOptions}
+            value={priority}
+            onChange={(e) => setPriority(e.target.value)}
+          />
+        </div>
+        <div style={{ marginTop: 14, minHeight: 40 }}>
+          {pendingChanges.length === 0 ? (
+            <p style={{ font: 'var(--text-agent)', color: 'var(--ink-3)', margin: 0 }}>
+              No change yet — pick a different estimate or priority.
+            </p>
+          ) : (
+            <>
+              <p style={{ font: 'var(--text-overline)', letterSpacing: 'var(--letter-spacing-wide)', textTransform: 'uppercase', color: 'var(--ink-3)', margin: '0 0 6px' }}>
+                Proposed label change
+              </p>
+              {diffs.map((d) => (
+                <div key={d} style={{ font: '500 13px var(--font-mono)', color: 'var(--ink-1)' }}>
+                  {d}
+                </div>
+              ))}
+              <p style={{ font: 'var(--text-agent)', color: 'var(--ink-2)', margin: '8px 0 0' }}>
+                Writes the label to gitea and re-runs the plan. Nothing else changes.
+              </p>
+            </>
+          )}
+        </div>
+      </Dialog>
+
       <div style={{ display: 'grid', gridTemplateColumns: '1fr 300px', gap: 16, alignItems: 'start' }}>
         {/* left: human intent */}
         <div style={{ display: 'flex', flexDirection: 'column', gap: 16 }}>

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

@@ -8,15 +8,22 @@ import { RUNWAY, CAPACITY } from '../../data/fixtures.js'
 export function RunwayScreen({
   onOpenCalibration,
   onOpenMilestone,
+  calibration,
 }: {
   onOpenCalibration: () => void
   onOpenMilestone: () => void
+  calibration?: { n: number; coldStart: boolean }
 }) {
+  const calibNote = calibration
+    ? calibration.coldStart
+      ? `cold-start priors · ${calibration.n}/20 closed issues estimated`
+      : `calibrated on ${calibration.n} closed ${calibration.n === 1 ? 'issue' : 'issues'}`
+    : 'calibrated on 27 closed issues'
   return (
     <div style={{ display: 'flex', flexDirection: 'column', gap: 16 }}>
       <header style={{ borderBottom: 'var(--rule-double)', paddingBottom: 14 }}>
         <h1 style={{ font: 'var(--text-display)', color: 'var(--ink-1)', margin: 0 }}>Runway</h1>
-        <p style={{ font: 'var(--text-data)', color: 'var(--ink-3)', margin: '6px 0 0' }}>capacity vs milestone dates · calibrated on 27 closed issues</p>
+        <p style={{ font: 'var(--text-data)', color: 'var(--ink-3)', margin: '6px 0 0' }}>capacity vs milestone dates · {calibNote}</p>
       </header>
 
       <Card overline="Milestones" flush>

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

@@ -1,8 +1,10 @@
 import React, { useEffect, useState } from 'react'
 
 import logoIcon from '../../design/assets/logo-icon.png'
+import type { IssueChange } from '@commitea/core'
+
 import type { IssueRef } from '../../data/fixtures.js'
-import { forecastBacklog, issuesToBoardColumns, scheduleFocus } from '../../lib/backlog.js'
+import { backlogCalibration, forecastBacklog, issuesToBoardColumns, scheduleFocus } from '../../lib/backlog.js'
 import { useBacklog } from '../../lib/use-backlog.js'
 import { PrimitivesGallery } from '../gallery.js'
 import { BoardScreen } from '../screens/board-screen.js'
@@ -85,11 +87,17 @@ export function AppShell() {
   const [offline, setOffline] = useState(false)
   const [issue, setIssue] = useState<IssueRef | null>(null)
   const [readIds, setReadIds] = useState<number[]>([])
-  const backlog = useBacklog()
+  const [backlog, refetchBacklog] = useBacklog()
-  const boardColumns = backlog.status === 'ready' ? issuesToBoardColumns(backlog.issues) : undefined
+  const boardColumns =
-  const focus = backlog.status === 'ready' ? scheduleFocus(backlog.issues, backlog.deps) : undefined
+    backlog.status === 'ready' ? issuesToBoardColumns(backlog.issues, backlog.timelines) : undefined
+  const focus =
+    backlog.status === 'ready' ? scheduleFocus(backlog.issues, backlog.deps, backlog.timelines) : undefined
+  const calibration =
+    backlog.status === 'ready' ? backlogCalibration(backlog.issues, backlog.timelines) : undefined
   const forecast =
-    backlog.status === 'ready' ? (forecastBacklog(backlog.issues, backlog.deps) ?? undefined) : undefined
+    backlog.status === 'ready'
+      ? (forecastBacklog(backlog.issues, backlog.deps, new Date(), calibration?.model) ?? undefined)
+      : undefined
 
   useEffect(() => {
     document.documentElement.setAttribute('data-theme', dark ? 'dark' : 'light')
@@ -101,6 +109,17 @@ export function AppShell() {
     setView('issue')
   }
 
+  // The write path: apply through the bridge, reflect the new labels on the open
+  // issue immediately, and re-reconcile so the board + forecast catch up.
+  const applyChange = async (change: IssueChange) => {
+    const res = await window.commitea.gitea.applyChange(change)
+    if (res.ok) {
+      setIssue((cur) => (cur && cur.id === res.issue.number ? { ...cur, labels: res.issue.labels } : cur))
+      refetchBacklog()
+    }
+    return res
+  }
+
   const NAV: NavEntry[] = [
     { id: 'standup', label: 'Standup', icon: 'sun' },
     { id: 'focus', label: 'Morning service', icon: 'coffee' },
@@ -176,10 +195,11 @@ export function AppShell() {
           <RunwayScreen
             onOpenCalibration={() => setView('calibration')}
             onOpenMilestone={() => setView('milestone')}
+            calibration={calibration ? { n: calibration.model.n, coldStart: calibration.model.coldStart } : undefined}
           />
         )
       case 'calibration':
-        return <CalibrationScreen onBack={() => setView('runway')} />
+        return <CalibrationScreen onBack={() => setView('runway')} data={calibration?.data} />
       case 'milestone':
         return <MilestoneScreen onBack={() => setView('runway')} onOpenIssue={openIssue} />
       case 'inbox':
@@ -199,7 +219,13 @@ export function AppShell() {
         return <SettingsScreen dark={dark} setDark={setDark} />
       case 'issue':
         return issue ? (
-          <IssueScreen issue={issue} onBack={() => setView(prevView)} onOpenIssue={openIssue} />
+          <IssueScreen
+            issue={issue}
+            onBack={() => setView(prevView)}
+            onOpenIssue={openIssue}
+            canWrite={backlog.status === 'ready'}
+            onApplyChange={applyChange}
+          />
         ) : null
       case 'states':
         return <StatesScreen onCapture={() => setView('capture')} />
@@ -311,7 +337,7 @@ export function AppShell() {
         </div>
       </main>
 
-      <ChatPanel onOpenDirectives={() => setView('directives')} offline={offline} />
+      <ChatPanel onOpenDirectives={() => setView('directives')} offline={offline} onApplyChange={applyChange} />
     </div>
   )
 }

apps/desktop/src/renderer/src/components/shell/chat-panel.tsx

@@ -1,22 +1,28 @@
 import React, { useEffect, useRef, useState } from 'react'
 
-import { CANNED_REPLY, CHAT, type ChatMessage } from '../../data/fixtures.js'
+import { describeChange, type IssueChange } from '@commitea/core'
-import { Icon, IconButton } from '../ui/index.js'
+
+import { useChat } from '../../lib/use-chat.js'
+import { Button, Icon, IconButton } from '../ui/index.js'
 
 /**
- * Reginald's panel — chat is the write-path (decisions.md D1). This is the P3-2
+ * Reginald's panel — chat is the write-path (decisions.md D1). Wired to the
- * fixture shell: it echoes a canned reply so the layout + interactions are real,
+ * model bridge via `useChat`: a configured model drives a real agent turn
- * but no model is wired. P4 replaces `send` with the model router + tools.
+ * (query_project + prose, propose_change for edits); otherwise it echoes the
+ * scripted fixture reply. Proposed changes are approved inline here — the write
+ * runs through `onApplyChange`, the same guarded handler the Issue screen uses.
  */
 export interface ChatPanelProps {
   onOpenDirectives?: () => void
   offline?: boolean
+  onApplyChange?: (change: IssueChange) => Promise<{ ok: boolean }>
 }
 
-export function ChatPanel({ onOpenDirectives, offline }: ChatPanelProps) {
+export function ChatPanel({ onOpenDirectives, offline, onApplyChange }: ChatPanelProps) {
-  const [msgs, setMsgs] = useState<ChatMessage[]>(CHAT)
+  const { msgs, thinking, live, model, steps, proposals, send: sendChat, approve, dismiss } = useChat(onApplyChange)
+  // shorten "google/gemma-4-26b-a4b-qat" → "gemma-4-26b" for the header chip
+  const modelLabel = model ? (model.split('/').pop() ?? model).replace(/-(qat|instruct|it|gguf)$/i, '') : 'gemma-4'
   const [text, setText] = useState('')
-  const [thinking, setThinking] = useState(false)
   const scrollRef = useRef<HTMLDivElement>(null)
 
   useEffect(() => {
@@ -27,13 +33,8 @@ export function ChatPanel({ onOpenDirectives, offline }: ChatPanelProps) {
   const send = () => {
     const t = text.trim()
     if (!t) return
-    setMsgs((m) => [...m, { from: 'user', text: t }])
     setText('')
-    setThinking(true)
+    sendChat(t)
-    setTimeout(() => {
-      setThinking(false)
-      setMsgs((m) => [...m, { from: 'agent', text: CANNED_REPLY }])
-    }, 900)
   }
 
   return (
@@ -61,7 +62,7 @@ export function ChatPanel({ onOpenDirectives, offline }: ChatPanelProps) {
         <Icon name="sparkles" size={16} style={{ color: offline ? 'var(--ink-3)' : 'var(--jade)' }} />
         <span style={{ font: 'var(--text-body-strong)', color: 'var(--ink-1)' }}>Reginald</span>
         <span style={{ font: '400 11px var(--font-mono)', color: 'var(--ink-3)', marginLeft: 'auto' }}>
-          {offline ? 'offline · queueing' : 'gemma-4b · local'}
+          {offline ? 'offline · queueing' : live ? `${modelLabel} · local` : 'demo · scripted'}
         </span>
         <IconButton icon="history" label="Directive log" size="sm" onClick={onOpenDirectives} />
       </header>
@@ -98,6 +99,38 @@ export function ChatPanel({ onOpenDirectives, offline }: ChatPanelProps) {
           </div>
         ) : null}
         {thinking ? <div style={{ font: 'var(--text-agent)', color: 'var(--ink-3)' }}>considering…</div> : null}
+        {!thinking && steps.length ? (
+          <div style={{ font: 'var(--text-caption)', color: 'var(--ink-3)', display: 'flex', alignItems: 'center', gap: 5 }}>
+            <Icon name="eye" size={11} /> consulted {Array.from(new Set(steps.map((s) => s.replace('query_project', 'the project').replace('propose_change', 'the labels').replace('record_directive', 'the directive ledger')))).join(', ')}
+          </div>
+        ) : null}
+        {proposals.map((p) => (
+          <div
+            key={`${p.change.issue}:${p.change.kind}`}
+            style={{
+              border: '1px solid var(--line-2)',
+              borderRadius: 'var(--radius-2)',
+              background: 'var(--paper-0)',
+              padding: '10px 12px',
+              display: 'flex',
+              flexDirection: 'column',
+              gap: 8,
+            }}
+          >
+            <div style={{ font: 'var(--text-caption)', color: 'var(--ink-3)', textTransform: 'uppercase', letterSpacing: 'var(--letter-spacing-wide)' }}>
+              Proposed · #{p.change.issue}
+            </div>
+            <div style={{ font: '500 13px var(--font-mono)', color: 'var(--ink-1)' }}>{describeChange(p.plan)}</div>
+            <div style={{ display: 'flex', gap: 8 }}>
+              <Button size="sm" onClick={() => approve(p)} disabled={offline}>
+                Approve
+              </Button>
+              <Button size="sm" variant="ghost" onClick={() => dismiss(p)}>
+                Dismiss
+              </Button>
+            </div>
+          </div>
+        ))}
       </div>
 
       <div style={{ padding: 14, borderTop: '1px solid var(--line-1)', flexShrink: 0 }}>

apps/desktop/src/renderer/src/global.d.ts

@@ -1,4 +1,32 @@
-import type { DependencyEdge, GiteaIssue, GiteaMilestone } from '@commitea/core'
+import type {
+  AgentStep,
+  ChangeProposal,
+  ChatMessage,
+  CaptureProposal,
+  DependencyEdge,
+  DirectiveRecord,
+  GiteaIssue,
+  GiteaMilestone,
+  IssueChange,
+  LabelPlan,
+  LifecycleEvent,
+  ProposedIssue,
+} from '@commitea/core'
+
+/** The result of a write through the bridge. */
+export type ApplyChangeResult =
+  | { ok: false; reason: 'unconfigured' }
+  | { ok: true; plan: LabelPlan; issue: GiteaIssue }
+
+/** The result of filing captured issues. */
+export type CreateIssuesResult =
+  | { ok: false; reason: 'unconfigured' }
+  | { ok: true; created: { number: number; title: string }[] }
+
+/** The result of a capture_work decomposition. */
+export type CaptureResult =
+  | { ok: false; reason: 'unconfigured' | 'error'; message?: string }
+  | ({ ok: true } & CaptureProposal)
 
 /** The gitea bridge exposed by the preload over IPC (main-process backed). */
 export interface GiteaBridge {
@@ -8,8 +36,34 @@ export interface GiteaBridge {
     issues: GiteaIssue[]
     milestones: GiteaMilestone[]
     deps: DependencyEdge[]
+    /** Normalized lifecycle events keyed by issue number. */
+    timelines: Record<number, LifecycleEvent[]>
   }>
   getIssue(index: number): Promise<GiteaIssue | null>
+  applyChange(change: IssueChange): Promise<ApplyChangeResult>
+  createIssues(issues: ProposedIssue[]): Promise<CreateIssuesResult>
+}
+
+/** One agent turn's result. */
+export type ChatResult =
+  | { ok: false; reason: 'unconfigured' | 'error'; message?: string }
+  | { ok: true; content: string; steps: AgentStep[]; proposals: ChangeProposal[] }
+
+/** The model bridge (Reginald) exposed by the preload over IPC. */
+export interface ModelBridge {
+  status(): Promise<{ configured: boolean; model: string | null }>
+  chat(messages: ChatMessage[]): Promise<ChatResult>
+  capture(braindump: string): Promise<CaptureResult>
+}
+
+/** The result of reading the directive ledger. */
+export type DirectivesResult =
+  | { ok: false; reason: 'unconfigured' | 'error'; message?: string }
+  | { ok: true; directives: DirectiveRecord[] }
+
+/** The pm-state bridge (machine-derived state) exposed by the preload over IPC. */
+export interface PmStateBridge {
+  directives(): Promise<DirectivesResult>
 }
 
 declare global {
@@ -17,6 +71,8 @@ declare global {
     commitea: {
       platform: string
       gitea: GiteaBridge
+      model: ModelBridge
+      pmstate: PmStateBridge
     }
   }
 }

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

@@ -1,17 +1,33 @@
 import {
+  type CalibrationModel,
+  type CalibrationSample,
+  calibrationSamples,
+  COLD_START_THRESHOLD,
   type DependencyEdge,
+  fitCalibration,
   forecast,
   type GiteaIssue,
-  inferColumnV0,
+  inferLifecycle,
   type LifecycleColumn,
+  type LifecycleEvent,
+  type LifecycleInference,
+  PRIOR_BUCKETS,
   schedule,
   type ScheduledItem,
   selectFocus,
+  toDurationModel,
 } from '@commitea/core'
 
-import { type BoardColumn, type BoardIssue, type FocusIssue } from '../data/fixtures.js'
+import { type BoardColumn, type BoardIssue, type CalibrationData, type FocusIssue } from '../data/fixtures.js'
 import { type BurnUpData, buildBurnUpData } from './dates.js'
 
+type Timelines = Record<number, LifecycleEvent[]>
+
+/** Infer every issue's lifecycle once; callers index by issue number. */
+function inferAll(issues: GiteaIssue[], timelines: Timelines, asOf: Date): Map<number, LifecycleInference> {
+  return new Map(issues.map((i) => [i.number, inferLifecycle(i, timelines[i.number] ?? [], asOf)]))
+}
+
 const COLUMN_LABELS: Record<LifecycleColumn, string> = {
   diagnosis: 'Diagnosis',
   triage: 'Triage',
@@ -27,24 +43,32 @@ function initials(login: string): string {
 }
 
 /**
- * Shape real gitea issues into the Board's five columns via lifecycle-v0.
+ * Shape real gitea issues into the Board's five columns via lifecycle inference
- * `steeping` / `review` stay empty until event inference (P1-5). `days` / `pr`
+ * (#5). Steeping / In-review are now populated from the event stream (first
- * are likewise event-derived and omitted here.
+ * commit ref → steeping, first PR ref → review); the `days` badge is the
+ * steeping age in working days.
  */
-export function issuesToBoardColumns(issues: GiteaIssue[]): BoardColumn[] {
+export function issuesToBoardColumns(
+  issues: GiteaIssue[],
+  timelines: Timelines = {},
+  asOf: Date = new Date(),
+): BoardColumn[] {
+  const inf = inferAll(issues, timelines, asOf)
   return COLUMN_ORDER.map((key) => ({
     id: key,
     label: COLUMN_LABELS[key],
     issues: issues
-      .filter((i) => inferColumnV0(i) === key)
+      .filter((i) => inf.get(i.number)!.column === key)
-      .map(
+      .map((i): BoardIssue => {
-        (i): BoardIssue => ({
+        const li = inf.get(i.number)!
+        return {
           id: i.number,
           title: i.title,
           labels: i.labels,
           who: i.assignee ? initials(i.assignee) : '·',
+          days: li.steepingDays != null ? `${li.steepingDays}d` : undefined,
+        }
       }),
-      ),
   }))
 }
 
@@ -54,9 +78,16 @@ export interface FocusView {
   later: FocusIssue | null
 }
 
-function toFocusIssue(item: ScheduledItem | null): FocusIssue | null {
+function toFocusIssue(item: ScheduledItem | null, inf?: Map<number, LifecycleInference>): FocusIssue | null {
   if (!item) return null
-  return { id: item.number, title: item.title, labels: item.labels, rationale: item.rationale }
+  const steepingDays = inf?.get(item.number)?.steepingDays ?? null
+  return {
+    id: item.number,
+    title: item.title,
+    labels: item.labels,
+    rationale: item.rationale,
+    steeping: steepingDays != null ? `${steepingDays}d` : undefined,
+  }
 }
 
 function toSchedulable(issues: GiteaIssue[]) {
@@ -76,22 +107,109 @@ export interface ForecastView {
   cone: BurnUpData
   p80Label: string
   rangeLabel: string
+  /** true while the forecast still runs on code priors (calibration not yet trusted). */
+  coldStart: boolean
+  /** Closed-with-estimate issues feeding calibration so far. */
+  calibratedN: number
 }
 
 /**
  * Monte Carlo forecast over the open backlog, mapped onto a calendar-anchored
- * burn-up cone. Returns null when there's nothing to forecast (no open scope) —
+ * burn-up cone. When a calibration model is supplied and past cold-start, its
- * the UI then falls back to the demo cone. `today` is injectable for tests.
+ * fitted params drive the sim. Returns null when there's nothing to forecast.
+ * `today` is injectable for tests.
  */
 export function forecastBacklog(
   issues: GiteaIssue[],
   deps: DependencyEdge[],
   today: Date = new Date(),
+  calibration?: CalibrationModel,
 ): ForecastView | null {
-  const f = forecast(toSchedulable(issues), deps)
+  const model = calibration ? toDurationModel(calibration) : undefined
+  const f = forecast(toSchedulable(issues), deps, model ? { model } : {})
   const cone = buildBurnUpData(f, today)
   if (!cone) return null
-  return { scope: f.scope, cone, p80Label: cone.p80Label, rangeLabel: cone.rangeLabel }
+  return {
+    scope: f.scope,
+    cone,
+    p80Label: cone.p80Label,
+    rangeLabel: cone.rangeLabel,
+    coldStart: f.coldStart,
+    calibratedN: calibration?.n ?? 0,
+  }
+}
+
+/** Fit the calibration model from the closed backlog's inferred actuals (#1). */
+export function calibrateBacklog(
+  issues: GiteaIssue[],
+  timelines: Timelines = {},
+  asOf: Date = new Date(),
+): CalibrationModel {
+  return fitCalibration(calibrationSamples(issues, timelines, asOf))
+}
+
+/** Calibration model + its screen view in one pass over the closed backlog. */
+export function backlogCalibration(
+  issues: GiteaIssue[],
+  timelines: Timelines = {},
+  asOf: Date = new Date(),
+): { model: CalibrationModel; data: CalibrationData } {
+  const samples = calibrationSamples(issues, timelines, asOf)
+  const model = fitCalibration(samples)
+  return { model, data: calibrationData(model, samples, issues) }
+}
+
+const pctFromMu = (mu: number) => Math.round((Math.exp(mu) - 1) * 100)
+
+/**
+ * Shape the calibration model + its samples into the screen's view. Buckets and
+ * people only earn a bias once their sample clears the fit floor; everything
+ * degrades honestly on a thin (cold-start) dataset.
+ */
+export function calibrationData(
+  model: CalibrationModel,
+  samples: CalibrationSample[],
+  openIssues: GiteaIssue[],
+): CalibrationData {
+  const labels = PRIOR_BUCKETS.map((b) => {
+    const inBucket = samples.filter((s) => s.bucket === b)
+    const fit = model.byBucket[b]
+    const mu = fit ? fit.mu : model.global.mu
+    return {
+      label: `est/${b}d`,
+      n: fit ? fit.n : inBucket.length,
+      median: inBucket.length ? `${(b * Math.exp(mu)).toFixed(1)}d` : '—',
+      bias: fit ? pctFromMu(fit.mu) : null,
+    }
+  })
+
+  const people = Object.entries(model.byPerson).map(([who, pb]) => ({
+    who,
+    n: pb.n,
+    bias: pctFromMu(model.global.mu + pb.biasMu),
+    note: '',
+  }))
+
+  const openEst = openIssues
+    .filter((i) => i.state === 'open')
+    .reduce((sum, i) => sum + (i.facts.estimateDays ?? 2), 0)
+  const effect = model.coldStart
+    ? { raw: `${model.n}/${COLD_START_THRESHOLD} estimated closes`, banded: 'cold-start priors', p50: '—' }
+    : {
+        raw: `${openEst}d estimated`,
+        banded: `×${Math.exp(model.global.mu).toFixed(2)} median drift`,
+        p50: `≈${Math.round(openEst * Math.exp(model.global.mu))}d`,
+      }
+
+  return {
+    n: model.n,
+    active: !model.coldStart,
+    labels,
+    people,
+    scatter: samples.map((s) => [s.estimateDays, s.actualWorkingDays]),
+    fit: Number(Math.exp(model.global.mu).toFixed(2)),
+    effect,
+  }
 }
 
 /**
@@ -99,8 +217,18 @@ export function forecastBacklog(
  * as Now/Next/Later. Estimates + priority come from label facts; dependency
  * edges come from gitea's native issue dependencies.
  */
-export function scheduleFocus(issues: GiteaIssue[], deps: DependencyEdge[]): FocusView {
+export function scheduleFocus(
+  issues: GiteaIssue[],
+  deps: DependencyEdge[],
+  timelines: Timelines = {},
+  asOf: Date = new Date(),
+): FocusView {
   const plan = schedule(toSchedulable(issues), deps)
   const f = selectFocus(plan)
-  return { now: toFocusIssue(f.now), next: toFocusIssue(f.next), later: toFocusIssue(f.later) }
+  const inf = inferAll(issues, timelines, asOf)
+  return {
+    now: toFocusIssue(f.now, inf),
+    next: toFocusIssue(f.next, inf),
+    later: toFocusIssue(f.later, inf),
+  }
 }

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

@@ -1,20 +1,29 @@
-import { useEffect, useState } from 'react'
+import { useCallback, useEffect, useState } from 'react'
 
-import type { DependencyEdge, GiteaIssue, GiteaMilestone } from '@commitea/core'
+import type { DependencyEdge, GiteaIssue, GiteaMilestone, LifecycleEvent } from '@commitea/core'
 
 export type BacklogState =
   | { status: 'loading' }
   | { status: 'unconfigured' }
   | { status: 'error'; message: string }
-  | { status: 'ready'; issues: GiteaIssue[]; milestones: GiteaMilestone[]; deps: DependencyEdge[] }
+  | {
+      status: 'ready'
+      issues: GiteaIssue[]
+      milestones: GiteaMilestone[]
+      deps: DependencyEdge[]
+      timelines: Record<number, LifecycleEvent[]>
+    }
 
 /**
- * Reconcile the managed repo once on mount, through the main-process bridge.
+ * Reconcile the managed repo through the main-process bridge. Runs once on
- * `unconfigured` means no token — the UI falls back to demo fixtures. Errors
+ * mount; the returned `refetch` re-reconciles after a write so the board and
- * (network, bad token) surface as `error`.
+ * forecast reflect the change. `unconfigured` means no token — the UI falls
+ * back to demo fixtures. Errors (network, bad token) surface as `error`.
  */
-export function useBacklog(): BacklogState {
+export function useBacklog(): [BacklogState, () => void] {
   const [state, setState] = useState<BacklogState>({ status: 'loading' })
+  const [nonce, setNonce] = useState(0)
+  const refetch = useCallback(() => setNonce((n) => n + 1), [])
 
   useEffect(() => {
     let alive = true
@@ -24,7 +33,13 @@ export function useBacklog(): BacklogState {
         if (!alive) return
         setState(
           r.configured
-            ? { status: 'ready', issues: r.issues, milestones: r.milestones, deps: r.deps }
+            ? {
+                status: 'ready',
+                issues: r.issues,
+                milestones: r.milestones,
+                deps: r.deps,
+                timelines: r.timelines,
+              }
             : { status: 'unconfigured' },
         )
       })
@@ -34,7 +49,7 @@ export function useBacklog(): BacklogState {
     return () => {
       alive = false
     }
-  }, [])
+  }, [nonce])
 
-  return state
+  return [state, refetch]
 }

apps/desktop/src/renderer/src/lib/use-chat.ts

@@ -0,0 +1,141 @@
+import { useCallback, useEffect, useRef, useState } from 'react'
+
+import type { ChangeProposal, ChatMessage as WireMessage, IssueChange } from '@commitea/core'
+
+import { CANNED_REPLY, CHAT, type ChatMessage } from '../data/fixtures.js'
+
+const LIVE_GREETING: ChatMessage = {
+  from: 'agent',
+  text: 'Morning. Ask me anything about the project — I check the real board before I answer.',
+}
+
+export interface ChatState {
+  msgs: ChatMessage[]
+  thinking: boolean
+  /** true once a model endpoint is confirmed; otherwise the panel echoes the demo reply. */
+  live: boolean
+  /** The loaded model's id when live (for the header). */
+  model: string | null
+  /** Tools Reginald consulted on the last turn (for a subtle activity line). */
+  steps: string[]
+  /** Changes Reginald has proposed and is awaiting approval on. */
+  proposals: ChangeProposal[]
+  send: (text: string) => void
+  approve: (p: ChangeProposal) => void
+  dismiss: (p: ChangeProposal) => void
+}
+
+/**
+ * Reginald's conversation. When a model is configured, `send` drives one agent
+ * turn through the main-process bridge (which runs the tool loop). Otherwise it
+ * echoes the scripted fixture reply, so the layout stays real with no model and
+ * fixture e2e is unaffected. The fixture greeting is display-only — only real
+ * turns (`convo`) are sent to the model as history. `onApplyChange` performs an
+ * approved write (the same handler the Issue screen uses — it refetches).
+ */
+export function useChat(onApplyChange?: (change: IssueChange) => Promise<{ ok: boolean }>): ChatState {
+  const [seed, setSeed] = useState<ChatMessage[]>(CHAT)
+  const [convo, setConvo] = useState<ChatMessage[]>([])
+  const [thinking, setThinking] = useState(false)
+  const [live, setLive] = useState(false)
+  const [model, setModel] = useState<string | null>(null)
+  const [steps, setSteps] = useState<string[]>([])
+  const [proposals, setProposals] = useState<ChangeProposal[]>([])
+  const convoRef = useRef(convo)
+  convoRef.current = convo
+
+  const proposalKey = (p: ChangeProposal) => `${p.change.issue}:${p.change.kind}`
+  const drop = (p: ChangeProposal) => setProposals((ps) => ps.filter((x) => proposalKey(x) !== proposalKey(p)))
+
+  useEffect(() => {
+    let alive = true
+    window.commitea.model
+      .status()
+      .then((s) => {
+        if (alive && s.configured) {
+          setLive(true)
+          setModel(s.model)
+          setSeed([LIVE_GREETING])
+        }
+      })
+      .catch(() => {})
+    return () => {
+      alive = false
+    }
+  }, [])
+
+  const send = useCallback(
+    (raw: string) => {
+      const text = raw.trim()
+      if (!text) return
+      const nextConvo: ChatMessage[] = [...convoRef.current, { from: 'user', text }]
+      setConvo(nextConvo)
+      setThinking(true)
+      setSteps([])
+      setProposals([])
+
+      if (!live) {
+        window.setTimeout(() => {
+          setThinking(false)
+          setConvo((c) => [...c, { from: 'agent', text: CANNED_REPLY }])
+        }, 900)
+        return
+      }
+
+      const wire: WireMessage[] = nextConvo.map((m) => ({
+        role: m.from === 'user' ? 'user' : 'assistant',
+        content: m.text,
+      }))
+      window.commitea.model
+        .chat(wire)
+        .then((res) => {
+          setThinking(false)
+          if (res.ok) {
+            setSteps(res.steps.map((s) => s.tool))
+            setProposals(res.proposals)
+            setConvo((c) => [...c, { from: 'agent', text: res.content || '…' }])
+          } else {
+            setConvo((c) => [
+              ...c,
+              {
+                from: 'agent',
+                text: res.reason === 'error' ? `I hit a snag: ${res.message ?? 'unknown error'}` : 'No model is configured.',
+              },
+            ])
+          }
+        })
+        .catch(() => {
+          setThinking(false)
+          setConvo((c) => [...c, { from: 'agent', text: 'I could not reach the model.' }])
+        })
+    },
+    [live],
+  )
+
+  const approve = useCallback(
+    (p: ChangeProposal) => {
+      if (!onApplyChange) return
+      drop(p)
+      const label = p.plan.added[0] ?? p.plan.removed[0] ?? 'change'
+      void onApplyChange(p.change).then((res) => {
+        setConvo((c) => [
+          ...c,
+          {
+            from: 'agent',
+            text: res.ok
+              ? `Done — #${p.change.issue} is now ${label}. The plan's been re-run.`
+              : `That didn't take — #${p.change.issue} is unchanged.`,
+          },
+        ])
+      })
+    },
+    [onApplyChange],
+  )
+
+  const dismiss = useCallback((p: ChangeProposal) => {
+    drop(p)
+    setConvo((c) => [...c, { from: 'agent', text: `Left #${p.change.issue} as it was.` }])
+  }, [])
+
+  return { msgs: [...seed, ...convo], thinking, live, model, steps, proposals, send, approve, dismiss }
+}

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

@@ -0,0 +1,103 @@
+import { beforeAll, describe, expect, it } from 'vitest'
+
+import { extractLabelFacts } from '../labels/label-schema.js'
+import type { FetchLike, GiteaIssue } from '../gitea/types.js'
+import { runAgentTurn } from './agent-loop.js'
+import { REGINALD_SYSTEM, REGINALD_TOOLS } from './agent-tools.js'
+import { createChatClient } from './chat-client.js'
+import { buildProjectView, type ProjectSnapshot } from './query-project.js'
+
+/**
+ * Opt-in (COMMITEA_MODEL_LIVE=1). Drives the real chat client + agent loop
+ * against a local OpenAI-compatible server (LM Studio on :1234 by default),
+ * proving the model calls the tools and narrates the real result. The model is
+ * whatever is loaded (via LM Studio's native API), so it never JIT-swaps.
+ */
+const LIVE = !!process.env.COMMITEA_MODEL_LIVE
+const BASE = process.env.COMMITEA_MODEL_URL ?? 'http://localhost:1234/v1'
+let MODEL = process.env.COMMITEA_MODEL_SMALL ?? ''
+
+beforeAll(async () => {
+  if (!LIVE || MODEL) return
+  const root = BASE.replace(/\/v1\/?$/, '')
+  const loaded = await fetch(`${root}/api/v0/models`)
+    .then((r) => (r.ok ? (r.json() as Promise<{ data?: { id: string; state?: string; type?: string }[] }>) : null))
+    .then((d) => d?.data?.find((m) => m.state === 'loaded' && m.type !== 'embeddings')?.id)
+    .catch(() => undefined)
+  MODEL = loaded ?? 'google/gemma-4-e4b'
+})
+
+function issue(over: Partial<GiteaIssue>): GiteaIssue {
+  const labels = over.labels ?? []
+  return {
+    number: 1, title: '#1', body: '', state: 'open', labels, facts: extractLabelFacts(labels),
+    milestone: null, assignee: null, assignees: [], createdAt: '2026-01-05T09:00:00Z',
+    updatedAt: '2026-01-05T09:00:00Z', closedAt: null, url: '', ...over,
+  }
+}
+
+const SNAP: ProjectSnapshot = {
+  issues: [
+    issue({ number: 2, title: 'ChangeSource interface + polling source', labels: ['est/3d', 'p/1'] }),
+    issue({ number: 3, title: 'SQLite cache bootstrap', labels: ['est/2d', 'p/1'] }),
+  ],
+  timelines: {},
+  deps: [{ issue: 3, dependsOn: 2 }],
+}
+
+describe('agent loop (live model)', () => {
+  it.skipIf(!LIVE)(
+    'calls query_project and narrates the real focus',
+    async () => {
+      const client = createChatClient({ baseUrl: BASE, model: MODEL }, globalThis.fetch as unknown as FetchLike)
+      const turn = await runAgentTurn({
+        complete: (m, t) => client.complete(m, t),
+        messages: [
+          { role: 'system', content: REGINALD_SYSTEM },
+          { role: 'user', content: 'What should I work on right now?' },
+        ],
+        tools: REGINALD_TOOLS,
+        execute: async (name, args) =>
+          name === 'query_project'
+            ? buildProjectView((args as { view: any }).view, (args as any).filters, SNAP, new Date())
+            : { error: `unknown tool ${name}` },
+      })
+
+      // it consulted the project, then answered in prose about the real top item (#2)
+      expect(turn.steps.some((s) => s.tool === 'query_project')).toBe(true)
+      expect(turn.content.trim().length).toBeGreaterThan(0)
+      expect(turn.content).toMatch(/#?2\b|ChangeSource/i)
+    },
+    60_000,
+  )
+
+  it.skipIf(!LIVE)(
+    'records a standing instruction via record_directive',
+    async () => {
+      const client = createChatClient({ baseUrl: BASE, model: MODEL }, globalThis.fetch as unknown as FetchLike)
+      const recorded: unknown[] = []
+      const turn = await runAgentTurn({
+        complete: (m, t) => client.complete(m, t),
+        messages: [
+          { role: 'system', content: REGINALD_SYSTEM },
+          { role: 'user', content: 'Log this standing directive: pilots come first, everything else waits.' },
+        ],
+        tools: REGINALD_TOOLS,
+        execute: async (name, args) => {
+          if (name === 'record_directive') {
+            recorded.push(args)
+            return { recorded: { kind: (args as { kind?: string }).kind ?? 'note' } }
+          }
+          return name === 'query_project'
+            ? buildProjectView((args as { view: any }).view, (args as any).filters, SNAP, new Date())
+            : { error: `unknown tool ${name}` }
+        },
+      })
+
+      // the model logged the directive rather than trying to apply it
+      expect(turn.steps.some((s) => s.tool === 'record_directive')).toBe(true)
+      expect(recorded.length).toBeGreaterThan(0)
+    },
+    60_000,
+  )
+})

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

@@ -0,0 +1,69 @@
+/**
+ * The agent turn loop. Given a model `complete` fn, the conversation, the tool
+ * declarations, and an `execute` that actually runs a tool, it drives the
+ * call→tool→result→call cycle until the model answers in prose (or a step
+ * budget is hit). Pure orchestration with injected I/O — the model and the tool
+ * executor are both stubbable, so the loop is fully unit-testable offline.
+ */
+
+import type { ChatMessage, CompletionResult, ToolDecl } from './chat-client.js'
+
+/** A tool the loop ran, with the raw args and its stringified result — for the UI's activity trail. */
+export interface AgentStep {
+  tool: string
+  arguments: string
+  result: string
+}
+
+export type ToolExecutor = (name: string, args: unknown) => Promise<unknown>
+
+export interface AgentTurn {
+  content: string
+  steps: AgentStep[]
+  /** The full conversation including this turn's assistant/tool messages. */
+  messages: ChatMessage[]
+}
+
+const DEFAULT_MAX_STEPS = 4
+
+function stringify(result: unknown): string {
+  return typeof result === 'string' ? result : JSON.stringify(result)
+}
+
+export async function runAgentTurn(opts: {
+  complete: (messages: ChatMessage[], tools?: ToolDecl[]) => Promise<CompletionResult>
+  messages: ChatMessage[]
+  tools: ToolDecl[]
+  execute: ToolExecutor
+  maxSteps?: number
+}): Promise<AgentTurn> {
+  const maxSteps = opts.maxSteps ?? DEFAULT_MAX_STEPS
+  const convo: ChatMessage[] = [...opts.messages]
+  const steps: AgentStep[] = []
+
+  for (let step = 0; step < maxSteps; step++) {
+    const { content, toolCalls } = await opts.complete(convo, opts.tools)
+    if (toolCalls.length === 0) {
+      convo.push({ role: 'assistant', content })
+      return { content, steps, messages: convo }
+    }
+    convo.push({ role: 'assistant', content, toolCalls })
+    for (const tc of toolCalls) {
+      let result: unknown
+      try {
+        const args = tc.arguments ? JSON.parse(tc.arguments) : {}
+        result = await opts.execute(tc.name, args)
+      } catch (e) {
+        result = { error: e instanceof Error ? e.message : String(e) }
+      }
+      const resultStr = stringify(result)
+      steps.push({ tool: tc.name, arguments: tc.arguments, result: resultStr })
+      convo.push({ role: 'tool', toolCallId: tc.id, name: tc.name, content: resultStr })
+    }
+  }
+
+  // Out of tool budget — force a final prose answer with tools withheld.
+  const final = await opts.complete(convo, [])
+  convo.push({ role: 'assistant', content: final.content })
+  return { content: final.content, steps, messages: convo }
+}

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

@@ -0,0 +1,91 @@
+/**
+ * Reginald's tool surface. v0 ships the one read tool (`query_project`); the
+ * three write tools (capture_work, apply_changes, record_directive) layer on
+ * later against the same loop. Few, fat tools so a small local model survives
+ * with one thing to reach for (docs/agent-tools.md).
+ */
+
+import type { ToolDecl } from './chat-client.js'
+
+export const QUERY_PROJECT_TOOL: ToolDecl = {
+  name: 'query_project',
+  description:
+    'Read the current project state. A `view` selects the shape; deterministic code (scheduler, ' +
+    'lifecycle inference, calibration) backs every number — you report it, you never compute it.',
+  parameters: {
+    type: 'object',
+    properties: {
+      view: {
+        type: 'string',
+        enum: ['focus', 'board', 'calibration', 'issue', 'search'],
+        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.',
+      },
+      filters: {
+        type: 'object',
+        properties: {
+          issueId: { type: 'number' },
+          query: { type: 'string' },
+          limit: { type: 'number' },
+        },
+      },
+    },
+    required: ['view'],
+  },
+}
+
+export const PROPOSE_CHANGE_TOOL: ToolDecl = {
+  name: 'propose_change',
+  description:
+    "Propose an estimate and/or priority change to an issue. This does NOT apply anything — it shows the " +
+    'human a diff to approve. Use it whenever the user asks to re-estimate or reprioritize. After calling it, ' +
+    "tell the user you've *proposed* the change for approval — never say it is done.",
+  parameters: {
+    type: 'object',
+    properties: {
+      issue: { type: 'number', description: 'the issue number to change' },
+      estimate: { type: 'string', enum: ['est/1d', 'est/2d', 'est/3d', 'est/5d', 'est/8d'] },
+      priority: { type: 'string', enum: ['p/1', 'p/2', 'p/3', 'p/4'] },
+    },
+    required: ['issue'],
+  },
+}
+
+export const RECORD_DIRECTIVE_TOOL: ToolDecl = {
+  name: 'record_directive',
+  description:
+    'Log a standing instruction from the PM to the durable directive ledger — a reprioritization, ' +
+    'a re-estimate policy, a deadline, a scope or capacity call, or a plain note. Use it when the user ' +
+    'states intent that should persist ("pilots come first", "freeze scope for beta"). This records the ' +
+    'intent verbatim; the actual issue edits still go through propose_change.',
+  parameters: {
+    type: 'object',
+    properties: {
+      kind: { type: 'string', enum: ['reprioritize', 'reestimate', 'set-deadline', 'scope', 'capacity', 'note'] },
+      quote: { type: 'string', description: "the PM's own words, stored verbatim" },
+      target: {
+        type: 'object',
+        properties: {
+          issue: { type: 'number' },
+          milestone: { type: 'number' },
+          member: { type: 'string' },
+        },
+      },
+      rationale: { type: 'string', description: 'why (optional)' },
+    },
+    required: ['kind', 'quote'],
+  },
+}
+
+export const REGINALD_TOOLS: ToolDecl[] = [QUERY_PROJECT_TOOL, PROPOSE_CHANGE_TOOL, RECORD_DIRECTIVE_TOOL]
+
+export const REGINALD_SYSTEM = [
+  'You are Reginald, the calm, dry project manager inside CommiTea — a tool that runs projects on Gitea.',
+  'Call query_project to ground every answer in the real project; never invent issues, numbers, or dates.',
+  'The scheduler and forecasts are deterministic code — report their output, do not recompute it.',
+  'To change an estimate or priority, call propose_change — it shows the human a diff to approve.',
+  'When the PM states standing intent ("pilots first", "freeze scope"), call record_directive to log it.',
+  'Never claim a change is applied; you propose, the human approves. Forecasts are ranges, never single dates.',
+  'Refer to issues as #<number>. Be brief and plain — a sentence or two. No preamble, no bullet dumps.',
+].join(' ')

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

@@ -0,0 +1,239 @@
+import { describe, expect, it } from 'vitest'
+
+import { extractLabelFacts } from '../labels/label-schema.js'
+import type { GiteaIssue } from '../gitea/types.js'
+import type { FetchLike } from '../gitea/types.js'
+import { type ChatMessage, type CompletionResult, createChatClient, type ToolDecl } from './chat-client.js'
+import { runAgentTurn } from './agent-loop.js'
+import { pickModel } from './model-router.js'
+import { buildProjectView, type ProjectSnapshot } from './query-project.js'
+
+// ---- chat client ----
+
+describe('createChatClient', () => {
+  function stub(body: unknown) {
+    const calls: { url: string; body: unknown }[] = []
+    const fetch: FetchLike = (url, init) => {
+      calls.push({ url, body: init?.body ? JSON.parse(init.body) : undefined })
+      return Promise.resolve({
+        ok: true,
+        status: 200,
+        json: () => Promise.resolve(body),
+        text: () => Promise.resolve(''),
+      })
+    }
+    return { fetch, calls }
+  }
+
+  it('POSTs to /chat/completions and parses content', async () => {
+    const { fetch, calls } = stub({ choices: [{ message: { content: 'the focus is #2' } }] })
+    const client = createChatClient({ baseUrl: 'http://localhost:1234/v1', model: 'gemma' }, fetch)
+    const res = await client.complete([{ role: 'user', content: 'what now?' }])
+
+    expect(res.content).toBe('the focus is #2')
+    expect(res.toolCalls).toEqual([])
+    expect(calls[0].url).toBe('http://localhost:1234/v1/chat/completions')
+    expect((calls[0].body as { model: string }).model).toBe('gemma')
+  })
+
+  it('parses tool calls from the wire shape', async () => {
+    const { fetch } = stub({
+      choices: [
+        {
+          message: {
+            content: null,
+            tool_calls: [{ id: 'c1', function: { name: 'query_project', arguments: '{"view":"focus"}' } }],
+          },
+        },
+      ],
+    })
+    const client = createChatClient({ baseUrl: 'http://x/v1', model: 'm' }, fetch)
+    const res = await client.complete([{ role: 'user', content: 'x' }], [{ name: 'query_project', description: '', parameters: {} }])
+    expect(res.toolCalls).toEqual([{ id: 'c1', name: 'query_project', arguments: '{"view":"focus"}' }])
+  })
+
+  it('serializes assistant tool_calls + tool results in the request', async () => {
+    const { fetch, calls } = stub({ choices: [{ message: { content: 'ok' } }] })
+    const client = createChatClient({ baseUrl: 'http://x/v1', model: 'm' }, fetch)
+    const convo: ChatMessage[] = [
+      { role: 'user', content: 'hi' },
+      { role: 'assistant', content: '', toolCalls: [{ id: 'c1', name: 'query_project', arguments: '{}' }] },
+      { role: 'tool', toolCallId: 'c1', name: 'query_project', content: '{"now":null}' },
+    ]
+    await client.complete(convo)
+    const sent = (calls[0].body as { messages: Record<string, unknown>[] }).messages
+    expect(sent[1].tool_calls).toBeDefined()
+    expect(sent[2]).toEqual({ role: 'tool', tool_call_id: 'c1', content: '{"now":null}' })
+  })
+})
+
+// ---- model router ----
+
+describe('pickModel', () => {
+  const router = { small: { baseUrl: 'u', model: 'small' }, big: { baseUrl: 'u', model: 'big' } }
+  it('routes plan → big, everything else → small', () => {
+    expect(pickModel(router, 'plan').model).toBe('big')
+    expect(pickModel(router, 'ritual').model).toBe('small')
+  })
+})
+
+// ---- agent loop ----
+
+describe('runAgentTurn', () => {
+  const tools: ToolDecl[] = [{ name: 'query_project', description: '', parameters: {} }]
+
+  it('runs a tool then returns the model prose, recording the step', async () => {
+    // first completion asks for a tool; second answers in prose
+    const scripted: CompletionResult[] = [
+      { content: '', toolCalls: [{ id: 'c1', name: 'query_project', arguments: '{"view":"focus"}' }] },
+      { content: 'Right now: #2.', toolCalls: [] },
+    ]
+    let i = 0
+    const executed: { name: string; args: unknown }[] = []
+    const turn = await runAgentTurn({
+      complete: async () => scripted[i++],
+      messages: [{ role: 'user', content: 'what now?' }],
+      tools,
+      execute: async (name, args) => {
+        executed.push({ name, args })
+        return { now: { issue: 2 } }
+      },
+    })
+
+    expect(turn.content).toBe('Right now: #2.')
+    expect(turn.steps).toEqual([
+      { tool: 'query_project', arguments: '{"view":"focus"}', result: '{"now":{"issue":2}}' },
+    ])
+    expect(executed).toEqual([{ name: 'query_project', args: { view: 'focus' } }])
+    // conversation carries user → assistant(tool) → tool → assistant(prose)
+    expect(turn.messages.map((m) => m.role)).toEqual(['user', 'assistant', 'tool', 'assistant'])
+  })
+
+  it('answers directly when the model needs no tool', async () => {
+    const turn = await runAgentTurn({
+      complete: async () => ({ content: 'Hello.', toolCalls: [] }),
+      messages: [{ role: 'user', content: 'hi' }],
+      tools,
+      execute: async () => ({}),
+    })
+    expect(turn.content).toBe('Hello.')
+    expect(turn.steps).toEqual([])
+  })
+
+  it('captures a tool executor error as the tool result instead of throwing', async () => {
+    const scripted: CompletionResult[] = [
+      { content: '', toolCalls: [{ id: 'c1', name: 'query_project', arguments: '{}' }] },
+      { content: 'Something went wrong reading that.', toolCalls: [] },
+    ]
+    let i = 0
+    const turn = await runAgentTurn({
+      complete: async () => scripted[i++],
+      messages: [{ role: 'user', content: 'x' }],
+      tools,
+      execute: async () => {
+        throw new Error('boom')
+      },
+    })
+    expect(turn.steps[0].result).toContain('boom')
+    expect(turn.content).toBe('Something went wrong reading that.')
+  })
+
+  it('forces a final prose answer when the step budget is exhausted', async () => {
+    // always asks for a tool; the loop must still terminate with prose
+    let toolRounds = 0
+    const turn = await runAgentTurn({
+      complete: async (_m, tls) => {
+        if (tls && tls.length) {
+          toolRounds++
+          return { content: '', toolCalls: [{ id: `c${toolRounds}`, name: 'query_project', arguments: '{}' }] }
+        }
+        return { content: 'final answer', toolCalls: [] } // called with tools withheld
+      },
+      messages: [{ role: 'user', content: 'x' }],
+      tools,
+      execute: async () => ({}),
+      maxSteps: 2,
+    })
+    expect(toolRounds).toBe(2)
+    expect(turn.content).toBe('final answer')
+  })
+})
+
+// ---- query_project view builder ----
+
+describe('buildProjectView', () => {
+  const asOf = new Date('2026-02-01T00:00:00Z')
+
+  function issue(over: Partial<GiteaIssue>): GiteaIssue {
+    const labels = over.labels ?? []
+    return {
+      number: 1,
+      title: '#1',
+      body: '',
+      state: 'open',
+      labels,
+      facts: extractLabelFacts(labels),
+      milestone: null,
+      assignee: null,
+      assignees: [],
+      createdAt: '2026-01-05T09:00:00Z',
+      updatedAt: '2026-01-05T09:00:00Z',
+      closedAt: null,
+      url: '',
+      ...over,
+    }
+  }
+
+  const snap: ProjectSnapshot = {
+    issues: [
+      issue({ number: 2, title: 'ChangeSource', labels: ['est/3d', 'p/1'] }),
+      issue({ number: 3, title: 'SQLite cache', labels: ['est/2d', 'p/1'] }),
+      issue({ number: 9, title: 'Done thing', state: 'closed', labels: ['est/2d'], closedAt: '2026-01-12T09:00:00Z' }),
+    ],
+    timelines: { 9: [{ type: 'commit', at: '2026-01-07T09:00:00Z' }, { type: 'close', at: '2026-01-12T09:00:00Z' }] },
+    deps: [{ issue: 3, dependsOn: 2 }],
+  }
+
+  it('focus returns Now/Next/Later grounded in the scheduler', () => {
+    const v = buildProjectView('focus', undefined, snap, asOf) as {
+      now: { issue: number } | null
+      openCount: number
+    }
+    expect(v.now?.issue).toBe(2) // #3 depends on #2, so #2 comes first
+    expect(v.openCount).toBe(2)
+  })
+
+  it('board groups issues by lifecycle column', () => {
+    const v = buildProjectView('board', undefined, snap, asOf) as {
+      columns: { column: string; count: number }[]
+    }
+    const done = v.columns.find((c) => c.column === 'done')
+    expect(done?.count).toBe(1) // #9
+    const triage = v.columns.find((c) => c.column === 'triage')
+    expect(triage?.count).toBe(2) // #2, #3 labelled, no commits yet
+  })
+
+  it('calibration reports n + cold-start honestly', () => {
+    const v = buildProjectView('calibration', undefined, snap, asOf) as { n: number; coldStart: boolean }
+    expect(v.n).toBe(1) // one closed, estimated, with an actual
+    expect(v.coldStart).toBe(true)
+  })
+
+  it('issue returns intent + derived for a specific id', () => {
+    const v = buildProjectView('issue', { issueId: 3 }, snap, asOf) as {
+      issue: number
+      blockedBy: number[]
+    }
+    expect(v.issue).toBe(3)
+    expect(v.blockedBy).toEqual([2])
+  })
+
+  it('search matches title/labels', () => {
+    const v = buildProjectView('search', { query: 'sqlite' }, snap, asOf) as { results: { issue: number }[] }
+    expect(v.results.map((r) => r.issue)).toEqual([3])
+  })
+
+  it('unbuilt views return a notImplemented marker, not fabricated data', () => {
+    expect(buildProjectView('standup', undefined, snap, asOf)).toEqual({ notImplemented: 'standup' })
+  })
+})

packages/core/src/agent/capture-work.test.ts

@@ -0,0 +1,65 @@
+import { describe, expect, it } from 'vitest'
+
+import type { CompletionResult } from './chat-client.js'
+import { captureWork, parseCaptureArgs } from './capture-work.js'
+
+describe('parseCaptureArgs', () => {
+  it('validates issues and keeps only real titles + valid labels', () => {
+    const p = parseCaptureArgs({
+      issues: [
+        { title: 'Fix token refresh', body: 'dies silently', estimate: 'est/2d', priority: 'p/1' },
+        { title: '  ', body: 'blank title dropped' },
+        { title: 'Docs', estimate: 'est/9d', priority: 'urgent' }, // invalid labels → dropped to undefined
+      ],
+      consequence: 'Beta slips a day',
+    })
+    expect(p.issues).toHaveLength(2)
+    expect(p.issues[0]).toEqual({ title: 'Fix token refresh', body: 'dies silently', estimate: 'est/2d', priority: 'p/1' })
+    expect(p.issues[1]).toEqual({ title: 'Docs', body: '', estimate: undefined, priority: undefined })
+    expect(p.consequence).toBe('Beta slips a day')
+  })
+
+  it('tolerates a missing/!array issues field', () => {
+    expect(parseCaptureArgs({}).issues).toEqual([])
+    expect(parseCaptureArgs({ issues: 'nope' }).issues).toEqual([])
+  })
+})
+
+describe('captureWork', () => {
+  it('forces propose_issues and returns the validated set', async () => {
+    const result: CompletionResult = {
+      content: '',
+      toolCalls: [
+        {
+          id: 'c1',
+          name: 'propose_issues',
+          arguments: JSON.stringify({
+            issues: [{ title: 'Retry token refresh with backoff', body: '', estimate: 'est/2d', priority: 'p/2' }],
+            consequence: 'no material shift',
+          }),
+        },
+      ],
+    }
+    let sawTool = ''
+    const proposal = await captureWork(async (_m, tools) => {
+      sawTool = tools?.[0]?.name ?? ''
+      return result
+    }, 'auth is flaky, token refresh dies')
+    expect(sawTool).toBe('propose_issues')
+    expect(proposal.issues[0].title).toBe('Retry token refresh with backoff')
+    expect(proposal.consequence).toBe('no material shift')
+  })
+
+  it('returns an empty set when the model answers without the tool', async () => {
+    const proposal = await captureWork(async () => ({ content: 'I need more detail.', toolCalls: [] }), 'vague')
+    expect(proposal.issues).toEqual([])
+  })
+
+  it('survives malformed tool arguments', async () => {
+    const proposal = await captureWork(
+      async () => ({ content: '', toolCalls: [{ id: 'c1', name: 'propose_issues', arguments: '{not json' }] }),
+      'x',
+    )
+    expect(proposal.issues).toEqual([])
+  })
+})

packages/core/src/agent/capture-work.ts

@@ -0,0 +1,109 @@
+/**
+ * capture_work — braindump → a small set of concrete issues. This is the one
+ * place the big model earns its keep (decomposition + estimate negotiation).
+ * It returns a *proposal*; nothing is filed until the human approves it in the
+ * Capture tray and it goes through the create-issue write path. Pure
+ * orchestration over an injected `complete` — stubbable, so it's testable offline.
+ */
+
+import {
+  type EstimateLabel,
+  ESTIMATE_LABELS,
+  type PriorityLabel,
+  PRIORITY_LABELS,
+} from '../labels/label-schema.js'
+import type { ChatMessage, CompletionResult, ToolDecl } from './chat-client.js'
+
+export interface ProposedIssue {
+  title: string
+  body: string
+  estimate?: EstimateLabel
+  priority?: PriorityLabel
+}
+
+export interface CaptureProposal {
+  issues: ProposedIssue[]
+  /** One-line schedule impact, if the model offered one. */
+  consequence?: string
+}
+
+export const PROPOSE_ISSUES_TOOL: ToolDecl = {
+  name: 'propose_issues',
+  description: 'Return the decomposed issue set for a braindump. Call this exactly once.',
+  parameters: {
+    type: 'object',
+    properties: {
+      issues: {
+        type: 'array',
+        items: {
+          type: 'object',
+          properties: {
+            title: { type: 'string', description: 'a clear imperative title' },
+            body: { type: 'string', description: 'one or two lines of detail' },
+            estimate: { type: 'string', enum: ['est/1d', 'est/2d', 'est/3d', 'est/5d', 'est/8d'] },
+            priority: { type: 'string', enum: ['p/1', 'p/2', 'p/3', 'p/4'] },
+          },
+          required: ['title'],
+        },
+      },
+      consequence: { type: 'string', description: 'one-line note on the schedule impact' },
+    },
+    required: ['issues'],
+  },
+}
+
+export const CAPTURE_SYSTEM = [
+  'You are Reginald, decomposing a rough braindump into a small set of concrete Gitea issues.',
+  'Call propose_issues exactly once. Split genuinely separate work; merge trivially-coupled work; invent no scope.',
+  'Each issue gets an imperative title, a one-line body, an estimate (est/1d…8d) and a priority (p/1…4).',
+  'Estimate honestly — a "quick" task is rarely one day. Keep the set tight; three good issues beat eight vague ones.',
+].join(' ')
+
+function isEstimate(v: unknown): v is EstimateLabel {
+  return typeof v === 'string' && (ESTIMATE_LABELS as readonly string[]).includes(v)
+}
+function isPriority(v: unknown): v is PriorityLabel {
+  return typeof v === 'string' && (PRIORITY_LABELS as readonly string[]).includes(v)
+}
+
+/** Coerce the model's raw propose_issues args into a validated proposal. */
+export function parseCaptureArgs(args: unknown): CaptureProposal {
+  const a = (args ?? {}) as { issues?: unknown[]; consequence?: unknown }
+  const issues: ProposedIssue[] = []
+  for (const raw of Array.isArray(a.issues) ? a.issues : []) {
+    const r = (raw ?? {}) as Record<string, unknown>
+    const title = typeof r.title === 'string' ? r.title.trim() : ''
+    if (!title) continue
+    issues.push({
+      title,
+      body: typeof r.body === 'string' ? r.body : '',
+      estimate: isEstimate(r.estimate) ? r.estimate : undefined,
+      priority: isPriority(r.priority) ? r.priority : undefined,
+    })
+  }
+  return { issues, consequence: typeof a.consequence === 'string' ? a.consequence : undefined }
+}
+
+/**
+ * Run one decomposition turn. Forces the model to answer via propose_issues and
+ * returns the validated set. An empty set means the model declined to structure it.
+ */
+export async function captureWork(
+  complete: (messages: ChatMessage[], tools?: ToolDecl[]) => Promise<CompletionResult>,
+  braindump: string,
+): Promise<CaptureProposal> {
+  const res = await complete(
+    [
+      { role: 'system', content: CAPTURE_SYSTEM },
+      { role: 'user', content: braindump },
+    ],
+    [PROPOSE_ISSUES_TOOL],
+  )
+  const call = res.toolCalls.find((t) => t.name === 'propose_issues')
+  if (!call) return { issues: [] }
+  try {
+    return parseCaptureArgs(JSON.parse(call.arguments || '{}'))
+  } catch {
+    return { issues: [] }
+  }
+}

packages/core/src/agent/chat-client.ts

@@ -0,0 +1,123 @@
+/**
+ * Reginald's model client — a thin OpenAI-wire chat-completions client over an
+ * injected fetch (the same seam the gitea client uses). `@commitea/core` stays
+ * pure: no network, no globals. The desktop main process passes the real
+ * `fetch`; tests pass a stub. Points at any OpenAI-compatible endpoint (LM
+ * Studio, Ollama, the OpenAI API) — the model router picks which.
+ */
+
+import type { FetchLike } from '../gitea/types.js'
+
+/** Where a model lives + which model to ask for. */
+export interface ModelConfig {
+  /** OpenAI-compatible base, including the version segment, e.g. `http://localhost:1234/v1`. */
+  baseUrl: string
+  model: string
+  /** Bearer key; omitted for local servers that don't check it. */
+  apiKey?: string
+}
+
+/** A model's request to run a tool. `arguments` is a raw JSON string (OpenAI shape). */
+export interface ToolCall {
+  id: string
+  name: string
+  arguments: string
+}
+
+/** One turn in the conversation, in our normalized shape. */
+export interface ChatMessage {
+  role: 'system' | 'user' | 'assistant' | 'tool'
+  content: string
+  /** assistant turns that requested tools. */
+  toolCalls?: ToolCall[]
+  /** tool turns: which call they answer. */
+  toolCallId?: string
+  /** tool turns: the function name. */
+  name?: string
+}
+
+/** A tool the model may call — name, description, and a JSON-Schema parameter spec. */
+export interface ToolDecl {
+  name: string
+  description: string
+  parameters: object
+}
+
+export interface CompletionResult {
+  content: string
+  toolCalls: ToolCall[]
+}
+
+export interface ChatClient {
+  complete(messages: ChatMessage[], tools?: ToolDecl[]): Promise<CompletionResult>
+}
+
+/** Map our message shape to the OpenAI wire shape. */
+function toWireMessage(m: ChatMessage): Record<string, unknown> {
+  if (m.role === 'assistant' && m.toolCalls?.length) {
+    return {
+      role: 'assistant',
+      content: m.content || null,
+      tool_calls: m.toolCalls.map((tc) => ({
+        id: tc.id,
+        type: 'function',
+        function: { name: tc.name, arguments: tc.arguments },
+      })),
+    }
+  }
+  if (m.role === 'tool') {
+    return { role: 'tool', tool_call_id: m.toolCallId, content: m.content }
+  }
+  return { role: m.role, content: m.content }
+}
+
+function toWireTool(t: ToolDecl): Record<string, unknown> {
+  return { type: 'function', function: { name: t.name, description: t.description, parameters: t.parameters } }
+}
+
+/** Shape of the one choice we read back. */
+interface RawChoiceMessage {
+  content: string | null
+  tool_calls?: { id: string; function: { name: string; arguments: string } }[]
+}
+
+export function createChatClient(config: ModelConfig, fetchImpl: FetchLike): ChatClient {
+  const url = `${config.baseUrl.replace(/\/+$/, '')}/chat/completions`
+
+  return {
+    async complete(messages, tools) {
+      const body: Record<string, unknown> = {
+        model: config.model,
+        messages: messages.map(toWireMessage),
+        temperature: 0,
+      }
+      if (tools?.length) {
+        body.tools = tools.map(toWireTool)
+        body.tool_choice = 'auto'
+      }
+      const res = await fetchImpl(url, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Accept: 'application/json',
+          ...(config.apiKey ? { Authorization: `Bearer ${config.apiKey}` } : {}),
+        },
+        body: JSON.stringify(body),
+      })
+      if (!res.ok) {
+        const text = await res.text().catch(() => '')
+        throw new Error(`model completion failed (${res.status}): ${text.slice(0, 200)}`)
+      }
+      const json = (await res.json()) as { choices?: { message: RawChoiceMessage }[] }
+      const msg = json.choices?.[0]?.message
+      return {
+        content: msg?.content ?? '',
+        toolCalls: (msg?.tool_calls ?? []).map((tc) => ({
+          id: tc.id,
+          name: tc.function.name,
+          arguments: tc.function.arguments,
+        })),
+      }
+    },
+  }
+}

packages/core/src/agent/model-router.ts

@@ -0,0 +1,22 @@
+/**
+ * Model router (per PLAN.md / decisions.md): prose + the read tool run on a
+ * small local model; decomposition/negotiation earns the big one. Reginald v0
+ * only exercises the small model (read + prose); the `big` slot is declared so
+ * `capture_work` / `record_directive` can route to it without a rewrite.
+ */
+
+import type { ModelConfig } from './chat-client.js'
+
+export type TaskKind = 'ritual' | 'plan'
+
+export interface ModelRouter {
+  /** Small local model — standups, focus prose, the read tool. */
+  small: ModelConfig
+  /** Big model — capture decomposition, directive negotiation. */
+  big: ModelConfig
+}
+
+/** `plan` → the big model; everything else → the small one. */
+export function pickModel(router: ModelRouter, kind: TaskKind): ModelConfig {
+  return kind === 'plan' ? router.big : router.small
+}

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

@@ -0,0 +1,146 @@
+/**
+ * `query_project` — Reginald's single read tool. It selects a compact,
+ * model-friendly view over the reconciled backlog. Every number comes from
+ * 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.
+ */
+
+import { fitCalibration, calibrationSamples } from '../calibration/calibration-v0.js'
+import type { GiteaIssue } from '../gitea/types.js'
+import { inferLifecycle, type LifecycleColumn, type LifecycleEvent } from '../lifecycle/lifecycle-v0.js'
+import { type DependencyEdge, schedule, selectFocus } from '../scheduler/scheduler-v0.js'
+
+export type ProjectView =
+  | 'focus'
+  | 'board'
+  | 'calibration'
+  | 'issue'
+  | 'milestone'
+  | 'runway'
+  | 'standup'
+  | 'search'
+
+export interface QueryFilters {
+  issueId?: number
+  query?: string
+  limit?: number
+}
+
+/** The reconciled inputs a view is built from. */
+export interface ProjectSnapshot {
+  issues: GiteaIssue[]
+  timelines: Record<number, LifecycleEvent[]>
+  deps: DependencyEdge[]
+}
+
+const COLUMN_ORDER: LifecycleColumn[] = ['diagnosis', 'triage', 'steeping', 'review', 'done']
+
+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,
+    }))
+}
+
+function focusView(snap: ProjectSnapshot) {
+  const plan = schedule(toSchedulable(snap.issues), snap.deps)
+  const f = selectFocus(plan)
+  const slot = (item: (typeof plan.items)[number] | null) =>
+    item ? { issue: item.number, title: item.title, rationale: item.rationale } : null
+  return { now: slot(f.now), next: slot(f.next), later: slot(f.later), openCount: plan.items.length }
+}
+
+function boardView(snap: ProjectSnapshot, asOf: Date) {
+  const columns: Record<string, { issue: number; title: string; labels: string[] }[]> = {}
+  for (const key of COLUMN_ORDER) columns[key] = []
+  for (const issue of snap.issues) {
+    const inf = inferLifecycle(issue, snap.timelines[issue.number] ?? [], asOf)
+    columns[inf.column].push({ issue: issue.number, title: issue.title, labels: issue.labels })
+  }
+  return {
+    columns: COLUMN_ORDER.map((key) => ({ column: key, count: columns[key].length, issues: columns[key] })),
+  }
+}
+
+function calibrationView(snap: ProjectSnapshot, asOf: Date) {
+  const model = fitCalibration(calibrationSamples(snap.issues, snap.timelines, asOf))
+  return {
+    n: model.n,
+    coldStart: model.coldStart,
+    globalMultiplier: Number(Math.exp(model.global.mu).toFixed(2)),
+    byBucket: Object.entries(model.byBucket).map(([bucket, fit]) => ({
+      estimate: `est/${bucket}d`,
+      n: fit.n,
+      multiplier: Number(Math.exp(fit.mu).toFixed(2)),
+    })),
+  }
+}
+
+function issueView(snap: ProjectSnapshot, filters: QueryFilters, asOf: Date) {
+  const issue = snap.issues.find((i) => i.number === filters.issueId)
+  if (!issue) return { notFound: filters.issueId ?? null }
+  const inf = inferLifecycle(issue, snap.timelines[issue.number] ?? [], asOf)
+  const blockedBy = snap.deps.filter((d) => d.issue === issue.number).map((d) => d.dependsOn)
+  const blocks = snap.deps.filter((d) => d.dependsOn === issue.number).map((d) => d.issue)
+  return {
+    issue: issue.number,
+    title: issue.title,
+    state: issue.state,
+    column: inf.column,
+    labels: issue.labels,
+    assignee: issue.assignee,
+    milestone: issue.milestone?.title ?? null,
+    estimateDays: issue.facts.estimateDays,
+    priority: issue.facts.priority,
+    steepingDays: inf.steepingDays,
+    blockedBy,
+    blocks,
+  }
+}
+
+function searchView(snap: ProjectSnapshot, filters: QueryFilters) {
+  const q = (filters.query ?? '').toLowerCase().trim()
+  const limit = Math.min(filters.limit ?? 20, 100)
+  const hits = q
+    ? snap.issues.filter(
+        (i) => i.title.toLowerCase().includes(q) || i.labels.some((l) => l.toLowerCase().includes(q)),
+      )
+    : []
+  return {
+    query: filters.query ?? '',
+    results: hits.slice(0, limit).map((i) => ({ issue: i.number, title: i.title, state: i.state, labels: i.labels })),
+  }
+}
+
+/** Build the compact payload for one view. Unknown/unbuilt views return a marker. */
+export function buildProjectView(
+  view: ProjectView,
+  filters: QueryFilters | undefined,
+  snap: ProjectSnapshot,
+  asOf: Date,
+): unknown {
+  const f = filters ?? {}
+  switch (view) {
+    case 'focus':
+      return focusView(snap)
+    case 'board':
+      return boardView(snap, asOf)
+    case 'calibration':
+      return calibrationView(snap, asOf)
+    case 'issue':
+      return issueView(snap, f, asOf)
+    case 'search':
+      return searchView(snap, f)
+    default:
+      return { notImplemented: view }
+  }
+}

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

@@ -0,0 +1,121 @@
+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 {
+  CALIBRATION_BUCKET_FLOOR,
+  calibrationSamples,
+  type CalibrationSample,
+  COLD_START_THRESHOLD,
+  fitCalibration,
+  toDurationModel,
+} from './calibration-v0.js'
+
+function sample(over: Partial<CalibrationSample> = {}): CalibrationSample {
+  return { issue: 1, estimateDays: 2, actualWorkingDays: 2, bucket: 2, person: null, ...over }
+}
+
+describe('fitCalibration', () => {
+  it('is cold-start below the threshold and reports the honest n', () => {
+    const m = fitCalibration([sample(), sample({ actualWorkingDays: 4 })])
+    expect(m.n).toBe(2)
+    expect(m.coldStart).toBe(true)
+  })
+
+  it('flips off cold-start at the threshold', () => {
+    const many = Array.from({ length: COLD_START_THRESHOLD }, (_, i) =>
+      sample({ issue: i, estimateDays: 2, actualWorkingDays: 3, bucket: 2 }),
+    )
+    const m = fitCalibration(many)
+    expect(m.n).toBe(COLD_START_THRESHOLD)
+    expect(m.coldStart).toBe(false)
+  })
+
+  it('recovers the global median ratio (mu = mean log-ratio)', () => {
+    // every actual is exactly 2x its estimate → mu = ln 2
+    const m = fitCalibration(Array.from({ length: 25 }, (_, i) => sample({ issue: i, estimateDays: 2, actualWorkingDays: 4 })))
+    expect(m.global.mu).toBeCloseTo(Math.log(2), 6)
+  })
+
+  it('fits a bucket only once it clears the floor', () => {
+    const twos = Array.from({ length: CALIBRATION_BUCKET_FLOOR }, (_, i) =>
+      sample({ issue: i, estimateDays: 2, actualWorkingDays: 3, bucket: 2 }),
+    )
+    const oneThin = [sample({ issue: 99, estimateDays: 5, actualWorkingDays: 9, bucket: 5 })]
+    const m = fitCalibration([...twos, ...oneThin])
+    expect(m.byBucket[2]?.n).toBe(CALIBRATION_BUCKET_FLOOR)
+    expect(m.byBucket[5]).toBeUndefined() // only 1 sample, below floor
+  })
+
+  it('drops non-positive estimates/actuals', () => {
+    const m = fitCalibration([sample({ actualWorkingDays: 0 }), sample({ estimateDays: 0 }), sample()])
+    expect(m.n).toBe(1)
+  })
+
+  it('derives a per-person bias relative to global', () => {
+    // one person consistently runs longer than the mean
+    const base = Array.from({ length: 20 }, (_, i) => sample({ issue: i, actualWorkingDays: 2, person: 'ak' }))
+    const slow = Array.from({ length: 3 }, (_, i) => sample({ issue: 100 + i, actualWorkingDays: 6, person: 'sm' }))
+    const m = fitCalibration([...base, ...slow])
+    expect(m.byPerson['sm'].biasMu).toBeGreaterThan(0)
+    expect(m.byPerson['ak'].biasMu).toBeLessThan(0)
+  })
+})
+
+describe('toDurationModel', () => {
+  it('projects the fit down to the params forecast needs', () => {
+    const m = fitCalibration(
+      Array.from({ length: 25 }, (_, i) => sample({ issue: i, estimateDays: 2, actualWorkingDays: 3, bucket: 2 })),
+    )
+    const dm = toDurationModel(m)
+    expect(dm.coldStart).toBe(false)
+    expect(dm.byBucket[2].mu).toBeCloseTo(m.byBucket[2].mu, 6)
+    expect(dm.global.mu).toBeCloseTo(m.global.mu, 6)
+  })
+})
+
+describe('calibrationSamples', () => {
+  const asOf = new Date('2026-02-01T00:00:00Z')
+
+  function issue(over: Partial<GiteaIssue>): GiteaIssue {
+    const labels = over.labels ?? []
+    return {
+      number: 1,
+      title: '#1',
+      body: '',
+      state: 'closed',
+      labels,
+      facts: extractLabelFacts(labels),
+      milestone: null,
+      assignee: null,
+      assignees: [],
+      createdAt: '2026-01-05T09:00:00Z',
+      updatedAt: '2026-01-12T09:00:00Z',
+      closedAt: '2026-01-12T09:00:00Z',
+      url: '',
+      ...over,
+    }
+  }
+
+  const events = (i: number): Record<number, LifecycleEvent[]> => ({
+    [i]: [{ type: 'commit', at: '2026-01-07T09:00:00Z' }, { type: 'close', at: '2026-01-12T09:00:00Z' }],
+  })
+
+  it('samples closed, estimated issues with a resolvable actual', () => {
+    const i = issue({ number: 7, labels: ['est/2d'], assignee: 'sm', closedAt: '2026-01-12T09:00:00Z' })
+    const [s] = calibrationSamples([i], events(7), asOf)
+    expect(s.issue).toBe(7)
+    expect(s.estimateDays).toBe(2)
+    expect(s.bucket).toBe(2)
+    expect(s.person).toBe('sm')
+    // Wed 2026-01-07 → Mon 2026-01-12 = Wed,Thu,Fri = 3 working days
+    expect(s.actualWorkingDays).toBe(3)
+  })
+
+  it('skips open issues and closed ones without an estimate', () => {
+    const open = issue({ number: 8, state: 'open', labels: ['est/2d'], closedAt: null })
+    const noEst = issue({ number: 9, labels: [] })
+    expect(calibrationSamples([open, noEst], { ...events(8), ...events(9) }, asOf)).toEqual([])
+  })
+})

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

@@ -0,0 +1,127 @@
+/**
+ * Calibration, v0 — fit the team's own estimate-vs-actual history so the
+ * forecast stops guessing (D3). The "actual" is the working time lifecycle
+ * inference derives from git events (#5), never manual tracking. Fit a
+ * lognormal on log(actual / estimate) globally and per estimate bucket; until
+ * the sample clears the cold-start threshold, the forecast keeps using the
+ * code-resident priors and this model just reports progress toward it.
+ */
+
+import { type DurationModel, type LognormalPrior, nearestBucket } from '../forecast/forecast-v0.js'
+import { inferLifecycle, type LifecycleEvent } from '../lifecycle/lifecycle-v0.js'
+import type { GiteaIssue } from '../gitea/types.js'
+
+/** Global sample size at which the fit takes over from the cold-start priors. */
+export const COLD_START_THRESHOLD = 20
+/** Minimum per-bucket sample before that bucket earns its own fit. */
+export const CALIBRATION_BUCKET_FLOOR = 3
+/** Fallback spread when a group is too small to estimate one. */
+const DEFAULT_SIGMA = 0.4
+
+/** One closed issue's estimate vs its inferred actual. */
+export interface CalibrationSample {
+  issue: number
+  estimateDays: number
+  actualWorkingDays: number
+  bucket: number
+  person: string | null
+}
+
+export interface BucketFit extends LognormalPrior {
+  n: number
+}
+
+export interface PersonBias {
+  /** Additive to global mu (log space). */
+  biasMu: number
+  n: number
+}
+
+export interface CalibrationModel {
+  /** Closed issues with an estimate + a resolvable actual. */
+  n: number
+  /** true while n < COLD_START_THRESHOLD — forecast keeps the code priors. */
+  coldStart: boolean
+  global: LognormalPrior
+  byBucket: Record<number, BucketFit>
+  byPerson: Record<string, PersonBias>
+}
+
+function mean(xs: number[]): number {
+  return xs.reduce((a, b) => a + b, 0) / xs.length
+}
+
+/** Sample standard deviation; falls back to DEFAULT_SIGMA below 2 points. */
+function stddev(xs: number[], mu: number): number {
+  if (xs.length < 2) return DEFAULT_SIGMA
+  const variance = xs.reduce((a, x) => a + (x - mu) ** 2, 0) / (xs.length - 1)
+  return Math.sqrt(variance) || DEFAULT_SIGMA
+}
+
+/** Fit a calibration model from estimate-vs-actual samples. Pure. */
+export function fitCalibration(samples: CalibrationSample[]): CalibrationModel {
+  const usable = samples.filter((s) => s.estimateDays > 0 && s.actualWorkingDays > 0)
+  const n = usable.length
+  const coldStart = n < COLD_START_THRESHOLD
+
+  const logRatios = usable.map((s) => Math.log(s.actualWorkingDays / s.estimateDays))
+  const globalMu = n ? mean(logRatios) : 0
+  const global: LognormalPrior = { mu: globalMu, sigma: n ? stddev(logRatios, globalMu) : DEFAULT_SIGMA }
+
+  const byBucket: Record<number, BucketFit> = {}
+  const byPerson: Record<string, PersonBias> = {}
+  const groups = new Map<number, number[]>()
+  const people = new Map<string, number[]>()
+  for (const s of usable) {
+    const lr = Math.log(s.actualWorkingDays / s.estimateDays)
+    ;(groups.get(s.bucket) ?? groups.set(s.bucket, []).get(s.bucket)!).push(lr)
+    if (s.person) (people.get(s.person) ?? people.set(s.person, []).get(s.person)!).push(lr)
+  }
+  for (const [bucket, lrs] of groups) {
+    if (lrs.length < CALIBRATION_BUCKET_FLOOR) continue
+    const mu = mean(lrs)
+    byBucket[bucket] = { mu, sigma: stddev(lrs, mu), n: lrs.length }
+  }
+  for (const [person, lrs] of people) {
+    if (lrs.length < CALIBRATION_BUCKET_FLOOR) continue
+    byPerson[person] = { biasMu: mean(lrs) - globalMu, n: lrs.length }
+  }
+
+  return { n, coldStart, global, byBucket, byPerson }
+}
+
+/** The subset of a model `forecast` consumes. */
+export function toDurationModel(model: CalibrationModel): DurationModel {
+  const byBucket: Record<number, LognormalPrior> = {}
+  for (const [bucket, fit] of Object.entries(model.byBucket)) {
+    byBucket[Number(bucket)] = { mu: fit.mu, sigma: fit.sigma }
+  }
+  return { coldStart: model.coldStart, global: model.global, byBucket }
+}
+
+/**
+ * Extract calibration samples from the closed backlog: each closed issue that
+ * carries an estimate and yields an inferred actual working duration.
+ */
+export function calibrationSamples(
+  issues: GiteaIssue[],
+  timelines: Record<number, LifecycleEvent[]>,
+  asOf: Date,
+): CalibrationSample[] {
+  const out: CalibrationSample[] = []
+  for (const issue of issues) {
+    if (issue.state !== 'closed') continue
+    const estimateDays = issue.facts.estimateDays
+    if (estimateDays == null) continue
+    const inf = inferLifecycle(issue, timelines[issue.number] ?? [], asOf)
+    if (inf.actualWorkingDays == null || inf.actualWorkingDays <= 0) continue
+    out.push({
+      issue: issue.number,
+      estimateDays,
+      actualWorkingDays: inf.actualWorkingDays,
+      bucket: nearestBucket(estimateDays),
+      person: issue.assignee,
+    })
+  }
+  return out
+}

packages/core/src/changes/apply-changes-v0.test.ts

@@ -0,0 +1,79 @@
+import { describe, expect, it } from 'vitest'
+
+import { describeChange, type IssueChange, planIssueChange, proposalsFor } from './apply-changes-v0.js'
+
+describe('planIssueChange', () => {
+  it('swaps the estimate label, keeping non-axis labels', () => {
+    const plan = planIssueChange(['est/2d', 'p/1', 'backend'], { kind: 'reestimate', issue: 1, estimate: 'est/5d' })
+    expect(plan.removed).toEqual(['est/2d'])
+    expect(plan.added).toEqual(['est/5d'])
+    expect(plan.labels).toEqual(['p/1', 'backend', 'est/5d'])
+    expect(plan.noop).toBe(false)
+  })
+
+  it('adds an estimate when none was set', () => {
+    const plan = planIssueChange(['p/2'], { kind: 'reestimate', issue: 1, estimate: 'est/1d' })
+    expect(plan.removed).toEqual([])
+    expect(plan.added).toEqual(['est/1d'])
+    expect(plan.labels).toEqual(['p/2', 'est/1d'])
+  })
+
+  it('clears the axis when the target is null', () => {
+    const plan = planIssueChange(['est/3d', 'p/1'], { kind: 'reprioritize', issue: 1, priority: null })
+    expect(plan.removed).toEqual(['p/1'])
+    expect(plan.added).toEqual([])
+    expect(plan.labels).toEqual(['est/3d'])
+  })
+
+  it('is a noop when the target already holds the axis alone', () => {
+    const plan = planIssueChange(['est/2d', 'p/1'], { kind: 'reestimate', issue: 1, estimate: 'est/2d' })
+    expect(plan.noop).toBe(true)
+    expect(plan.labels).toEqual(['p/1', 'est/2d'])
+  })
+
+  it('cleans up a duplicated axis down to the target', () => {
+    // two est/* labels — the change collapses to one
+    const plan = planIssueChange(['est/2d', 'est/5d', 'p/1'], { kind: 'reestimate', issue: 1, estimate: 'est/5d' })
+    expect(plan.removed).toEqual(['est/2d'])
+    expect(plan.added).toEqual([]) // est/5d already present
+    expect(plan.labels).toEqual(['p/1', 'est/5d'])
+    expect(plan.noop).toBe(false)
+  })
+
+  it('reprioritize only touches the priority axis', () => {
+    const plan = planIssueChange(['est/2d', 'p/3'], { kind: 'reprioritize', issue: 1, priority: 'p/1' })
+    expect(plan.labels).toEqual(['est/2d', 'p/1'])
+  })
+
+  it('describeChange renders the diff', () => {
+    const change: IssueChange = { kind: 'reestimate', issue: 1, estimate: 'est/5d' }
+    expect(describeChange(planIssueChange(['est/2d'], change))).toBe('est/2d → est/5d')
+    expect(describeChange(planIssueChange(['p/1'], { kind: 'reprioritize', issue: 1, priority: null }))).toBe('p/1 → ∅')
+    expect(describeChange(planIssueChange(['est/5d'], change))).toBe('no change')
+  })
+})
+
+describe('proposalsFor', () => {
+  it('builds one proposal per changed axis, carrying the concrete change + diff', () => {
+    const props = proposalsFor({ issue: 2, estimate: 'est/5d', priority: 'p/1' }, ['est/2d', 'p/3'], 'ChangeSource')
+    expect(props).toHaveLength(2)
+    expect(props[0].change).toEqual({ kind: 'reestimate', issue: 2, estimate: 'est/5d' })
+    expect(describeChange(props[0].plan)).toBe('est/2d → est/5d')
+    expect(props[1].change).toEqual({ kind: 'reprioritize', issue: 2, priority: 'p/1' })
+    expect(props[0].issueTitle).toBe('ChangeSource')
+  })
+
+  it('drops a noop axis (already at the requested value)', () => {
+    const props = proposalsFor({ issue: 2, estimate: 'est/2d', priority: 'p/1' }, ['est/2d', 'p/3'])
+    expect(props.map((p) => p.change.kind)).toEqual(['reprioritize']) // estimate unchanged
+  })
+
+  it('ignores invalid label values from the model', () => {
+    const props = proposalsFor({ issue: 2, estimate: 'est/4d' as never, priority: 'high' as never }, [])
+    expect(props).toEqual([])
+  })
+
+  it('returns nothing when no axis is provided', () => {
+    expect(proposalsFor({ issue: 2 }, ['est/2d'])).toEqual([])
+  })
+})

packages/core/src/changes/apply-changes-v0.ts

@@ -0,0 +1,104 @@
+/**
+ * Apply-changes, v0 — the write path's planning half. Estimates and priority
+ * live as exclusive label axes (`est/*`, `p/*`); a change swaps the axis label.
+ * This computes the resulting label set + a human-readable diff *purely*, so the
+ * UI can show a propose-approve consequence before the write and tests can pin
+ * the semantics. The actual PUT (name→id resolution + network) is the bridge's
+ * job — additive here, never assumed.
+ */
+
+import {
+  type EstimateLabel,
+  ESTIMATE_LABELS,
+  type PriorityLabel,
+  PRIORITY_LABELS,
+} from '../labels/label-schema.js'
+
+export type IssueChange =
+  | { kind: 'reestimate'; issue: number; estimate: EstimateLabel | null }
+  | { kind: 'reprioritize'; issue: number; priority: PriorityLabel | null }
+
+export interface LabelPlan {
+  /** The full resulting label-name set (order: kept labels, then the new axis label). */
+  labels: string[]
+  /** Axis labels being added (0 or 1). */
+  added: string[]
+  /** Axis labels being removed (includes clearing a duplicated axis). */
+  removed: string[]
+  /** true when the change would leave the labels unchanged. */
+  noop: boolean
+}
+
+function axisFor(change: IssueChange): { labels: readonly string[]; target: string | null } {
+  return change.kind === 'reestimate'
+    ? { labels: ESTIMATE_LABELS, target: change.estimate }
+    : { labels: PRIORITY_LABELS, target: change.priority }
+}
+
+/**
+ * Plan the label mutation for a single change. Removes every label on the
+ * change's axis except the target, adds the target if absent. Setting the axis
+ * to null clears it. Cleans up a duplicated axis (two `est/*`) as a side effect.
+ */
+export function planIssueChange(current: string[], change: IssueChange): LabelPlan {
+  const { labels: axis, target } = axisFor(change)
+  const onAxis = current.filter((l) => axis.includes(l))
+  const removed = onAxis.filter((l) => l !== target)
+  const added = target && !current.includes(target) ? [target] : []
+  const kept = current.filter((l) => !axis.includes(l))
+  const labels = target ? [...kept, target] : kept
+  return { labels, added, removed, noop: added.length === 0 && removed.length === 0 }
+}
+
+/** A short "est/2d → est/3d" (or "+p/1" / "−est/5d") summary for the confirm UI. */
+export function describeChange(plan: LabelPlan): string {
+  if (plan.noop) return 'no change'
+  const from = plan.removed.length ? plan.removed.join(', ') : '∅'
+  const to = plan.added.length ? plan.added.join(', ') : '∅'
+  return `${from} → ${to}`
+}
+
+/** A change the agent proposes: the concrete op + its diff, ready for approve-then-apply. */
+export interface ChangeProposal {
+  change: IssueChange
+  plan: LabelPlan
+  issueTitle?: string
+}
+
+/** What the `propose_change` tool accepts — a target issue and the axes to set. */
+export interface ProposeChangeArgs {
+  issue: number
+  estimate?: EstimateLabel
+  priority?: PriorityLabel
+}
+
+function isEstimate(v: unknown): v is EstimateLabel {
+  return typeof v === 'string' && (ESTIMATE_LABELS as readonly string[]).includes(v)
+}
+function isPriority(v: unknown): v is PriorityLabel {
+  return typeof v === 'string' && (PRIORITY_LABELS as readonly string[]).includes(v)
+}
+
+/**
+ * Build the concrete, non-noop proposals for a `propose_change` request against
+ * an issue's current labels. Invalid or unchanged axes are dropped — the agent
+ * proposes only real changes, and never a label outside the est/* · p/* axes.
+ */
+export function proposalsFor(
+  args: ProposeChangeArgs,
+  currentLabels: string[],
+  issueTitle?: string,
+): ChangeProposal[] {
+  const out: ChangeProposal[] = []
+  if (isEstimate(args.estimate)) {
+    const change: IssueChange = { kind: 'reestimate', issue: args.issue, estimate: args.estimate }
+    const plan = planIssueChange(currentLabels, change)
+    if (!plan.noop) out.push({ change, plan, issueTitle })
+  }
+  if (isPriority(args.priority)) {
+    const change: IssueChange = { kind: 'reprioritize', issue: args.issue, priority: args.priority }
+    const plan = planIssueChange(currentLabels, change)
+    if (!plan.noop) out.push({ change, plan, issueTitle })
+  }
+  return out
+}

packages/core/src/directives/record-directive-v0.test.ts

@@ -0,0 +1,66 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  appendDirective,
+  makeDirectiveEntry,
+  parseDirectiveLog,
+  serializeDirective,
+  toDirectiveInput,
+} from './record-directive-v0.js'
+
+describe('toDirectiveInput', () => {
+  it('keeps a valid kind + target and drops an empty target', () => {
+    const input = toDirectiveInput({ kind: 'reprioritize', quote: 'pilots first', target: { issue: 87 }, rationale: 'blocked' })
+    expect(input).toEqual({ kind: 'reprioritize', quote: 'pilots first', target: { issue: 87 }, params: undefined, rationale: 'blocked' })
+    expect(toDirectiveInput({ kind: 'note', quote: 'x', target: {} }).target).toBeUndefined()
+  })
+
+  it('falls back to note for an unknown kind', () => {
+    expect(toDirectiveInput({ kind: 'nonsense', quote: 'hmm' }).kind).toBe('note')
+  })
+})
+
+describe('serialize + parse round-trip', () => {
+  const entry = makeDirectiveEntry(
+    { kind: 'reprioritize', quote: 'pilots come first', target: { issue: 87 } },
+    'id-1',
+    '2026-02-01T09:00:00Z',
+  )
+
+  it('serializes to one JSON line', () => {
+    const line = serializeDirective(entry)
+    expect(line).not.toContain('\n')
+    expect(JSON.parse(line)).toMatchObject({ id: 'id-1', kind: 'reprioritize', status: 'accepted' })
+  })
+
+  it('parses a log, orders by ts, and assigns a 1-based seq', () => {
+    const a = serializeDirective(makeDirectiveEntry({ kind: 'note', quote: 'later' }, 'b', '2026-02-02T00:00:00Z'))
+    const b = serializeDirective(makeDirectiveEntry({ kind: 'note', quote: 'earlier' }, 'a', '2026-02-01T00:00:00Z'))
+    const records = parseDirectiveLog(`${a}\n${b}\n`)
+    expect(records.map((r) => r.quote)).toEqual(['earlier', 'later'])
+    expect(records.map((r) => r.seq)).toEqual([1, 2])
+  })
+
+  it('skips blank and corrupt lines without losing the rest', () => {
+    const good = serializeDirective(entry)
+    const records = parseDirectiveLog(`\n{not json\n${good}\n\n`)
+    expect(records).toHaveLength(1)
+    expect(records[0].id).toBe('id-1')
+  })
+})
+
+describe('appendDirective', () => {
+  it('concatenates a newline-terminated entry, normalizing a missing trailing newline', () => {
+    const e1 = makeDirectiveEntry({ kind: 'note', quote: 'one' }, 'i1', '2026-01-01T00:00:00Z')
+    const e2 = makeDirectiveEntry({ kind: 'note', quote: 'two' }, 'i2', '2026-01-02T00:00:00Z')
+    let log = appendDirective('', e1)
+    log = appendDirective(log, e2)
+    expect(parseDirectiveLog(log).map((r) => r.quote)).toEqual(['one', 'two'])
+    expect(log.endsWith('\n')).toBe(true)
+  })
+
+  it('handles existing text without a trailing newline', () => {
+    const e = makeDirectiveEntry({ kind: 'note', quote: 'x' }, 'i', '2026-01-01T00:00:00Z')
+    expect(appendDirective('{"id":"prev","ts":"2025-01-01T00:00:00Z"}', e).split('\n').filter(Boolean)).toHaveLength(2)
+  })
+})

packages/core/src/directives/record-directive-v0.ts

@@ -0,0 +1,106 @@
+/**
+ * record_directive — the PM's standing instructions ("pilots come first"),
+ * appended to an append-only JSONL ledger in the pm-state repo (decisions.md D4,
+ * pm-state.md). A directive is *intent*: it's logged verbatim; its effects land
+ * later through apply_changes. Merge is concatenation — order derives from `ts`
+ * at read time, so two writers never conflict. `seq` is a display ordinal
+ * computed on read, never stored. This module is pure serialize/parse; the
+ * append (read → concat → write) is the bridge's job.
+ */
+
+export type DirectiveKind = 'reprioritize' | 'reestimate' | 'set-deadline' | 'scope' | 'capacity' | 'note'
+
+export type DirectiveStatus = 'proposed' | 'accepted' | 'amended' | 'withdrawn'
+
+export interface DirectiveTarget {
+  issue?: number
+  milestone?: number
+  member?: string
+}
+
+/** What the record_directive tool captures. */
+export interface DirectiveInput {
+  kind: DirectiveKind
+  /** Verbatim PM words, shown in the ledger. */
+  quote: string
+  target?: DirectiveTarget
+  /** Structured effect the scheduler applies, e.g. { priority: 1 }. */
+  params?: Record<string, unknown>
+  rationale?: string
+}
+
+/** A ledger entry — an input plus its durable id/ts/status. */
+export interface DirectiveEntry extends DirectiveInput {
+  id: string
+  ts: string
+  status: DirectiveStatus
+}
+
+/** A ledger entry as read back, with a computed display ordinal. */
+export interface DirectiveRecord extends DirectiveEntry {
+  seq: number
+}
+
+const DIRECTIVE_KINDS: readonly DirectiveKind[] = [
+  'reprioritize',
+  'reestimate',
+  'set-deadline',
+  'scope',
+  'capacity',
+  'note',
+]
+
+/** Normalize a raw tool payload into a DirectiveInput (unknown kind → note). */
+export function toDirectiveInput(raw: unknown): DirectiveInput {
+  const r = (raw ?? {}) as Record<string, unknown>
+  const kind = DIRECTIVE_KINDS.includes(r.kind as DirectiveKind) ? (r.kind as DirectiveKind) : 'note'
+  const target = (r.target ?? undefined) as DirectiveTarget | undefined
+  return {
+    kind,
+    quote: typeof r.quote === 'string' ? r.quote : '',
+    target: target && (target.issue || target.milestone || target.member) ? target : undefined,
+    params: (r.params && typeof r.params === 'object' ? (r.params as Record<string, unknown>) : undefined),
+    rationale: typeof r.rationale === 'string' ? r.rationale : undefined,
+  }
+}
+
+/** Build a full entry from an input + externally-supplied id/ts (Date/uuid live in the caller). */
+export function makeDirectiveEntry(
+  input: DirectiveInput,
+  id: string,
+  ts: string,
+  status: DirectiveStatus = 'accepted',
+): DirectiveEntry {
+  return { ...input, id, ts, status }
+}
+
+/** One JSONL line (no trailing newline — the caller joins). */
+export function serializeDirective(entry: DirectiveEntry): string {
+  return JSON.stringify(entry)
+}
+
+/**
+ * Parse a JSONL log into records ordered by `ts` (then id for stability), with a
+ * 1-based `seq` assigned on read. Blank/corrupt lines are skipped, not fatal.
+ */
+export function parseDirectiveLog(text: string): DirectiveRecord[] {
+  const entries: DirectiveEntry[] = []
+  for (const line of text.split('\n')) {
+    const trimmed = line.trim()
+    if (!trimmed) continue
+    try {
+      const e = JSON.parse(trimmed) as DirectiveEntry
+      if (e && typeof e.id === 'string' && typeof e.ts === 'string') entries.push(e)
+    } catch {
+      // skip a corrupt line rather than lose the whole ledger
+    }
+  }
+  entries.sort((a, b) => (a.ts === b.ts ? a.id.localeCompare(b.id) : a.ts.localeCompare(b.ts)))
+  return entries.map((e, i) => ({ ...e, seq: i + 1 }))
+}
+
+/** Append a serialized entry to existing log text (concatenation merge). */
+export function appendDirective(existing: string, entry: DirectiveEntry): string {
+  const base = existing.endsWith('\n') || existing === '' ? existing : existing + '\n'
+  return `${base}${serializeDirective(entry)}\n`
+}

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

@@ -97,4 +97,27 @@ describe('forecast', () => {
     expect(f.scope).toBe(2)
     expect(f.p50Day).toBeGreaterThan(0)
   })
+
+  it('a cold-start model changes nothing — the code priors still drive it', () => {
+    const priors = forecast(scope, [], { trials: 1000, seed: 7 })
+    const cold = forecast(scope, [], {
+      trials: 1000,
+      seed: 7,
+      model: { coldStart: true, global: { mu: 5, sigma: 0.1 }, byBucket: {} },
+    })
+    expect(cold.coldStart).toBe(true)
+    expect(cold.p50Day).toBeCloseTo(priors.p50Day, 6)
+  })
+
+  it('a fitted model drives the sim once past cold-start', () => {
+    // an optimistic fit (mu < 0, tight sigma) should land the scope sooner than the pessimistic priors
+    const priors = forecast(scope, [], { trials: 2000, seed: 7 })
+    const fitted = forecast(scope, [], {
+      trials: 2000,
+      seed: 7,
+      model: { coldStart: false, global: { mu: -0.2, sigma: 0.1 }, byBucket: {} },
+    })
+    expect(fitted.coldStart).toBe(false)
+    expect(fitted.p50Day).toBeLessThan(priors.p50Day)
+  })
 })

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

@@ -41,15 +41,29 @@ export const COLD_START_PRIORS: Record<number, LognormalPrior> = {
   8: { mu: 0.16, sigma: 0.36 },
 }
 
-const PRIOR_BUCKETS = [1, 2, 3, 5, 8]
+export const PRIOR_BUCKETS = [1, 2, 3, 5, 8]
 
 /** Nearest estimate bucket (ties resolve to the smaller bucket). */
-export function priorForEstimate(days: number): LognormalPrior {
+export function nearestBucket(days: number): number {
   let best = PRIOR_BUCKETS[0]
   for (const b of PRIOR_BUCKETS) {
     if (Math.abs(b - days) < Math.abs(best - days)) best = b
   }
-  return COLD_START_PRIORS[best]
+  return best
+}
+
+/** The cold-start prior for the bucket nearest to `days`. */
+export function priorForEstimate(days: number): LognormalPrior {
+  return COLD_START_PRIORS[nearestBucket(days)]
+}
+
+/** The lognormal parameters `forecast` needs, per estimate bucket. */
+export interface DurationModel {
+  coldStart: boolean
+  /** Fallback params (used when a bucket lacks its own fit). */
+  global: LognormalPrior
+  /** Per-bucket fitted params; missing buckets fall back to `global`. */
+  byBucket: Record<number, LognormalPrior>
 }
 
 export interface ForecastOptions {
@@ -57,6 +71,19 @@ export interface ForecastOptions {
   trials?: number
   /** PRNG seed. Fixed by default so a forecast is reproducible. */
   seed?: number
+  /**
+   * Fitted duration model. When present and not cold-start, its params drive
+   * the sim; otherwise the code-resident cold-start priors do.
+   */
+  model?: DurationModel
+}
+
+/** Resolve the lognormal params for an estimate, preferring a fitted model. */
+export function durationParams(days: number, model?: DurationModel): LognormalPrior {
+  if (model && !model.coldStart) {
+    return model.byBucket[nearestBucket(days)] ?? model.global
+  }
+  return priorForEstimate(days)
 }
 
 export interface BurnUpPoint {
@@ -121,13 +148,14 @@ export function forecast(
 ): Forecast {
   const trials = options.trials ?? DEFAULT_TRIALS
   const seed = options.seed ?? DEFAULT_SEED
+  const coldStart = options.model ? options.model.coldStart : true
   const order = schedule(issues, edges).items // empty when a dependency cycle exists
   const n = order.length
   if (n === 0) {
-    return { scope: 0, trials, coldStart: true, p50Day: 0, p80Day: 0, p95Day: 0, curve: [] }
+    return { scope: 0, trials, coldStart, p50Day: 0, p80Day: 0, p95Day: 0, curve: [] }
   }
 
-  const priors = order.map((it) => priorForEstimate(it.durationDays))
+  const priors = order.map((it) => durationParams(it.durationDays, options.model))
   const rng = mulberry32(seed)
 
   // endByRank[k][t] = working day the (k+1)-th scheduled issue completes on trial t.
@@ -156,7 +184,7 @@ export function forecast(
   return {
     scope: n,
     trials,
-    coldStart: true,
+    coldStart,
     p50Day: percentile(total, 0.5),
     p80Day: percentile(total, 0.8),
     p95Day: percentile(total, 0.95),

packages/core/src/gitea/client.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest'
 
-import { createGiteaClient, normalizeIssue } from './client.js'
+import { createGiteaClient, normalizeIssue, normalizeTimeline } from './client.js'
 import { GiteaApiError, type FetchLike, type GiteaConfig, type GiteaRequestInit } from './types.js'
 
 const CONFIG: GiteaConfig = {
@@ -44,6 +44,31 @@ function stubFetch(body: unknown, status = 200): {
   return { fetch, calls }
 }
 
+describe('normalizeTimeline', () => {
+  it('maps known gitea event types to lifecycle signals and drops the rest', () => {
+    const events = normalizeTimeline([
+      { type: 'label', created_at: '2026-01-06T09:00:00Z' },
+      { type: 'milestone', created_at: '2026-01-06T09:05:00Z' },
+      { type: 'commit_ref', created_at: '2026-01-07T12:00:00Z' },
+      { type: 'pull_ref', created_at: '2026-01-08T12:00:00Z' },
+      { type: 'comment', created_at: '2026-01-08T13:00:00Z' }, // dropped
+      { type: 'add_dependency', created_at: '2026-01-08T14:00:00Z' }, // dropped
+      { type: 'close', created_at: '2026-01-12T09:00:00Z' },
+    ])
+    expect(events).toEqual([
+      { type: 'triage', at: '2026-01-06T09:00:00Z' },
+      { type: 'triage', at: '2026-01-06T09:05:00Z' },
+      { type: 'commit', at: '2026-01-07T12:00:00Z' },
+      { type: 'pull', at: '2026-01-08T12:00:00Z' },
+      { type: 'close', at: '2026-01-12T09:00:00Z' },
+    ])
+  })
+
+  it('skips events missing a timestamp', () => {
+    expect(normalizeTimeline([{ type: 'commit_ref', created_at: '' }])).toEqual([])
+  })
+})
+
 describe('createGiteaClient.getIssue', () => {
   it('returns a normalized, typed issue from canned JSON', async () => {
     const { fetch } = stubFetch(RAW_ISSUE)
@@ -98,6 +123,63 @@ describe('createGiteaClient.getIssue', () => {
     )
   })
 
+  it('setIssueLabels PUTs the label ids to the issue labels endpoint', async () => {
+    const { fetch, calls } = stubFetch(null, 204)
+    await createGiteaClient(CONFIG, fetch).setIssueLabels(9, [3, 7])
+
+    expect(calls).toHaveLength(1)
+    expect(calls[0].url).toBe('https://gitea.stephenmann.io/api/v1/repos/christian/commitea/issues/9/labels')
+    expect(calls[0].init?.method).toBe('PUT')
+    expect(calls[0].init?.headers?.['Content-Type']).toBe('application/json')
+    expect(JSON.parse(calls[0].init?.body ?? '{}')).toEqual({ labels: [3, 7] })
+  })
+
+  it('listLabels returns id+name pairs', async () => {
+    const { fetch } = stubFetch([
+      { id: 3, name: 'est/2d', color: 'fff' },
+      { id: 7, name: 'p/1', color: '000' },
+    ])
+    const labels = await createGiteaClient(CONFIG, fetch).listLabels()
+    expect(labels).toEqual([
+      { id: 3, name: 'est/2d' },
+      { id: 7, name: 'p/1' },
+    ])
+  })
+
+  it('getFile returns null on 404 and content+sha on hit', async () => {
+    const miss = stubFetch('nope', 404)
+    expect(await createGiteaClient(CONFIG, miss.fetch).getFile('directives/log.jsonl')).toBeNull()
+
+    const hit = stubFetch({ content: 'aGVsbG8=\n', sha: 'abc123' })
+    const file = await createGiteaClient(CONFIG, hit.fetch).getFile('directives/log.jsonl')
+    expect(file).toEqual({ contentBase64: 'aGVsbG8=', sha: 'abc123' })
+    expect(hit.calls[0].url).toContain('/contents/directives/log.jsonl')
+  })
+
+  it('putFile POSTs to create and PUTs to update (with sha)', async () => {
+    const create = stubFetch({}, 201)
+    await createGiteaClient(CONFIG, create.fetch).putFile('directives/log.jsonl', { contentBase64: 'eA==', message: 'seed' })
+    expect(create.calls[0].init?.method).toBe('POST')
+    expect(JSON.parse(create.calls[0].init?.body ?? '{}')).toEqual({ content: 'eA==', message: 'seed' })
+
+    const update = stubFetch({}, 200)
+    await createGiteaClient(CONFIG, update.fetch).putFile('directives/log.jsonl', { contentBase64: 'eQ==', message: 'append', sha: 's1' })
+    expect(update.calls[0].init?.method).toBe('PUT')
+    expect(JSON.parse(update.calls[0].init?.body ?? '{}')).toEqual({ content: 'eQ==', message: 'append', sha: 's1' })
+  })
+
+  it('createIssue POSTs title/body/labels and returns a normalized issue', async () => {
+    const created = { ...RAW_ISSUE, number: 44, title: 'Retry token refresh', labels: [{ name: 'est/2d' }, { name: 'p/2' }] }
+    const { fetch, calls } = stubFetch(created, 201)
+    const issue = await createGiteaClient(CONFIG, fetch).createIssue({ title: 'Retry token refresh', body: 'backoff', labelIds: [3, 7] })
+
+    expect(calls[0].url).toBe('https://gitea.stephenmann.io/api/v1/repos/christian/commitea/issues')
+    expect(calls[0].init?.method).toBe('POST')
+    expect(JSON.parse(calls[0].init?.body ?? '{}')).toEqual({ title: 'Retry token refresh', body: 'backoff', labels: [3, 7] })
+    expect(issue.number).toBe(44)
+    expect(issue.labels).toEqual(['est/2d', 'p/2'])
+  })
+
   it('throws GiteaApiError carrying status + body on a non-2xx response', async () => {
     const { fetch } = stubFetch('not found', 404)
     const client = createGiteaClient(CONFIG, fetch)

packages/core/src/gitea/client.ts

@@ -6,12 +6,14 @@
  * get the full set.
  */
 
+import { type LifecycleEvent, type LifecycleEventType } from '../lifecycle/lifecycle-v0.js'
 import { extractLabelFacts } from '../labels/label-schema.js'
 import {
   GiteaApiError,
   type FetchLike,
   type GiteaConfig,
   type GiteaIssue,
+  type GiteaLabel,
   type GiteaMilestone,
   type GiteaMilestoneRef,
 } from './types.js'
@@ -54,6 +56,33 @@ interface RawMilestoneFull {
   closed_issues: number
 }
 
+/** The subset of a gitea timeline comment we read. */
+interface RawTimelineComment {
+  type: string
+  created_at: string
+}
+
+/** gitea timeline `type` → our lifecycle signal. Unmapped types are dropped. */
+const TIMELINE_TYPE_MAP: Record<string, LifecycleEventType> = {
+  label: 'triage',
+  milestone: 'triage',
+  assignees: 'triage',
+  commit_ref: 'commit',
+  pull_ref: 'pull',
+  close: 'close',
+  reopen: 'reopen',
+}
+
+/** Map a raw gitea timeline to normalized lifecycle events. Pure. */
+export function normalizeTimeline(raw: RawTimelineComment[]): LifecycleEvent[] {
+  const out: LifecycleEvent[] = []
+  for (const c of raw) {
+    const type = TIMELINE_TYPE_MAP[c.type]
+    if (type && c.created_at) out.push({ type, at: c.created_at })
+  }
+  return out
+}
+
 export interface ListIssuesOptions {
   /** @default 'all' */
   state?: 'open' | 'closed' | 'all'
@@ -68,6 +97,18 @@ export interface GiteaClient {
   listMilestones(): Promise<GiteaMilestone[]>
   /** The issue indices this issue depends on (its blockers). */
   getIssueDependencies(index: number): Promise<number[]>
+  /** Normalized lifecycle events for one issue (all pages of its timeline). */
+  getIssueTimeline(index: number): Promise<LifecycleEvent[]>
+  /** Every label defined on the repo (id + name), for name→id resolution. */
+  listLabels(): Promise<GiteaLabel[]>
+  /** Replace an issue's entire label set with the given label ids. Write. */
+  setIssueLabels(index: number, labelIds: number[]): Promise<void>
+  /** Open a new issue with a title, optional body, and label ids. Write. */
+  createIssue(input: { title: string; body?: string; labelIds?: number[] }): Promise<GiteaIssue>
+  /** Read a repo file's base64 content + blob sha; null if it (or the repo) is absent. */
+  getFile(path: string): Promise<{ contentBase64: string; sha: string } | null>
+  /** Create or update a repo file with base64 content (pass `sha` to update). Write. */
+  putFile(path: string, input: { contentBase64: string; message: string; sha?: string }): Promise<void>
 }
 
 /** Map raw gitea issue JSON to the normalized domain shape. Pure. */
@@ -114,18 +155,24 @@ export function createGiteaClient(config: GiteaConfig, fetchImpl: FetchLike): Gi
   const apiBase = `${config.baseUrl.replace(/\/+$/, '')}/api/v1`
   const repoBase = `${apiBase}/repos/${config.owner}/${config.repo}`
 
-  async function request(path: string): Promise<unknown> {
+  async function request(path: string, init?: { method?: string; body?: unknown }): Promise<unknown> {
+    const method = init?.method ?? 'GET'
+    const hasBody = init?.body !== undefined
     const res = await fetchImpl(`${repoBase}${path}`, {
+      method,
       headers: {
         Authorization: `token ${config.token}`,
         Accept: 'application/json',
+        ...(hasBody ? { 'Content-Type': 'application/json' } : {}),
       },
+      body: hasBody ? JSON.stringify(init!.body) : undefined,
     })
     if (!res.ok) {
       const body = await res.text().catch(() => '')
-      throw new GiteaApiError(res.status, `GET ${path} failed (${res.status})`, body)
+      throw new GiteaApiError(res.status, `${method} ${path} failed (${res.status})`, body)
     }
-    return res.json()
+    // writes may reply 204 No Content
+    return res.status === 204 ? null : res.json()
   }
 
   /** Follow gitea's page-limit pagination until a short page is returned. */
@@ -163,5 +210,51 @@ export function createGiteaClient(config: GiteaConfig, fetchImpl: FetchLike): Gi
       const raw = (await request(`/issues/${index}/dependencies`)) as { number: number }[]
       return raw.map((d) => d.number)
     },
+
+    async getIssueTimeline(index) {
+      const raw = await requestAll<RawTimelineComment>(
+        (page) => `/issues/${index}/timeline?page=${page}&limit=${PAGE_LIMIT}`,
+      )
+      return normalizeTimeline(raw)
+    },
+
+    async listLabels() {
+      const raw = await requestAll<{ id: number; name: string }>(
+        (page) => `/labels?page=${page}&limit=${PAGE_LIMIT}`,
+      )
+      return raw.map((l) => ({ id: l.id, name: l.name }))
+    },
+
+    async setIssueLabels(index, labelIds) {
+      await request(`/issues/${index}/labels`, { method: 'PUT', body: { labels: labelIds } })
+    },
+
+    async createIssue(input) {
+      const raw = (await request('/issues', {
+        method: 'POST',
+        body: { title: input.title, body: input.body ?? '', labels: input.labelIds ?? [] },
+      })) as RawIssue
+      return normalizeIssue(raw)
+    },
+
+    async getFile(path) {
+      const res = await fetchImpl(`${repoBase}/contents/${path}`, {
+        headers: { Authorization: `token ${config.token}`, Accept: 'application/json' },
+      })
+      if (res.status === 404) return null
+      if (!res.ok) {
+        const body = await res.text().catch(() => '')
+        throw new GiteaApiError(res.status, `GET contents/${path} failed (${res.status})`, body)
+      }
+      const json = (await res.json()) as { content?: string; sha: string }
+      return { contentBase64: (json.content ?? '').replace(/\n/g, ''), sha: json.sha }
+    },
+
+    async putFile(path, input) {
+      await request(`/contents/${path}`, {
+        method: input.sha ? 'PUT' : 'POST',
+        body: { content: input.contentBase64, message: input.message, ...(input.sha ? { sha: input.sha } : {}) },
+      })
+    },
   }
 }

packages/core/src/gitea/types.ts

@@ -35,6 +35,12 @@ export interface GiteaHttpResponse {
 
 export type FetchLike = (url: string, init?: GiteaRequestInit) => Promise<GiteaHttpResponse>
 
+/** A repo label — just the id + name we need for name→id resolution. */
+export interface GiteaLabel {
+  id: number
+  name: string
+}
+
 /** Milestone as referenced from an issue (not the full milestone resource). */
 export interface GiteaMilestoneRef {
   id: number

packages/core/src/index.ts

@@ -9,7 +9,7 @@ export {
 } from './labels/label-schema.js'
 export type { EstimateLabel, LabelFacts, PriorityLabel } from './labels/label-schema.js'
 
-export { createGiteaClient, normalizeIssue, normalizeMilestone } from './gitea/client.js'
+export { createGiteaClient, normalizeIssue, normalizeMilestone, normalizeTimeline } from './gitea/client.js'
 export type { GiteaClient, ListIssuesOptions } from './gitea/client.js'
 export { GiteaApiError } from './gitea/types.js'
 export type {
@@ -17,13 +17,28 @@ export type {
   GiteaConfig,
   GiteaHttpResponse,
   GiteaIssue,
+  GiteaLabel,
   GiteaMilestone,
   GiteaMilestoneRef,
   GiteaRequestInit,
 } from './gitea/types.js'
 
-export { inferColumnV0, LIFECYCLE_COLUMNS } from './lifecycle/lifecycle-v0.js'
+export { describeChange, planIssueChange, proposalsFor } from './changes/apply-changes-v0.js'
-export type { LifecycleColumn } from './lifecycle/lifecycle-v0.js'
+export type { ChangeProposal, IssueChange, LabelPlan, ProposeChangeArgs } from './changes/apply-changes-v0.js'
+
+export {
+  inferColumnV0,
+  inferLifecycle,
+  LIFECYCLE_COLUMNS,
+  workingDaysBetween,
+} from './lifecycle/lifecycle-v0.js'
+export type {
+  LifecycleColumn,
+  LifecycleEvent,
+  LifecycleEventType,
+  LifecycleInference,
+  LifecycleStages,
+} from './lifecycle/lifecycle-v0.js'
 
 export { DEFAULT_ESTIMATE_DAYS, schedule, selectFocus } from './scheduler/scheduler-v0.js'
 export type {
@@ -34,5 +49,66 @@ export type {
   SchedulePlan,
 } from './scheduler/scheduler-v0.js'
 
-export { COLD_START_PRIORS, forecast, priorForEstimate } from './forecast/forecast-v0.js'
+export {
-export type { BurnUpPoint, Forecast, ForecastOptions, LognormalPrior } from './forecast/forecast-v0.js'
+  COLD_START_PRIORS,
+  durationParams,
+  forecast,
+  nearestBucket,
+  PRIOR_BUCKETS,
+  priorForEstimate,
+} from './forecast/forecast-v0.js'
+export type {
+  BurnUpPoint,
+  DurationModel,
+  Forecast,
+  ForecastOptions,
+  LognormalPrior,
+} from './forecast/forecast-v0.js'
+
+export {
+  CALIBRATION_BUCKET_FLOOR,
+  calibrationSamples,
+  COLD_START_THRESHOLD,
+  fitCalibration,
+  toDurationModel,
+} from './calibration/calibration-v0.js'
+export type {
+  BucketFit,
+  CalibrationModel,
+  CalibrationSample,
+  PersonBias,
+} from './calibration/calibration-v0.js'
+
+export { createChatClient } from './agent/chat-client.js'
+export type { ChatClient, ChatMessage, CompletionResult, ModelConfig, ToolCall, ToolDecl } from './agent/chat-client.js'
+export { pickModel } from './agent/model-router.js'
+export type { ModelRouter, TaskKind } from './agent/model-router.js'
+export { runAgentTurn } from './agent/agent-loop.js'
+export type { AgentStep, AgentTurn, ToolExecutor } from './agent/agent-loop.js'
+export {
+  PROPOSE_CHANGE_TOOL,
+  QUERY_PROJECT_TOOL,
+  RECORD_DIRECTIVE_TOOL,
+  REGINALD_SYSTEM,
+  REGINALD_TOOLS,
+} from './agent/agent-tools.js'
+export { buildProjectView } from './agent/query-project.js'
+export type { ProjectSnapshot, ProjectView, QueryFilters } from './agent/query-project.js'
+export { CAPTURE_SYSTEM, captureWork, parseCaptureArgs, PROPOSE_ISSUES_TOOL } from './agent/capture-work.js'
+export type { CaptureProposal, ProposedIssue } from './agent/capture-work.js'
+
+export {
+  appendDirective,
+  makeDirectiveEntry,
+  parseDirectiveLog,
+  serializeDirective,
+  toDirectiveInput,
+} from './directives/record-directive-v0.js'
+export type {
+  DirectiveEntry,
+  DirectiveInput,
+  DirectiveKind,
+  DirectiveRecord,
+  DirectiveStatus,
+  DirectiveTarget,
+} from './directives/record-directive-v0.js'

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

@@ -1,6 +1,11 @@
 import { describe, expect, it } from 'vitest'
 
-import { inferColumnV0 } from './lifecycle-v0.js'
+import {
+  inferColumnV0,
+  inferLifecycle,
+  type LifecycleEvent,
+  workingDaysBetween,
+} from './lifecycle-v0.js'
 
 const base = { state: 'open' as const, labels: [] as string[], milestone: null }
 
@@ -27,3 +32,93 @@ describe('inferColumnV0', () => {
     expect(['steeping', 'review']).not.toContain(col)
   })
 })
+
+describe('workingDaysBetween', () => {
+  it('counts weekdays in [start, end), excluding weekends', () => {
+    // Mon 2026-01-05 → Mon 2026-01-12 spans a full week = 5 working days
+    expect(workingDaysBetween(new Date('2026-01-05'), new Date('2026-01-12'))).toBe(5)
+  })
+
+  it('is 0 for same day or reversed', () => {
+    expect(workingDaysBetween(new Date('2026-01-05'), new Date('2026-01-05'))).toBe(0)
+    expect(workingDaysBetween(new Date('2026-01-12'), new Date('2026-01-05'))).toBe(0)
+  })
+
+  it('skips a weekend inside the interval', () => {
+    // Fri 2026-01-09 → Mon 2026-01-12: only Fri counts (Sat/Sun excluded) = 1
+    expect(workingDaysBetween(new Date('2026-01-09'), new Date('2026-01-12'))).toBe(1)
+  })
+})
+
+describe('inferLifecycle', () => {
+  const openBase = { ...base, createdAt: '2026-01-05T09:00:00Z', closedAt: null }
+  const asOf = new Date('2026-01-14T09:00:00Z')
+
+  const ev = (type: LifecycleEvent['type'], at: string): LifecycleEvent => ({ type, at })
+
+  it('bare open issue with no events is diagnosis', () => {
+    const inf = inferLifecycle(openBase, [], asOf)
+    expect(inf.column).toBe('diagnosis')
+    expect(inf.stages.opened).toBe(openBase.createdAt)
+    expect(inf.actualWorkingDays).toBeNull()
+    expect(inf.steepingDays).toBeNull()
+  })
+
+  it('a triage event (or a current label) moves it to triage', () => {
+    expect(inferLifecycle(openBase, [ev('triage', '2026-01-06T09:00:00Z')], asOf).column).toBe('triage')
+    expect(inferLifecycle({ ...openBase, labels: ['p/1'] }, [], asOf).column).toBe('triage')
+  })
+
+  it('a commit ref moves an open issue to steeping and counts its working age', () => {
+    const inf = inferLifecycle(
+      { ...openBase, labels: ['est/2d'] },
+      [ev('triage', '2026-01-05T10:00:00Z'), ev('commit', '2026-01-07T12:00:00Z')],
+      asOf,
+    )
+    expect(inf.column).toBe('steeping')
+    expect(inf.stages.steeping).toBe('2026-01-07T12:00:00Z')
+    // Wed 2026-01-07 → Wed 2026-01-14 = 5 working days
+    expect(inf.steepingDays).toBe(5)
+  })
+
+  it('a pull ref outranks a commit ref → review', () => {
+    const inf = inferLifecycle(
+      openBase,
+      [ev('commit', '2026-01-07T12:00:00Z'), ev('pull', '2026-01-08T12:00:00Z')],
+      asOf,
+    )
+    expect(inf.column).toBe('review')
+    expect(inf.steepingDays).toBeNull() // only steeping issues carry an age
+  })
+
+  it('closed → done, with actual working time from work-start to close', () => {
+    const inf = inferLifecycle(
+      { ...openBase, state: 'closed', closedAt: '2026-01-12T09:00:00Z' },
+      [ev('commit', '2026-01-07T09:00:00Z'), ev('pull', '2026-01-08T09:00:00Z'), ev('close', '2026-01-12T09:00:00Z')],
+      asOf,
+    )
+    expect(inf.column).toBe('done')
+    expect(inf.stages.done).toBe('2026-01-12T09:00:00Z')
+    // Wed 2026-01-07 → Mon 2026-01-12 = Wed,Thu,Fri = 3 working days
+    expect(inf.actualWorkingDays).toBe(3)
+  })
+
+  it('takes the earliest event of each kind for stage timestamps', () => {
+    const inf = inferLifecycle(
+      openBase,
+      [ev('commit', '2026-01-09T09:00:00Z'), ev('commit', '2026-01-07T09:00:00Z')],
+      asOf,
+    )
+    expect(inf.stages.steeping).toBe('2026-01-07T09:00:00Z')
+  })
+
+  it('falls back to opened when a closed issue has no work-start signal', () => {
+    const inf = inferLifecycle(
+      { ...openBase, state: 'closed', closedAt: '2026-01-08T09:00:00Z' },
+      [ev('close', '2026-01-08T09:00:00Z')],
+      asOf,
+    )
+    // Mon 2026-01-05 → Thu 2026-01-08 = Mon,Tue,Wed = 3 working days
+    expect(inf.actualWorkingDays).toBe(3)
+  })
+})

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

@@ -1,12 +1,10 @@
 /**
- * Lifecycle inference, v0 — the coarse column an issue sits in, derived from
+ * Lifecycle inference.
- * *only* what a single issues-list read gives us (state, labels, milestone).
  *
- * The real five-column inference (P1-5) needs the issue timeline: first
+ * `inferColumnV0` places the coarse three columns from a single issues-list
- * branch/commit ref → Steeping, PR opened → In review, PR merged → Deploy.
+ * read (state/labels/milestone). `inferLifecycle` (#5) adds the issue timeline:
- * Until that lands, v0 can only place three columns honestly; `steeping` and
+ * first commit ref → Steeping, first PR ref → In review, close → Done — and
- * `review` stay empty rather than guess. Board renders all five columns and
+ * derives the estimate-vs-actual working time that feeds calibration (D3).
- * fills the middle two once the event stream is available.
  */
 
 import type { GiteaIssue } from '../gitea/types.js'
@@ -23,10 +21,109 @@ export const LIFECYCLE_COLUMNS: readonly LifecycleColumn[] = [
 
 /**
  * Closed → done. Open with any human intent applied (a label or a milestone)
- * → triage. Open and bare → diagnosis. Never returns steeping/review in v0.
+ * → triage. Open and bare → diagnosis. Never returns steeping/review — that's
+ * `inferLifecycle`, which reads the event stream.
  */
 export function inferColumnV0(issue: Pick<GiteaIssue, 'state' | 'labels' | 'milestone'>): LifecycleColumn {
   if (issue.state === 'closed') return 'done'
   const hasIntent = issue.labels.length > 0 || issue.milestone !== null
   return hasIntent ? 'triage' : 'diagnosis'
 }
+
+/** A timeline signal, normalized from gitea's raw event stream. */
+export type LifecycleEventType = 'triage' | 'commit' | 'pull' | 'close' | 'reopen'
+
+export interface LifecycleEvent {
+  type: LifecycleEventType
+  /** ISO timestamp. */
+  at: string
+}
+
+/** Timestamps for the stages an issue has reached (absent = not yet reached). */
+export interface LifecycleStages {
+  opened: string
+  /** First label / milestone / assignment. */
+  triaged?: string
+  /** First commit referencing the issue — work began. */
+  steeping?: string
+  /** First PR referencing the issue — in review. */
+  review?: string
+  /** Closed. */
+  done?: string
+}
+
+export interface LifecycleInference {
+  column: LifecycleColumn
+  stages: LifecycleStages
+  /**
+   * Working days from work-start (steeping → triaged → opened, first available)
+   * to done. Only for closed issues — this is the "actual" calibration learns
+   * from. null while open.
+   */
+  actualWorkingDays: number | null
+  /** Working days the issue has been steeping (first commit → asOf); null unless currently steeping. */
+  steepingDays: number | null
+}
+
+const DAY_MS = 86_400_000
+
+/**
+ * Whole working days (Mon–Fri) in the half-open interval [start, end). Same day
+ * or reversed → 0. Day-granular by design — estimates are in days.
+ */
+export function workingDaysBetween(start: Date, end: Date): number {
+  const s = Date.UTC(start.getUTCFullYear(), start.getUTCMonth(), start.getUTCDate())
+  const e = Date.UTC(end.getUTCFullYear(), end.getUTCMonth(), end.getUTCDate())
+  if (e <= s) return 0
+  let count = 0
+  for (let t = s; t < e; t += DAY_MS) {
+    const dow = new Date(t).getUTCDay()
+    if (dow !== 0 && dow !== 6) count += 1
+  }
+  return count
+}
+
+/**
+ * The five-column inference. Column reflects the furthest stage still in play:
+ * closed → done; else an open PR ref → review; else a commit ref → steeping;
+ * else any triage signal (or a current label/milestone) → triage; else
+ * diagnosis. Stage timestamps are the earliest event of each kind.
+ */
+export function inferLifecycle(
+  issue: Pick<GiteaIssue, 'state' | 'labels' | 'milestone' | 'createdAt' | 'closedAt'>,
+  events: LifecycleEvent[],
+  asOf: Date,
+): LifecycleInference {
+  const sorted = [...events].sort((a, b) => a.at.localeCompare(b.at))
+  const firstOf = (type: LifecycleEventType) => sorted.find((e) => e.type === type)?.at
+
+  const stages: LifecycleStages = { opened: issue.createdAt }
+  const triagedAt = firstOf('triage')
+  const steepingAt = firstOf('commit')
+  const reviewAt = firstOf('pull')
+  if (triagedAt) stages.triaged = triagedAt
+  if (steepingAt) stages.steeping = steepingAt
+  if (reviewAt) stages.review = reviewAt
+  const doneAt = issue.state === 'closed' ? (issue.closedAt ?? firstOf('close')) : undefined
+  if (doneAt) stages.done = doneAt
+
+  let column: LifecycleColumn
+  if (issue.state === 'closed') column = 'done'
+  else if (reviewAt) column = 'review'
+  else if (steepingAt) column = 'steeping'
+  else if (triagedAt || issue.labels.length > 0 || issue.milestone !== null) column = 'triage'
+  else column = 'diagnosis'
+
+  let actualWorkingDays: number | null = null
+  if (stages.done) {
+    const start = stages.steeping ?? stages.triaged ?? stages.opened
+    actualWorkingDays = workingDaysBetween(new Date(start), new Date(stages.done))
+  }
+
+  let steepingDays: number | null = null
+  if (column === 'steeping' && stages.steeping) {
+    steepingDays = workingDaysBetween(new Date(stages.steeping), asOf)
+  }
+
+  return { column, stages, actualWorkingDays, steepingDays }
+}