feat: Reginald follows the model you load (auto-detect) + shows it in the header

Instead of a hardcoded model name (which forces LM Studio to JIT-swap your loaded model out — and fails when a big model already fills memory), resolve the model at request time: an explicit env override wins, else ask the server which model is *loaded* (LM Studio's native /api/v0/models), else the first non-embedding model, else a default. Reginald now uses whatever you load, no config churn. - main/model.ts: resolveLoadedModel() drives both model:status and model:chat; COMMITEA_MODEL_SMALL still overrides. - useChat exposes the resolved model id; the panel header shows it (google/gemma-4-26b-a4b-qat → "gemma-4-26b-a4b · local"). - live-reginald e2e: header assertion relaxed to the loaded model; timeouts raised for a slow big local model (~2 calls/turn + a reconcile). Verified: 14 fixture e2e green; live e2e drives the app against the loaded gemma-4-26b — "What now?" → "You should work on #2 … on the critical path, unblocks #33 and #4" (the real scheduler pick), header shows the live model. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
feat: Reginald is real — model router + agent loop + query_project (P4)
2026-07-08 21:03:23 -04:00 · 2026-07-08 20:43:02 -04:00
29 changed files with 74 additions and 1675 deletions
--- a/apps/desktop/e2e/live-backlog.spec.ts
+++ b/apps/desktop/e2e/live-backlog.spec.ts
@@ -45,21 +45,6 @@ test.describe('live backlog', () => {
    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()
  })
 })
--- a/apps/desktop/e2e/live-capture.spec.ts
+++ b/apps/desktop/e2e/live-capture.spec.ts
@@ -1,37 +0,0 @@
 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()
  })
 })
--- a/apps/desktop/e2e/live-directive.spec.ts
+++ b/apps/desktop/e2e/live-directive.spec.ts
@@ -1,32 +0,0 @@
 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()
  })
 })
