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

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

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

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

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

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

@@ -45,6 +45,21 @@ 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()
   })
 })

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

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

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

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

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

@@ -30,4 +30,27 @@ 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()
+  })
 })

apps/desktop/src/main/gitea.ts

@@ -6,15 +6,24 @@
  * 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'
 
@@ -59,6 +68,45 @@ 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,
@@ -94,4 +142,59 @@ export function registerGiteaIpc(): void {
     if (!client) return null
     return client.getIssue(index)
   })
+
+  // Cached label list for name→id resolution; refreshed on demand if a name misses.
+  let labelCache: GiteaLabel[] | null = null
+  async function resolveLabelIds(names: string[]): Promise<number[]> {
+    if (!client) return []
+    const lookup = () => new Map(labelCache!.map((l) => [l.name, l.id]))
+    if (!labelCache) labelCache = await client.listLabels()
+    let byName = lookup()
+    if (names.some((n) => !byName.has(n))) {
+      labelCache = await client.listLabels() // a name we don't know — refetch once
+      byName = lookup()
+    }
+    return names.map((n) => byName.get(n)).filter((id): id is number => id != null)
+  }
+
+  // The write path (apply_changes). Additive label swaps, applied only after the
+  // renderer's propose-approve. Returns the plan + the freshly-read issue.
+  ipcMain.handle('gitea:applyChange', async (_event, change: IssueChange) => {
+    if (!client) return { ok: false as const, reason: 'unconfigured' as const }
+    const current = await client.getIssue(change.issue)
+    const plan = planIssueChange(current.labels, change)
+    if (plan.noop) return { ok: true as const, plan, issue: current }
+    const ids = await resolveLabelIds(plan.labels)
+    await client.setIssueLabels(change.issue, ids)
+    const issue = await client.getIssue(change.issue)
+    return { ok: true as const, plan, issue }
+  })
+
+  // capture_work filing: open each approved issue with its est/* + p/* labels.
+  // Only touches the CommiTea label namespaces — no invented labels (zero-pollution).
+  ipcMain.handle(
+    'gitea:createIssues',
+    async (_event, issues: { title: string; body?: string; estimate?: string; priority?: string }[]) => {
+      if (!client) return { ok: false as const, reason: 'unconfigured' as const }
+      const created: { number: number; title: string }[] = []
+      for (const it of issues) {
+        const names = [it.estimate, it.priority].filter((n): n is string => !!n)
+        const labelIds = await resolveLabelIds(names)
+        const issue = await client.createIssue({ title: it.title, body: it.body, labelIds })
+        created.push({ number: issue.number, title: issue.title })
+      }
+      return { ok: true as const, created }
+    },
+  )
+
+  // Read the directive ledger from the pm-state repo (for the Directives screen).
+  ipcMain.handle('pmstate:directives', async () => {
+    const pm = getPmStateClient()
+    if (!pm) return { ok: false as const, reason: 'unconfigured' as const }
+    try {
+      return { ok: true as const, directives: await readDirectives(pm) }
+    } catch (e) {
+      return { ok: false as const, reason: 'error' as const, message: e instanceof Error ? e.message : String(e) }
+    }
+  })
 }

apps/desktop/src/main/model.ts

@@ -9,18 +9,24 @@
 
 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 { getGiteaClient, reconcileSnapshot } from './gitea.js'
+import { appendDirectiveEntry, getGiteaClient, getPmStateClient, reconcileSnapshot } from './gitea.js'
 
 /** Small local model for prose + the read tool; big model reserved for later decomposition. */
 function resolveModelRouter(): ModelRouter | null {
@@ -80,13 +86,39 @@ 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)
         const a = (args ?? {}) as { view: ProjectView; filters?: QueryFilters }
         return buildProjectView(a.view, a.filters, snap, new Date())
       }