--- a/apps/desktop/e2e/live-persistence.spec.ts
+++ b/apps/desktop/e2e/live-persistence.spec.ts
@@ -1,37 +0,0 @@
 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). A real launch persists the snapshot; a second launch with
 // gitea unreachable must still show the board + real scheduler output from the
 // persisted cache (offline reads). No model needed.
 test.describe('live persistence', () => {
  test('offline: serves the persisted snapshot', async () => {
    test.skip(!process.env.GITEA_LIVE, 'GITEA_LIVE not set — opt-in live test')
    test.setTimeout(120_000)
    // launch 1 — real reconcile writes the snapshot to disk
    const app1 = await electron.launch({ args: [MAIN], env: { ...process.env } })
    const w1 = await app1.firstWindow()
    await w1.waitForLoadState('domcontentloaded')
    // a scheduler-only phrase confirms real data reconciled (never emitted by fixtures)
    await expect(w1.getByText(/on the critical path|unblocks #|waits on #|· ready/).first()).toBeVisible({ timeout: 30000 })
    await app1.close()
    // launch 2 — gitea unreachable; the reconcile must fall back to the persisted snapshot
    const app2 = await electron.launch({
      args: [MAIN],
      env: { ...process.env, GITEA_BASE_URL: 'http://127.0.0.1:9' },
    })
    const w2 = await app2.firstWindow()
    await w2.waitForLoadState('domcontentloaded')
    // Focus still renders real scheduler output — proving it came from the cache, offline
    await expect(w2.getByText(/on the critical path|unblocks #|waits on #|· ready/).first()).toBeVisible({ timeout: 20000 })
    await w2.screenshot({ path: join(here, '.artifacts', 'screens', 'live-offline.png'), fullPage: true, animations: 'disabled' })
    await app2.close()
  })
 })
--- a/apps/desktop/e2e/live-reginald.spec.ts
+++ b/apps/desktop/e2e/live-reginald.spec.ts
@@ -30,27 +30,4 @@ test.describe('live Reginald', () => {
    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()
  })
 })
--- a/apps/desktop/src/main/gitea.ts
+++ b/apps/desktop/src/main/gitea.ts
@@ -6,29 +6,18 @@
 * properly later.
 */
 import { randomUUID } from 'node:crypto'
 import { readFileSync } from 'node:fs'
 import { dirname, join } from 'node:path'
 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'
 import { loadSnapshot, saveSnapshot } from './snapshot-store.js'
 /** Walk up from cwd looking for a .env.local with a GITEA_TOKEN (dev convenience). */
 function loadEnvLocalToken(): string | undefined {
  let dir = process.cwd()
@@ -70,45 +59,6 @@ export function getGiteaClient(): GiteaClient | null {
  return sharedClient
 }
 // 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
 }
 const DIRECTIVE_LOG_PATH = 'directives/log.jsonl'
 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,
@@ -128,142 +78,20 @@ export async function reconcileSnapshot(
  return { issues, milestones, deps, timelines }
 }
 type Snapshot = Awaited<ReturnType<typeof reconcileSnapshot>>
 /**
 * A single in-memory reconcile cache shared across the app. A full reconcile is
 * ~2N gitea calls (deps + timelines per issue); without this, every agent tool
 * call refetched the whole repo. Reads within `maxAgeMs` reuse the cache;
 * `getSnapshot({ maxAgeMs: 0 })` forces a fresh pull (the explicit UI reconcile),
 * and any write calls `invalidateSnapshot()` so the next read sees it. The cache
 * is rebuildable — the durable truth stays in gitea (the purity split, D4).
 */
 let snapshotCache: { snap: Snapshot; at: number } | null = null
 export async function getSnapshot(client: GiteaClient, opts?: { maxAgeMs?: number }): Promise<Snapshot> {
  const maxAgeMs = opts?.maxAgeMs ?? 0
  if (snapshotCache && maxAgeMs > 0 && Date.now() - snapshotCache.at <= maxAgeMs) {
    return snapshotCache.snap
  }
  const snap = await reconcileSnapshot(client)
  snapshotCache = { snap, at: Date.now() }
  saveSnapshot(snap, new Date().toISOString()) // persist for instant boot + offline
  return snap
 }
 /** Drop the cache so the next read reflects a just-made write. */
 export function invalidateSnapshot(): void {
  snapshotCache = null
 }
 /**
 * The last persisted snapshot (from a previous session), for instant boot. The
 * renderer shows it immediately, then a real reconcile supersedes it
 * (stale-while-revalidate). Returns null when there's nothing on disk; its
 * `savedAt` marks staleness. It does NOT seed the cache — agent tool calls
 * always reconcile fresh so they never reason over stale data.
 */
 export function bootSnapshot(): (Snapshot & { savedAt: string }) | null {
  const persisted = loadSnapshot()
  if (!persisted) return null
  return {
    issues: persisted.issues,
    milestones: persisted.milestones,
    deps: persisted.deps,
    timelines: persisted.timelines,
    savedAt: persisted.savedAt,
  } as unknown as Snapshot & { savedAt: string }
 }
 /** Agent tool calls tolerate a slightly stale snapshot (seconds) to stay responsive. */
 export const AGENT_SNAPSHOT_TTL_MS = 30_000
 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 }))
  // Instant boot: the last persisted snapshot, shown before the fresh reconcile lands.
  ipcMain.handle('gitea:boot', () => {
    if (!client) return { configured: false }
    const persisted = bootSnapshot()
    return persisted ? { configured: true, cached: true, ...persisted } : { configured: true, cached: false }
  })
  ipcMain.handle('gitea:reconcile', async () => {
    if (!client) return { configured: false, issues: [], milestones: [], deps: [], timelines: {} }
-    try {
+    const snap = await reconcileSnapshot(client)
-      // explicit UI sync — force fresh, and warm the cache for agent tool calls
+    return { configured: true, ...snap }
      const snap = await getSnapshot(client, { maxAgeMs: 0 })
      return { configured: true, stale: false, ...snap }
    } catch (e) {
      // offline / gitea down — serve the last persisted snapshot rather than error out
      const persisted = bootSnapshot()
      if (persisted) return { configured: true, stale: true, ...persisted }
      throw e
    }
  })
  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)
    invalidateSnapshot() // the board + forecast must reflect the label change
    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 })
      }
      if (created.length) invalidateSnapshot() // new issues enter the board/scope
      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) }
    }
  })
 }
--- a/apps/desktop/src/main/model.ts
+++ b/apps/desktop/src/main/model.ts
@@ -9,30 +9,18 @@
 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 {
+import { getGiteaClient, reconcileSnapshot } from './gitea.js'
  AGENT_SNAPSHOT_TTL_MS,
  appendDirectiveEntry,
  getGiteaClient,
  getPmStateClient,
  getSnapshot,
 } from './gitea.js'
 /** Small local model for prose + the read tool; big model reserved for later decomposition. */
 function resolveModelRouter(): ModelRouter | null {
@@ -92,39 +80,12 @@ export function registerModelIpc(): void {
    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 (name !== 'query_project') return { error: `unknown tool: ${name}` }
      if (!client) return { error: 'gitea is not configured' }
-      if (name === 'query_project') {
+      const snap = await reconcileSnapshot(client)
-        // reuse a recent reconcile — a multi-tool turn shouldn't refetch the repo each call
+      const a = (args ?? {}) as { view: ProjectView; filters?: QueryFilters }
-        const snap = await getSnapshot(client, { maxAgeMs: AGENT_SNAPSHOT_TTL_MS })
+      return buildProjectView(a.view, a.filters, snap, new Date())
        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 {
@@ -134,22 +95,7 @@ export function registerModelIpc(): void {
        tools: REGINALD_TOOLS,
        execute,
      })
-      return { ok: true as const, content: turn.content, steps: turn.steps, proposals }
+      return { ok: true as const, content: turn.content, steps: turn.steps }
    } 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) }
    }
--- a/apps/desktop/src/main/snapshot-store.ts
+++ b/apps/desktop/src/main/snapshot-store.ts
@@ -1,47 +0,0 @@
 /**
 * Durable snapshot store — the reconcile cache, persisted to disk. On boot the
 * app shows the last snapshot instantly (stale-while-revalidate) instead of a
 * blank board while ~2N gitea calls run; if gitea is unreachable, reads fall
 * back to it (offline). It's a rebuildable mirror — the durable truth stays in
 * gitea (the purity split, D4). A plain JSON file: the whole snapshot fits in
 * memory at this scale, so indexed SQL buys nothing yet (see the PR).
 */
 import { readFileSync, writeFileSync } from 'node:fs'
 import { join } from 'node:path'
 import { app } from 'electron'
 /** The shape we persist — kept loose so a schema drift degrades to "no cache", not a crash. */
 export interface PersistedSnapshot {
  issues: unknown[]
  milestones: unknown[]
  deps: unknown[]
  timelines: Record<number, unknown[]>
  /** ISO time the snapshot was reconciled — shown as "cached since". */
  savedAt: string
 }
 function snapshotPath(): string {
  return join(app.getPath('userData'), 'commitea-snapshot.json')
 }
 /** Load the last persisted snapshot, or null if absent/corrupt. Never throws. */
 export function loadSnapshot(): PersistedSnapshot | null {
  try {
    const parsed = JSON.parse(readFileSync(snapshotPath(), 'utf8')) as PersistedSnapshot
    if (parsed && Array.isArray(parsed.issues)) return parsed
    return null
  } catch {
    return null // missing file, bad JSON, or drift — treat as no cache
  }
 }
 /** Persist a freshly reconciled snapshot. Best-effort — a write failure never breaks a reconcile. */
 export function saveSnapshot(snap: Omit<PersistedSnapshot, 'savedAt'>, savedAt: string): void {
  try {
    writeFileSync(snapshotPath(), JSON.stringify({ ...snap, savedAt }), 'utf8')
  } catch {
    // disk full / permissions — the in-memory cache still works this session
  }
 }
--- a/apps/desktop/src/preload/index.ts
+++ b/apps/desktop/src/preload/index.ts
@@ -5,28 +5,16 @@ const api = {
  gitea: {
    /** Whether the main process has a gitea token + target repo configured. */
    status: () => ipcRenderer.invoke('gitea:status'),
    /** The last persisted snapshot, for instant boot before the fresh reconcile. */
    boot: () => ipcRenderer.invoke('gitea:boot'),
    /** Full read of the managed repo — every issue + milestone. */
    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),
  },
 }