+      if (name === 'propose_change') {
+        const a = (args ?? {}) as ProposeChangeArgs
+        const issue = await client.getIssue(a.issue).catch(() => null)
+        if (!issue) return { error: `issue #${a.issue} not found` }
+        const built = proposalsFor(a, issue.labels, issue.title)
+        proposals.push(...built)
+        return built.length
+          ? { proposed: built.map((p) => ({ issue: a.issue, diff: describeChange(p.plan) })) }
+          : { proposed: [], note: 'no change — already at that value' }
+      }
+      if (name === 'record_directive') {
+        const pm = getPmStateClient()
+        if (!pm) return { error: 'pm-state is not configured' }
+        try {
+          const entry = await appendDirectiveEntry(pm, toDirectiveInput(args))
+          return { recorded: { kind: entry.kind, quote: entry.quote } }
+        } catch (e) {
+          return { error: `could not record — is the pm-state repo created? (${e instanceof Error ? e.message : e})` }
+        }
+      }
+      return { error: `unknown tool: ${name}` }
+    }
 
     try {
       const turn = await runAgentTurn({
@@ -95,7 +127,22 @@ export function registerModelIpc(): void {
         tools: REGINALD_TOOLS,
         execute,
       })
-      return { ok: true as const, content: turn.content, steps: turn.steps }
+      return { ok: true as const, content: turn.content, steps: turn.steps, proposals }
+    } catch (e) {
+      return { ok: false as const, reason: 'error' as const, message: e instanceof Error ? e.message : String(e) }
+    }
+  })
+
+  // capture_work — braindump → proposed issue set. The big model does the
+  // decomposition (with one loaded local model, that's the loaded one). Returns
+  // a proposal; nothing is filed until the Capture tray approves it.
+  ipcMain.handle('model:capture', async (_event, braindump: string) => {
+    if (!router) return { ok: false as const, reason: 'unconfigured' as const }
+    const model = await resolveLoadedModel(router.big.baseUrl, router.big.model)
+    const chat = createChatClient({ ...router.big, model }, fetch)
+    try {
+      const proposal = await captureWork((m, t) => chat.complete(m, t), braindump)
+      return { ok: true as const, ...proposal }
     } catch (e) {
       return { ok: false as const, reason: 'error' as const, message: e instanceof Error ? e.message : String(e) }
     }

apps/desktop/src/preload/index.ts

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

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

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

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

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

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

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

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

@@ -1,6 +1,8 @@
 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'
@@ -85,7 +87,7 @@ export function AppShell() {
   const [offline, setOffline] = useState(false)
   const [issue, setIssue] = useState<IssueRef | null>(null)
   const [readIds, setReadIds] = useState<number[]>([])
-  const backlog = useBacklog()
+  const [backlog, refetchBacklog] = useBacklog()
   const boardColumns =
     backlog.status === 'ready' ? issuesToBoardColumns(backlog.issues, backlog.timelines) : undefined
   const focus =
@@ -107,6 +109,17 @@ export function AppShell() {
     setView('issue')
   }
 
+  // The write path: apply through the bridge, reflect the new labels on the open
+  // issue immediately, and re-reconcile so the board + forecast catch up.
+  const applyChange = async (change: IssueChange) => {
+    const res = await window.commitea.gitea.applyChange(change)
+    if (res.ok) {
+      setIssue((cur) => (cur && cur.id === res.issue.number ? { ...cur, labels: res.issue.labels } : cur))
+      refetchBacklog()
+    }
+    return res
+  }
+
   const NAV: NavEntry[] = [
     { id: 'standup', label: 'Standup', icon: 'sun' },
     { id: 'focus', label: 'Morning service', icon: 'coffee' },
@@ -206,7 +219,13 @@ export function AppShell() {
         return <SettingsScreen dark={dark} setDark={setDark} />
       case 'issue':
         return issue ? (
-          <IssueScreen issue={issue} onBack={() => setView(prevView)} onOpenIssue={openIssue} />
+          <IssueScreen
+            issue={issue}
+            onBack={() => setView(prevView)}
+            onOpenIssue={openIssue}
+            canWrite={backlog.status === 'ready'}
+            onApplyChange={applyChange}
+          />
         ) : null
       case 'states':
         return <StatesScreen onCapture={() => setView('capture')} />
@@ -318,7 +337,7 @@ export function AppShell() {
         </div>
       </main>
 
-      <ChatPanel onOpenDirectives={() => setView('directives')} offline={offline} />
+      <ChatPanel onOpenDirectives={() => setView('directives')} offline={offline} onApplyChange={applyChange} />
     </div>
   )
 }

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

@@ -1,21 +1,25 @@
 import React, { useEffect, useRef, useState } from 'react'
 
+import { describeChange, type IssueChange } from '@commitea/core'
+
 import { useChat } from '../../lib/use-chat.js'
-import { Icon, IconButton } from '../ui/index.js'
+import { Button, Icon, IconButton } from '../ui/index.js'
 
 /**
  * Reginald's panel — chat is the write-path (decisions.md D1). Wired to the
- * model bridge via `useChat`: when a model is configured, sending drives a real
- * agent turn (query_project + prose); otherwise it echoes the scripted fixture
- * reply so the layout stays real. Writes still go through propose-approve.
+ * model bridge via `useChat`: a configured model drives a real agent turn
+ * (query_project + prose, propose_change for edits); otherwise it echoes the
+ * scripted fixture reply. Proposed changes are approved inline here — the write
+ * runs through `onApplyChange`, the same guarded handler the Issue screen uses.
  */
 export interface ChatPanelProps {
   onOpenDirectives?: () => void
   offline?: boolean
+  onApplyChange?: (change: IssueChange) => Promise<{ ok: boolean }>
 }
 
-export function ChatPanel({ onOpenDirectives, offline }: ChatPanelProps) {
-  const { msgs, thinking, live, model, steps, send: sendChat } = useChat()
+export function ChatPanel({ onOpenDirectives, offline, onApplyChange }: ChatPanelProps) {
+  const { msgs, thinking, live, model, steps, proposals, send: sendChat, approve, dismiss } = useChat(onApplyChange)
   // shorten "google/gemma-4-26b-a4b-qat" → "gemma-4-26b" for the header chip
   const modelLabel = model ? (model.split('/').pop() ?? model).replace(/-(qat|instruct|it|gguf)$/i, '') : 'gemma-4'
   const [text, setText] = useState('')
@@ -97,9 +101,36 @@ export function ChatPanel({ onOpenDirectives, offline }: ChatPanelProps) {
         {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')))).join(', ')}
+            <Icon name="eye" size={11} /> consulted {Array.from(new Set(steps.map((s) => s.replace('query_project', 'the project').replace('propose_change', 'the labels').replace('record_directive', 'the directive ledger')))).join(', ')}
           </div>
         ) : null}
+        {proposals.map((p) => (
+          <div
+            key={`${p.change.issue}:${p.change.kind}`}
+            style={{
+              border: '1px solid var(--line-2)',
+              borderRadius: 'var(--radius-2)',
+              background: 'var(--paper-0)',
+              padding: '10px 12px',
+              display: 'flex',
+              flexDirection: 'column',
+              gap: 8,
+            }}
+          >
+            <div style={{ font: 'var(--text-caption)', color: 'var(--ink-3)', textTransform: 'uppercase', letterSpacing: 'var(--letter-spacing-wide)' }}>
+              Proposed · #{p.change.issue}
+            </div>
+            <div style={{ font: '500 13px var(--font-mono)', color: 'var(--ink-1)' }}>{describeChange(p.plan)}</div>
+            <div style={{ display: 'flex', gap: 8 }}>
+              <Button size="sm" onClick={() => approve(p)} disabled={offline}>
+                Approve
+              </Button>
+              <Button size="sm" variant="ghost" onClick={() => dismiss(p)}>
+                Dismiss
+              </Button>
+            </div>
+          </div>
+        ))}
       </div>
 
       <div style={{ padding: 14, borderTop: '1px solid var(--line-1)', flexShrink: 0 }}>

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

@@ -1,12 +1,33 @@
 import type {
   AgentStep,
+  ChangeProposal,
   ChatMessage,
+  CaptureProposal,
   DependencyEdge,
+  DirectiveRecord,
   GiteaIssue,
   GiteaMilestone,
+  IssueChange,
+  LabelPlan,
   LifecycleEvent,
+  ProposedIssue,
 } from '@commitea/core'
 
+/** The result of a write through the bridge. */
+export type ApplyChangeResult =
+  | { ok: false; reason: 'unconfigured' }
+  | { ok: true; plan: LabelPlan; issue: GiteaIssue }
+
+/** The result of filing captured issues. */
+export type CreateIssuesResult =
+  | { ok: false; reason: 'unconfigured' }
+  | { ok: true; created: { number: number; title: string }[] }
+
+/** The result of a capture_work decomposition. */
+export type CaptureResult =
+  | { ok: false; reason: 'unconfigured' | 'error'; message?: string }
+  | ({ ok: true } & CaptureProposal)
+
 /** The gitea bridge exposed by the preload over IPC (main-process backed). */
 export interface GiteaBridge {
   status(): Promise<{ configured: boolean; repo: string | null }>
@@ -19,17 +40,30 @@ export interface GiteaBridge {
     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[] }
+  | { ok: true; content: string; steps: AgentStep[]; proposals: ChangeProposal[] }
 
 /** The model bridge (Reginald) exposed by the preload over IPC. */
 export interface ModelBridge {
   status(): Promise<{ configured: boolean; model: string | null }>
   chat(messages: ChatMessage[]): Promise<ChatResult>
+  capture(braindump: string): Promise<CaptureResult>
+}
+
+/** The result of reading the directive ledger. */
+export type DirectivesResult =
+  | { ok: false; reason: 'unconfigured' | 'error'; message?: string }
+  | { ok: true; directives: DirectiveRecord[] }
+
+/** The pm-state bridge (machine-derived state) exposed by the preload over IPC. */
+export interface PmStateBridge {
+  directives(): Promise<DirectivesResult>
 }
 
 declare global {
@@ -38,6 +72,7 @@ declare global {
       platform: string
       gitea: GiteaBridge
       model: ModelBridge
+      pmstate: PmStateBridge
     }
   }
 }

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

@@ -1,4 +1,4 @@
-import { useEffect, useState } from 'react'
+import { useCallback, useEffect, useState } from 'react'
 
 import type { DependencyEdge, GiteaIssue, GiteaMilestone, LifecycleEvent } from '@commitea/core'
 
@@ -15,12 +15,15 @@ export type BacklogState =
     }
 
 /**
- * Reconcile the managed repo once on mount, through the main-process bridge.
- * `unconfigured` means no token — the UI falls back to demo fixtures. Errors
- * (network, bad token) surface as `error`.
+ * Reconcile the managed repo through the main-process bridge. Runs once on
+ * mount; the returned `refetch` re-reconciles after a write so the board and
+ * forecast reflect the change. `unconfigured` means no token — the UI falls
+ * back to demo fixtures. Errors (network, bad token) surface as `error`.
  */
-export function useBacklog(): BacklogState {
+export function useBacklog(): [BacklogState, () => void] {
   const [state, setState] = useState<BacklogState>({ status: 'loading' })
+  const [nonce, setNonce] = useState(0)
+  const refetch = useCallback(() => setNonce((n) => n + 1), [])
 
   useEffect(() => {
     let alive = true
@@ -46,7 +49,7 @@ export function useBacklog(): BacklogState {
     return () => {
       alive = false
     }
-  }, [])
+  }, [nonce])
 
-  return state
+  return [state, refetch]
 }

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

@@ -1,6 +1,6 @@
 import { useCallback, useEffect, useRef, useState } from 'react'
 
-import type { ChatMessage as WireMessage } from '@commitea/core'
+import type { ChangeProposal, ChatMessage as WireMessage, IssueChange } from '@commitea/core'
 
 import { CANNED_REPLY, CHAT, type ChatMessage } from '../data/fixtures.js'
 
@@ -18,7 +18,11 @@ 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
 }
 
 /**
@@ -26,18 +30,23 @@ 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.
+ * turns (`convo`) are sent to the model as history. `onApplyChange` performs an
+ * approved write (the same handler the Issue screen uses — it refetches).
  */
-export function useChat(): ChatState {
+export function useChat(onApplyChange?: (change: IssueChange) => Promise<{ ok: boolean }>): ChatState {
   const [seed, setSeed] = useState<ChatMessage[]>(CHAT)
   const [convo, setConvo] = useState<ChatMessage[]>([])
   const [thinking, setThinking] = useState(false)
   const [live, setLive] = useState(false)
   const [model, setModel] = useState<string | null>(null)
   const [steps, setSteps] = useState<string[]>([])
+  const [proposals, setProposals] = useState<ChangeProposal[]>([])
   const convoRef = useRef(convo)
   convoRef.current = convo
 
+  const proposalKey = (p: ChangeProposal) => `${p.change.issue}:${p.change.kind}`
+  const drop = (p: ChangeProposal) => setProposals((ps) => ps.filter((x) => proposalKey(x) !== proposalKey(p)))
+
   useEffect(() => {
     let alive = true
     window.commitea.model
@@ -63,6 +72,7 @@ export function useChat(): ChatState {
       setConvo(nextConvo)
       setThinking(true)
       setSteps([])
+      setProposals([])
 
       if (!live) {
         window.setTimeout(() => {
@@ -82,6 +92,7 @@ export function useChat(): ChatState {
           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) => [
@@ -101,5 +112,30 @@ export function useChat(): ChatState {
     [live],
   )
 
-  return { msgs: [...seed, ...convo], thinking, live, model, steps, send }
+  const approve = useCallback(
+    (p: ChangeProposal) => {
+      if (!onApplyChange) return
+      drop(p)
+      const label = p.plan.added[0] ?? p.plan.removed[0] ?? 'change'
+      void onApplyChange(p.change).then((res) => {
+        setConvo((c) => [
+          ...c,
+          {
+            from: 'agent',
+            text: res.ok
+              ? `Done — #${p.change.issue} is now ${label}. The plan's been re-run.`
+              : `That didn't take — #${p.change.issue} is unchanged.`,
+          },
+        ])
+      })
+    },
+    [onApplyChange],
+  )
+
+  const dismiss = useCallback((p: ChangeProposal) => {
+    drop(p)
+    setConvo((c) => [...c, { from: 'agent', text: `Left #${p.change.issue} as it was.` }])
+  }, [])
+
+  return { msgs: [...seed, ...convo], thinking, live, model, steps, proposals, send, approve, dismiss }
 }

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

@@ -1,4 +1,4 @@
-import { describe, expect, it } from 'vitest'
+import { beforeAll, describe, expect, it } from 'vitest'
 
 import { extractLabelFacts } from '../labels/label-schema.js'
 import type { FetchLike, GiteaIssue } from '../gitea/types.js'
@@ -10,11 +10,22 @@ 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 query_project and narrates the real result.
+ * proving the model calls the tools and narrates the real result. The model is
+ * whatever is loaded (via LM Studio's native API), so it never JIT-swaps.
  */
 const LIVE = !!process.env.COMMITEA_MODEL_LIVE
 const BASE = process.env.COMMITEA_MODEL_URL ?? 'http://localhost:1234/v1'
-const MODEL = process.env.COMMITEA_MODEL_SMALL ?? 'google/gemma-4-e4b'
+let MODEL = process.env.COMMITEA_MODEL_SMALL ?? ''
+
+beforeAll(async () => {
+  if (!LIVE || MODEL) return
+  const root = BASE.replace(/\/v1\/?$/, '')
+  const loaded = await fetch(`${root}/api/v0/models`)
+    .then((r) => (r.ok ? (r.json() as Promise<{ data?: { id: string; state?: string; type?: string }[] }>) : null))
+    .then((d) => d?.data?.find((m) => m.state === 'loaded' && m.type !== 'embeddings')?.id)
+    .catch(() => undefined)
+  MODEL = loaded ?? 'google/gemma-4-e4b'
+})
 
 function issue(over: Partial<GiteaIssue>): GiteaIssue {
   const labels = over.labels ?? []
@@ -59,4 +70,34 @@ 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,
+  )
 })

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

@@ -35,12 +35,57 @@ export const QUERY_PROJECT_TOOL: ToolDecl = {
   },
 }
 
-export const REGINALD_TOOLS: ToolDecl[] = [QUERY_PROJECT_TOOL]
+export const PROPOSE_CHANGE_TOOL: ToolDecl = {
+  name: 'propose_change',
+  description:
+    "Propose an estimate and/or priority change to an issue. This does NOT apply anything — it shows the " +
+    'human a diff to approve. Use it whenever the user asks to re-estimate or reprioritize. After calling it, ' +
+    "tell the user you've *proposed* the change for approval — never say it is done.",
+  parameters: {
+    type: 'object',
+    properties: {
+      issue: { type: 'number', description: 'the issue number to change' },
+      estimate: { type: 'string', enum: ['est/1d', 'est/2d', 'est/3d', 'est/5d', 'est/8d'] },
+      priority: { type: 'string', enum: ['p/1', 'p/2', 'p/3', 'p/4'] },
+    },
+    required: ['issue'],
+  },
+}
+
+export const RECORD_DIRECTIVE_TOOL: ToolDecl = {
+  name: 'record_directive',
+  description:
+    'Log a standing instruction from the PM to the durable directive ledger — a reprioritization, ' +
+    'a re-estimate policy, a deadline, a scope or capacity call, or a plain note. Use it when the user ' +
+    'states intent that should persist ("pilots come first", "freeze scope for beta"). This records the ' +
+    'intent verbatim; the actual issue edits still go through propose_change.',
+  parameters: {
+    type: 'object',
+    properties: {
+      kind: { type: 'string', enum: ['reprioritize', 'reestimate', 'set-deadline', 'scope', 'capacity', 'note'] },
+      quote: { type: 'string', description: "the PM's own words, stored verbatim" },
+      target: {
+        type: 'object',
+        properties: {
+          issue: { type: 'number' },
+          milestone: { type: 'number' },
+          member: { type: 'string' },
+        },
+      },
+      rationale: { type: 'string', description: 'why (optional)' },
+    },
+    required: ['kind', 'quote'],
+  },
+}
+
+export const REGINALD_TOOLS: ToolDecl[] = [QUERY_PROJECT_TOOL, PROPOSE_CHANGE_TOOL, RECORD_DIRECTIVE_TOOL]
 
 export const REGINALD_SYSTEM = [
   'You are Reginald, the calm, dry project manager inside CommiTea — a tool that runs projects on Gitea.',
   'Call query_project to ground every answer in the real project; never invent issues, numbers, or dates.',
   'The scheduler and forecasts are deterministic code — report their output, do not recompute it.',
-  'Forecasts are ranges, never single dates. Refer to issues as #<number>.',
-  'Be brief and plain. A sentence or two is usually enough. No preamble, no bullet-point dumps.',
+  'To change an estimate or priority, call propose_change — it shows the human a diff to approve.',
+  'When the PM states standing intent ("pilots first", "freeze scope"), call record_directive to log it.',
+  'Never claim a change is applied; you propose, the human approves. Forecasts are ranges, never single dates.',
+  'Refer to issues as #<number>. Be brief and plain — a sentence or two. No preamble, no bullet dumps.',
 ].join(' ')

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -123,6 +123,63 @@ describe('createGiteaClient.getIssue', () => {
     )
   })
 
+  it('setIssueLabels PUTs the label ids to the issue labels endpoint', async () => {
+    const { fetch, calls } = stubFetch(null, 204)
+    await createGiteaClient(CONFIG, fetch).setIssueLabels(9, [3, 7])
+
+    expect(calls).toHaveLength(1)
+    expect(calls[0].url).toBe('https://gitea.stephenmann.io/api/v1/repos/christian/commitea/issues/9/labels')
+    expect(calls[0].init?.method).toBe('PUT')
+    expect(calls[0].init?.headers?.['Content-Type']).toBe('application/json')
+    expect(JSON.parse(calls[0].init?.body ?? '{}')).toEqual({ labels: [3, 7] })
+  })
+
+  it('listLabels returns id+name pairs', async () => {
+    const { fetch } = stubFetch([
+      { id: 3, name: 'est/2d', color: 'fff' },
+      { id: 7, name: 'p/1', color: '000' },
+    ])
+    const labels = await createGiteaClient(CONFIG, fetch).listLabels()
+    expect(labels).toEqual([
+      { id: 3, name: 'est/2d' },
+      { id: 7, name: 'p/1' },
+    ])
+  })
+
+  it('getFile returns null on 404 and content+sha on hit', async () => {
+    const miss = stubFetch('nope', 404)
+    expect(await createGiteaClient(CONFIG, miss.fetch).getFile('directives/log.jsonl')).toBeNull()
+
+    const hit = stubFetch({ content: 'aGVsbG8=\n', sha: 'abc123' })
+    const file = await createGiteaClient(CONFIG, hit.fetch).getFile('directives/log.jsonl')
+    expect(file).toEqual({ contentBase64: 'aGVsbG8=', sha: 'abc123' })
+    expect(hit.calls[0].url).toContain('/contents/directives/log.jsonl')
+  })
+
+  it('putFile POSTs to create and PUTs to update (with sha)', async () => {
+    const create = stubFetch({}, 201)
+    await createGiteaClient(CONFIG, create.fetch).putFile('directives/log.jsonl', { contentBase64: 'eA==', message: 'seed' })
+    expect(create.calls[0].init?.method).toBe('POST')
+    expect(JSON.parse(create.calls[0].init?.body ?? '{}')).toEqual({ content: 'eA==', message: 'seed' })
+
+    const update = stubFetch({}, 200)
+    await createGiteaClient(CONFIG, update.fetch).putFile('directives/log.jsonl', { contentBase64: 'eQ==', message: 'append', sha: 's1' })
+    expect(update.calls[0].init?.method).toBe('PUT')
+    expect(JSON.parse(update.calls[0].init?.body ?? '{}')).toEqual({ content: 'eQ==', message: 'append', sha: 's1' })
+  })
+
+  it('createIssue POSTs title/body/labels and returns a normalized issue', async () => {
+    const created = { ...RAW_ISSUE, number: 44, title: 'Retry token refresh', labels: [{ name: 'est/2d' }, { name: 'p/2' }] }
+    const { fetch, calls } = stubFetch(created, 201)
+    const issue = await createGiteaClient(CONFIG, fetch).createIssue({ title: 'Retry token refresh', body: 'backoff', labelIds: [3, 7] })
+
+    expect(calls[0].url).toBe('https://gitea.stephenmann.io/api/v1/repos/christian/commitea/issues')
+    expect(calls[0].init?.method).toBe('POST')
+    expect(JSON.parse(calls[0].init?.body ?? '{}')).toEqual({ title: 'Retry token refresh', body: 'backoff', labels: [3, 7] })
+    expect(issue.number).toBe(44)
+    expect(issue.labels).toEqual(['est/2d', 'p/2'])
+  })
+
   it('throws GiteaApiError carrying status + body on a non-2xx response', async () => {
     const { fetch } = stubFetch('not found', 404)
     const client = createGiteaClient(CONFIG, fetch)

packages/core/src/gitea/client.ts

@@ -13,6 +13,7 @@ import {
   type FetchLike,
   type GiteaConfig,
   type GiteaIssue,
+  type GiteaLabel,
   type GiteaMilestone,
   type GiteaMilestoneRef,
 } from './types.js'
@@ -98,6 +99,16 @@ 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. */
@@ -144,18 +155,24 @@ export function createGiteaClient(config: GiteaConfig, fetchImpl: FetchLike): Gi
   const apiBase = `${config.baseUrl.replace(/\/+$/, '')}/api/v1`
   const repoBase = `${apiBase}/repos/${config.owner}/${config.repo}`
 
-  async function request(path: string): Promise<unknown> {
+  async function request(path: string, init?: { method?: string; body?: unknown }): Promise<unknown> {
+    const method = init?.method ?? 'GET'
+    const hasBody = init?.body !== undefined
     const res = await fetchImpl(`${repoBase}${path}`, {
+      method,
       headers: {
         Authorization: `token ${config.token}`,
         Accept: 'application/json',
+        ...(hasBody ? { 'Content-Type': 'application/json' } : {}),
       },
+      body: hasBody ? JSON.stringify(init!.body) : undefined,
     })
     if (!res.ok) {
       const body = await res.text().catch(() => '')
-      throw new GiteaApiError(res.status, `GET ${path} failed (${res.status})`, body)
+      throw new GiteaApiError(res.status, `${method} ${path} failed (${res.status})`, body)
     }
-    return res.json()
+    // writes may reply 204 No Content
+    return res.status === 204 ? null : res.json()
   }
 
   /** Follow gitea's page-limit pagination until a short page is returned. */
@@ -200,5 +217,44 @@ 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 } : {}) },
+      })
+    },
   }
 }

packages/core/src/gitea/types.ts

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

packages/core/src/index.ts

@@ -17,11 +17,15 @@ 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,
@@ -81,6 +85,30 @@ 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 { QUERY_PROJECT_TOOL, REGINALD_SYSTEM, REGINALD_TOOLS } from './agent/agent-tools.js'
+export {
+  PROPOSE_CHANGE_TOOL,
+  QUERY_PROJECT_TOOL,
+  RECORD_DIRECTIVE_TOOL,
+  REGINALD_SYSTEM,
+  REGINALD_TOOLS,
+} from './agent/agent-tools.js'
 export { buildProjectView } from './agent/query-project.js'
 export type { ProjectSnapshot, ProjectView, QueryFilters } from './agent/query-project.js'
+export { CAPTURE_SYSTEM, captureWork, parseCaptureArgs, PROPOSE_ISSUES_TOOL } from './agent/capture-work.js'
+export type { CaptureProposal, ProposedIssue } from './agent/capture-work.js'
+
+export {
+  appendDirective,
+  makeDirectiveEntry,
+  parseDirectiveLog,
+  serializeDirective,
+  toDirectiveInput,
+} from './directives/record-directive-v0.js'
+export type {
+  DirectiveEntry,
+  DirectiveInput,
+  DirectiveKind,
+  DirectiveRecord,
+  DirectiveStatus,
+  DirectiveTarget,
+} from './directives/record-directive-v0.js'