--- a/apps/desktop/src/renderer/src/components/screens/capture-screen.tsx
+++ b/apps/desktop/src/renderer/src/components/screens/capture-screen.tsx
@@ -1,12 +1,8 @@
 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
@@ -34,64 +30,6 @@ 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
@@ -125,23 +63,19 @@ export function CaptureScreen({ onDone }: { onDone: () => void }) {
    else setStage('review')
  }
-  // draft tickets build as the interview progresses (scripted demo path)
+  // draft tickets build as the interview progresses
-  const scripted: Ticket[] = []
+  const tickets: Ticket[] = []
  if (split === true) {
-    scripted.push({ title: 'Token refresh: retry with backoff', est: 'est/2d', p: 'p/2' })
+    tickets.push({ title: 'Token refresh: retry with backoff', est: 'est/2d', p: 'p/2' })
-    scripted.push({ title: 'Session storage: stale reads on wake', est: 'est/1d', p: 'p/3' })
+    tickets.push({ title: 'Session storage: stale reads on wake', est: 'est/1d', p: 'p/3' })
  } else if (split === false) {
-    scripted.push({ title: 'Auth: token refresh + session storage', est: 'est/3d', p: 'p/2' })
+    tickets.push({ title: 'Auth: token refresh + session storage', est: 'est/3d', p: 'p/2' })
  }
-  if (webEst) scripted.push({ title: 'Webhook debounce: double-fire guard', est: webEst, p: 'p/1', dep: 'blocked by auth work' })
+  if (webEst) tickets.push({ title: 'Webhook debounce: double-fire guard', est: webEst, p: 'p/1', dep: 'blocked by auth work' })
-  if (!live && (stage === 'review' || stage === 'filed')) {
+  if (stage === 'review' || stage === 'filed') {
-    scripted.push({ title: 'Docs: auth setup guide', est: 'est/1d', p: 'p/4', byReginald: true })
+    tickets.push({ title: 'Docs: auth setup guide', est: 'est/1d', p: 'p/4', byReginald: true })
  }
-  // real capture_work output overrides the scripted set when present
+  const totalDays = tickets.reduce((n, t) => n + parseInt(t.est.replace('est/', '')), 0)
  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 }))
@@ -162,20 +96,8 @@ export function CaptureScreen({ onDone }: { onDone: () => void }) {
            <div style={{ display: 'flex', alignItems: 'center', gap: 8, flexWrap: 'wrap' }}>
              {editable ? (
                <>
-                  <Select
+                  <Select options={estOptions} defaultValue={t.est} style={{ width: 96 }} />
-                    options={estOptions}
+                  <Select options={pOptions} defaultValue={t.p} style={{ width: 76 }} />
                    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 }}
                  />
                </>
              ) : (
                <>
@@ -222,12 +144,7 @@ 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={() => void onBrew()} disabled={brewing}>
+          <Button icon="sparkles" onClick={() => setStage('interview')}>Brew tickets</Button>
            {brewing ? 'Brewing…' : 'Brew tickets'}
          </Button>
          {error ? (
            <p style={{ font: 'var(--text-agent)', color: 'var(--danger)', margin: '10px 0 0' }}>{error}</p>
          ) : null}
        </Card>
      ) : null}
@@ -257,26 +174,15 @@ 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={() => (live ? fileLive() : setStage('filed'))} disabled={brewing}>
+                  <Button onClick={() => setStage('filed')}>Approve all</Button>
-                    {brewing ? 'Filing…' : 'Approve all'}
+                  <Button variant="ghost" onClick={() => { setStage('dump'); setQi(0); setLog([]); setSplit(null); setWebEst(null); setSecs(0); }}>Discard</Button>
                  </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-body)', margin: '0 0 8px' }}>
-              <p style={{ font: 'var(--text-agent)', color: 'var(--ink-2)', margin: 0 }}>
+              Beta's 80% window moves <span style={{ font: 'var(--text-data)' }}>Mar 3–12 → Mar 5–14</span>. Capacity absorbs the rest.
-                {tickets.length} issue{tickets.length === 1 ? '' : 's'} from your braindump, estimated and prioritized.
+            </p>
-                Adjust the labels, then approve — I'll open them in gitea with only est/* and p/* labels.
+            <p style={{ font: 'var(--text-agent)', color: 'var(--ink-2)', margin: 0 }}>
-              </p>
+              I added the docs ticket you mentioned and wired the dependency. Shall I make it so?
-            ) : (
+            </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>
@@ -289,7 +195,7 @@ export function CaptureScreen({ onDone }: { onDone: () => void }) {
              <Icon name="circle-check" size={22} /> Filed
            </span>
            <p style={{ font: 'var(--text-body)', margin: 0 }}>
-              {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.
+              {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.
--- a/apps/desktop/src/renderer/src/components/screens/directives-screen.tsx
+++ b/apps/desktop/src/renderer/src/components/screens/directives-screen.tsx
@@ -8,35 +8,6 @@ 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',
--- a/apps/desktop/src/renderer/src/components/screens/issue-screen.tsx
+++ b/apps/desktop/src/renderer/src/components/screens/issue-screen.tsx
@@ -1,33 +1,17 @@
 // Issue detail — human intent (gitea) on the left, machine-derived (pm-state) on the right
-import React, { useState } from 'react'
+import React 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, Dialog, Icon, Select, Tag } from '../ui/index.js'
+import { Badge, Button, Card, Icon, 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',
@@ -56,44 +40,6 @@ 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 */}
@@ -119,69 +65,10 @@ export function IssueScreen({
              </span>
            </div>
          </div>
-          <div style={{ display: 'flex', gap: 8, flexShrink: 0 }}>
+          <Button variant="secondary" icon="arrow-up-right">Open in Gitea</Button>
            {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 }}>
--- a/apps/desktop/src/renderer/src/components/shell/app-shell.tsx
+++ b/apps/desktop/src/renderer/src/components/shell/app-shell.tsx
@@ -1,8 +1,6 @@
 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 { backlogCalibration, forecastBacklog, issuesToBoardColumns, scheduleFocus } from '../../lib/backlog.js'
 import { useBacklog } from '../../lib/use-backlog.js'
@@ -87,7 +85,7 @@ export function AppShell() {
  const [offline, setOffline] = useState(false)
  const [issue, setIssue] = useState<IssueRef | null>(null)
  const [readIds, setReadIds] = useState<number[]>([])
-  const [backlog, refetchBacklog] = useBacklog()
+  const backlog = useBacklog()
  const boardColumns =
    backlog.status === 'ready' ? issuesToBoardColumns(backlog.issues, backlog.timelines) : undefined
  const focus =
@@ -109,17 +107,6 @@ 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' },
@@ -219,13 +206,7 @@ export function AppShell() {
        return <SettingsScreen dark={dark} setDark={setDark} />
      case 'issue':
        return issue ? (
-          <IssueScreen
+          <IssueScreen issue={issue} onBack={() => setView(prevView)} onOpenIssue={openIssue} />
            issue={issue}
            onBack={() => setView(prevView)}
            onOpenIssue={openIssue}
            canWrite={backlog.status === 'ready'}
            onApplyChange={applyChange}
          />
        ) : null
      case 'states':
        return <StatesScreen onCapture={() => setView('capture')} />
@@ -337,7 +318,7 @@ export function AppShell() {
        </div>
      </main>
-      <ChatPanel onOpenDirectives={() => setView('directives')} offline={offline} onApplyChange={applyChange} />
+      <ChatPanel onOpenDirectives={() => setView('directives')} offline={offline} />
    </div>
  )
 }
--- a/apps/desktop/src/renderer/src/components/shell/chat-panel.tsx
+++ b/apps/desktop/src/renderer/src/components/shell/chat-panel.tsx
@@ -1,25 +1,21 @@
 import React, { useEffect, useRef, useState } from 'react'
 import { describeChange, type IssueChange } from '@commitea/core'
 import { useChat } from '../../lib/use-chat.js'
-import { Button, Icon, IconButton } from '../ui/index.js'
+import { Icon, IconButton } from '../ui/index.js'
 /**
 * Reginald's panel — chat is the write-path (decisions.md D1). Wired to the
- * model bridge via `useChat`: a configured model drives a real agent turn
+ * model bridge via `useChat`: when a model is configured, sending drives a real
- * (query_project + prose, propose_change for edits); otherwise it echoes the
+ * agent turn (query_project + prose); otherwise it echoes the scripted fixture
- * scripted fixture reply. Proposed changes are approved inline here — the write
+ * reply so the layout stays real. Writes still go through propose-approve.
 * 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, onApplyChange }: ChatPanelProps) {
+export function ChatPanel({ onOpenDirectives, offline }: ChatPanelProps) {
-  const { msgs, thinking, live, model, steps, proposals, send: sendChat, approve, dismiss } = useChat(onApplyChange)
+  const { msgs, thinking, live, model, steps, send: sendChat } = useChat()
  // 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('')
@@ -101,36 +97,9 @@ export function ChatPanel({ onOpenDirectives, offline, onApplyChange }: ChatPane
        {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(', ')}
+            <Icon name="eye" size={11} /> consulted {Array.from(new Set(steps.map((s) => s.replace('query_project', 'the project')))).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 }}>
--- a/apps/desktop/src/renderer/src/global.d.ts
+++ b/apps/desktop/src/renderer/src/global.d.ts
@@ -1,83 +1,35 @@
 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)
 /** A reconciled snapshot as it crosses the bridge. */
 export interface SnapshotPayload {
  configured: boolean
  issues: GiteaIssue[]
  milestones: GiteaMilestone[]
  deps: DependencyEdge[]
  /** Normalized lifecycle events keyed by issue number. */
  timelines: Record<number, LifecycleEvent[]>
  /** true when served from the persisted cache (offline / instant boot). */
  stale?: boolean
  /** ISO time the persisted snapshot was reconciled (present on cached reads). */
  savedAt?: string
 }
 /** Boot payload — the persisted snapshot, or a marker that there's none yet. */
 export type BootPayload =
  | { configured: false }
  | { configured: true; cached: false }
  | ({ configured: true; cached: true } & Omit<SnapshotPayload, 'configured'>)
 /** The gitea bridge exposed by the preload over IPC (main-process backed). */
 export interface GiteaBridge {
  status(): Promise<{ configured: boolean; repo: string | null }>
-  boot(): Promise<BootPayload>
+  reconcile(): Promise<{
-  reconcile(): Promise<SnapshotPayload>
+    configured: boolean
    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[] }
+  | { ok: true; content: string; steps: AgentStep[] }
 /** 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 {
@@ -86,7 +38,6 @@ declare global {
      platform: string
      gitea: GiteaBridge
      model: ModelBridge
      pmstate: PmStateBridge
    }
  }
 }
--- a/apps/desktop/src/renderer/src/lib/use-backlog.ts
+++ b/apps/desktop/src/renderer/src/lib/use-backlog.ts
@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useState } from 'react'
+import { useEffect, useState } from 'react'
 import type { DependencyEdge, GiteaIssue, GiteaMilestone, LifecycleEvent } from '@commitea/core'
@@ -12,50 +12,18 @@ export type BacklogState =
      milestones: GiteaMilestone[]
      deps: DependencyEdge[]
      timelines: Record<number, LifecycleEvent[]>
      /** true while showing the persisted snapshot (instant boot / offline). */
      stale: boolean
      /** ISO time the shown snapshot was reconciled, when stale. */
      savedAt?: string
    }
 /**
- * Reconcile the managed repo through the main-process bridge, stale-while-
+ * Reconcile the managed repo once on mount, through the main-process bridge.
- * revalidate: on mount it shows the persisted snapshot instantly (marked stale),
+ * `unconfigured` means no token — the UI falls back to demo fixtures. Errors
- * then a fresh reconcile supersedes it. If gitea is unreachable, the fresh
+ * (network, bad token) surface as `error`.
 * reconcile falls back to the persisted snapshot (offline). `refetch` re-syncs
 * after a write. `unconfigured` means no token — the UI uses demo fixtures.
 */
-export function useBacklog(): [BacklogState, () => void] {
+export function useBacklog(): BacklogState {
  const [state, setState] = useState<BacklogState>({ status: 'loading' })
  const [nonce, setNonce] = useState(0)
  const refetch = useCallback(() => setNonce((n) => n + 1), [])
  useEffect(() => {
    let alive = true
    // instant boot from the persisted snapshot (only on first mount, not refetch)
    if (nonce === 0) {
      window.commitea.gitea
        .boot()
        .then((b) => {
          if (!alive || !('cached' in b) || !b.cached) return
          setState((prev) =>
            prev.status === 'ready' && !prev.stale
              ? prev // a fresh reconcile already won the race
              : {
                  status: 'ready',
                  issues: b.issues,
                  milestones: b.milestones,
                  deps: b.deps,
                  timelines: b.timelines,
                  stale: true,
                  savedAt: b.savedAt,
                },
          )
        })
        .catch(() => {})
    }
    window.commitea.gitea
      .reconcile()
      .then((r) => {
@@ -68,24 +36,17 @@ export function useBacklog(): [BacklogState, () => void] {
                milestones: r.milestones,
                deps: r.deps,
                timelines: r.timelines,
                stale: r.stale ?? false,
                savedAt: r.savedAt,
              }
            : { status: 'unconfigured' },
        )
      })
      .catch((e: unknown) => {
-        if (alive) {
+        if (alive) setState({ status: 'error', message: e instanceof Error ? e.message : String(e) })
          // keep a shown boot snapshot rather than clobbering it with an error
          setState((prev) =>
            prev.status === 'ready' ? prev : { status: 'error', message: e instanceof Error ? e.message : String(e) },
          )
        }
      })
    return () => {
      alive = false
    }
-  }, [nonce])
+  }, [])
-  return [state, refetch]
+  return state
 }
--- a/apps/desktop/src/renderer/src/lib/use-chat.ts
+++ b/apps/desktop/src/renderer/src/lib/use-chat.ts
@@ -1,6 +1,6 @@
 import { useCallback, useEffect, useRef, useState } from 'react'
-import type { ChangeProposal, ChatMessage as WireMessage, IssueChange } from '@commitea/core'
+import type { ChatMessage as WireMessage } from '@commitea/core'
 import { CANNED_REPLY, CHAT, type ChatMessage } from '../data/fixtures.js'
@@ -18,11 +18,7 @@ export interface ChatState {
  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
 }
 /**
@@ -30,23 +26,18 @@ export interface ChatState {
 * 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
+ * turns (`convo`) are sent to the model as history.
 * approved write (the same handler the Issue screen uses — it refetches).
 */
-export function useChat(onApplyChange?: (change: IssueChange) => Promise<{ ok: boolean }>): ChatState {
+export function useChat(): 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
@@ -72,7 +63,6 @@ export function useChat(onApplyChange?: (change: IssueChange) => Promise<{ ok: b
      setConvo(nextConvo)
      setThinking(true)
      setSteps([])
      setProposals([])
      if (!live) {
        window.setTimeout(() => {
@@ -92,7 +82,6 @@ export function useChat(onApplyChange?: (change: IssueChange) => Promise<{ ok: b
          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) => [
@@ -112,30 +101,5 @@ export function useChat(onApplyChange?: (change: IssueChange) => Promise<{ ok: b
    [live],
  )
-  const approve = useCallback(
+  return { msgs: [...seed, ...convo], thinking, live, model, steps, send }
    (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 }
 }
--- a/packages/core/src/agent/agent-live.test.ts
+++ b/packages/core/src/agent/agent-live.test.ts
@@ -1,4 +1,4 @@
-import { beforeAll, describe, expect, it } from 'vitest'
+import { describe, expect, it } from 'vitest'
 import { extractLabelFacts } from '../labels/label-schema.js'
 import type { FetchLike, GiteaIssue } from '../gitea/types.js'
@@ -10,22 +10,11 @@ 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
+ * proving the model calls query_project and narrates the real result.
 * 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 ?? ''
+const MODEL = process.env.COMMITEA_MODEL_SMALL ?? 'google/gemma-4-e4b'
 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 ?? []
@@ -70,34 +59,4 @@ describe('agent loop (live model)', () => {
    },
    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,
  )
 })
--- a/packages/core/src/agent/agent-tools.ts
+++ b/packages/core/src/agent/agent-tools.ts
@@ -35,57 +35,12 @@ export const QUERY_PROJECT_TOOL: ToolDecl = {
  },
 }
-export const PROPOSE_CHANGE_TOOL: ToolDecl = {
+export const REGINALD_TOOLS: ToolDecl[] = [QUERY_PROJECT_TOOL]
  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.',
+  'Forecasts are ranges, never single dates. Refer to issues as #<number>.',
-  'When the PM states standing intent ("pilots first", "freeze scope"), call record_directive to log it.',
+  'Be brief and plain. A sentence or two is usually enough. No preamble, no bullet-point dumps.',
  '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(' ')
--- a/packages/core/src/agent/capture-work.test.ts
+++ b/packages/core/src/agent/capture-work.test.ts
@@ -1,65 +0,0 @@
 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([])
  })
 })
--- a/packages/core/src/agent/capture-work.ts
+++ b/packages/core/src/agent/capture-work.ts
@@ -1,109 +0,0 @@
 /**
 * 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: [] }
  }
 }
--- a/packages/core/src/changes/apply-changes-v0.test.ts
+++ b/packages/core/src/changes/apply-changes-v0.test.ts
@@ -1,79 +0,0 @@
 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([])
  })
 })
--- a/packages/core/src/changes/apply-changes-v0.ts
+++ b/packages/core/src/changes/apply-changes-v0.ts
@@ -1,104 +0,0 @@
 /**
 * 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
 }
--- a/packages/core/src/directives/record-directive-v0.test.ts
+++ b/packages/core/src/directives/record-directive-v0.test.ts
@@ -1,66 +0,0 @@
 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)
  })
 })
--- a/packages/core/src/directives/record-directive-v0.ts
+++ b/packages/core/src/directives/record-directive-v0.ts
@@ -1,106 +0,0 @@
 /**
 * 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`
 }
--- a/packages/core/src/gitea/client.test.ts
+++ b/packages/core/src/gitea/client.test.ts
@@ -123,63 +123,6 @@ 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)
--- a/packages/core/src/gitea/client.ts
+++ b/packages/core/src/gitea/client.ts
@@ -13,7 +13,6 @@ import {
  type FetchLike,
  type GiteaConfig,
  type GiteaIssue,
  type GiteaLabel,
  type GiteaMilestone,
  type GiteaMilestoneRef,
 } from './types.js'
@@ -99,16 +98,6 @@ export interface GiteaClient {
  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. */
@@ -155,24 +144,18 @@ 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, init?: { method?: string; body?: unknown }): Promise<unknown> {
+  async function request(path: string): 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, `${method} ${path} failed (${res.status})`, body)
+      throw new GiteaApiError(res.status, `GET ${path} failed (${res.status})`, body)
    }
-    // writes may reply 204 No Content
+    return res.json()
    return res.status === 204 ? null : res.json()
  }
  /** Follow gitea's page-limit pagination until a short page is returned. */
@@ -217,44 +200,5 @@ export function createGiteaClient(config: GiteaConfig, fetchImpl: FetchLike): Gi
      )
      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 } : {}) },
      })
    },
  }
 }
--- a/packages/core/src/gitea/types.ts
+++ b/packages/core/src/gitea/types.ts
@@ -35,12 +35,6 @@ 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
--- a/packages/core/src/index.ts
+++ b/packages/core/src/index.ts
@@ -17,15 +17,11 @@ export type {
  GiteaConfig,
  GiteaHttpResponse,
  GiteaIssue,
  GiteaLabel,
  GiteaMilestone,
  GiteaMilestoneRef,
  GiteaRequestInit,
 } from './gitea/types.js'
 export { describeChange, planIssueChange, proposalsFor } from './changes/apply-changes-v0.js'
 export type { ChangeProposal, IssueChange, LabelPlan, ProposeChangeArgs } from './changes/apply-changes-v0.js'
 export {
  inferColumnV0,
  inferLifecycle,
@@ -85,30 +81,6 @@ 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 {
+export { QUERY_PROJECT_TOOL, REGINALD_SYSTEM, REGINALD_TOOLS } from './agent/agent-tools.js'
  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'