Merge main into offline-write-queue: resolve index.ts, fix stale standup assertion

- index.ts: keep both cache (#3) and queue (#33) exports
- agent.test.ts: #28 landed the standup impl but left agent.test.ts asserting
  standup is notImplemented (its real test moved to query-project.test.ts);
  retarget the unbuilt-view assertion to milestone/runway, which are still stubs

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

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

@@ -11,6 +11,7 @@ const MAIN = join(here, '..', 'out', 'main', 'index.js')
 test.describe('live backlog', () => {
   test('The pot + Focus render real gitea data', async () => {
     test.skip(!process.env.GITEA_LIVE, 'GITEA_LIVE not set — opt-in live test')
+    test.setTimeout(90_000)
     const app = await electron.launch({ args: [MAIN], env: { ...process.env } })
     const win = await app.firstWindow()
     await win.waitForLoadState('domcontentloaded')
@@ -42,16 +43,17 @@ test.describe('live backlog', () => {
       win.getByText(/cold-start priors · \d+\/20 closed issues estimated|calibrated on \d+ closed/),
     ).toBeVisible()
     // Real per-milestone forecasts — these milestone names come from gitea, not the
-    // fixture (which lists Beta / Pilot-ready / v1.0).
-    await expect(win.getByText(/P2 — Scheduler/)).toBeVisible()
+    // fixture (Beta / Pilot-ready / v1.0). The runway shows milestones with open
+    // scope; P5 is active (P2 is fully shipped, so it's correctly omitted).
+    await expect(win.getByText(/P5 — Dogfood/)).toBeVisible()
     // Real capacity config from pm-state (christian/stephen), not the fixture (Stephen/Ana K.)
     await expect(win.getByText('christian', { exact: true })).toBeVisible()
     await expect(win.getByText(/pd\/day/).first()).toBeVisible()
     await win.screenshot({ path: join(here, '.artifacts', 'screens', 'live-runway.png'), fullPage: true, animations: 'disabled' })
 
-    // Milestone drill-in — clicking a real milestone opens its real detail
-    await win.getByText(/P2 — Scheduler/).click()
-    await expect(win.getByRole('heading', { name: 'P2 — Scheduler + Monte Carlo' })).toBeVisible()
+    // Milestone drill-in — clicking a real (active) milestone opens its real detail
+    await win.getByText(/P5 — Dogfood/).click()
+    await expect(win.getByRole('heading', { name: 'P5 — Dogfood + polish' })).toBeVisible()
     await expect(win.getByText(/\d+ issues · est \d+d/)).toBeVisible()
     await win.screenshot({ path: join(here, '.artifacts', 'screens', 'live-milestone.png'), fullPage: true, animations: 'disabled' })
     await rail.getByRole('button', { name: 'Runway' }).click()
@@ -68,10 +70,15 @@ test.describe('live backlog', () => {
     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 expect(win.getByText('Adjust issue')).toBeVisible()
     await win.getByRole('combobox').first().selectOption('est/8d')
-    await expect(win.getByText('Proposed label change')).toBeVisible()
+    await expect(win.getByText('Proposed change')).toBeVisible()
     await expect(win.getByText(/est\/8d/).last()).toBeVisible()
+    // the unified tool also drives assignee + milestone — the pickers render and diff
+    await expect(win.getByText('Assignee', { exact: true })).toBeVisible()
+    await expect(win.getByText('Milestone', { exact: true })).toBeVisible()
+    await win.getByRole('combobox').nth(2).selectOption('') // Assignee → Unassigned
+    await expect(win.getByText('unassign', { exact: true })).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
 

apps/desktop/package.json

@@ -34,6 +34,7 @@
     "electron-vite": "^3.1.0",
     "postcss": "^8.5.1",
     "tailwindcss": "^3.4.17",
+    "tsx": "^4",
     "typescript": "^5.7.3",
     "vite": "^6.1.0"
   }

apps/desktop/scripts/dogfood-report.ts

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

apps/desktop/src/main/gitea.ts

@@ -19,6 +19,7 @@ import {
   type GiteaConfig,
   type GiteaLabel,
   type IssueChange,
+  isLabelChange,
   type LifecycleEvent,
   makeDirectiveEntry,
   parseCapacityConfig,
@@ -263,19 +264,32 @@ export function registerGiteaIpc(): void {
     return client.getIssue(index)
   })
 
-  // The write path (apply_changes). Additive label swaps, applied only after the
-  // renderer's propose-approve. Returns the plan + the freshly-read issue.
+  // The write path (apply_changes), applied only after the renderer's propose-
+  // approve. Label swaps (est/p) return the plan; field writes (assign, milestone)
+  // return the freshly-read issue directly. Either way the snapshot is invalidated
+  // so the board + forecast reflect the change.
   ipcMain.handle('gitea:applyChange', async (_event, change: IssueChange) => {
     const client = getGiteaClient()
     if (!client) return { ok: false as const, reason: 'unconfigured' as const }
+
+    if (isLabelChange(change)) {
       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(client, plan.labels)
       await client.setIssueLabels(change.issue, ids)
       const issue = await client.getIssue(change.issue)
-    invalidateSnapshot() // the board + forecast must reflect the label change
+      invalidateSnapshot()
       return { ok: true as const, plan, issue }
+    }
+
+    // Field writes — the client returns the updated issue.
+    const issue =
+      change.kind === 'assign'
+        ? await client.setIssueAssignees(change.issue, change.assignee ? [change.assignee] : [])
+        : await client.setIssueMilestone(change.issue, change.milestone)
+    invalidateSnapshot()
+    return { ok: true as const, issue }
   })
 
   // capture_work filing: open each approved issue with its est/* + p/* labels.
@@ -319,6 +333,17 @@ export function registerGiteaIpc(): void {
     }
   })
 
+  // Assignable people (repo collaborators) for the Adjust dialog's assignee picker.
+  ipcMain.handle('gitea:collaborators', async () => {
+    const client = getGiteaClient()
+    if (!client) return []
+    try {
+      return await client.listCollaborators()
+    } catch {
+      return []
+    }
+  })
+
   // ---- config (team onboarding) ----
   ipcMain.handle('config:get', () => publicConfig())
 

apps/desktop/src/main/model.ts

@@ -13,7 +13,6 @@ import {
   type ChangeProposal,
   type ChatMessage,
   createChatClient,
-  describeChange,
   type ModelRouter,
   type ProjectView,
   proposalsFor,
@@ -130,10 +129,19 @@ export function registerModelIpc(): void {
         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)
+        // Milestone titles + current assignee/milestone let a proposal label the
+        // milestone and skip a no-op assign/move.
+        const milestones = (a.milestone !== undefined ? await client.listMilestones().catch(() => []) : []).map(
+          (m) => ({ id: m.id, title: m.title }),
+        )
+        const built = proposalsFor(a, issue.labels, issue.title, {
+          currentAssignee: issue.assignee,
+          currentMilestoneId: issue.milestone?.id ?? null,
+          milestones,
+        })
         proposals.push(...built)
         return built.length
-          ? { proposed: built.map((p) => ({ issue: a.issue, diff: describeChange(p.plan) })) }
+          ? { proposed: built.map((p) => ({ issue: a.issue, diff: p.summary })) }
           : { proposed: [], note: 'no change — already at that value' }
       }
       if (name === 'record_directive') {

apps/desktop/src/preload/index.ts

@@ -15,6 +15,8 @@ const api = {
     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),
+    /** Assignable people (repo collaborators) for the assignee picker. */
+    collaborators: () => ipcRenderer.invoke('gitea:collaborators'),
   },
   pmstate: {
     /** Read the directive ledger from the pm-state repo. */

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

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

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

@@ -2,13 +2,12 @@
 import React, { useState } from 'react'
 
 import {
-  describeChange,
   type EstimateLabel,
   ESTIMATE_LABELS,
   type IssueChange,
-  planIssueChange,
   type PriorityLabel,
   PRIORITY_LABELS,
+  summarizeChange,
 } from '@commitea/core'
 
 import { ISSUE_DETAIL, type IssueDetail, type IssueRef } from '../../data/fixtures.js'
@@ -23,6 +22,10 @@ export function IssueScreen({
   onOpenIssue,
   canWrite = false,
   onApplyChange,
+  collaborators = [],
+  milestones = [],
+  currentAssignee = null,
+  currentMilestoneId = null,
 }: {
   issue: IssueRef
   detail?: IssueDetail
@@ -30,6 +33,10 @@ export function IssueScreen({
   onOpenIssue: (issue: IssueRef) => void
   canWrite?: boolean
   onApplyChange?: (change: IssueChange) => Promise<{ ok: boolean }>
+  collaborators?: { login: string; name: string }[]
+  milestones?: { id: number; title: string }[]
+  currentAssignee?: string | null
+  currentMilestoneId?: number | null
 }) {
   const det: IssueDetail = detail ?? ISSUE_DETAIL[issue.id] ?? {
     state: 'triage',
@@ -62,25 +69,40 @@ export function IssueScreen({
   const labels = issue.labels ?? []
   const curEstimate = labels.find((l) => l.startsWith('est/')) ?? ''
   const curPriority = labels.find((l) => l.startsWith('p/')) ?? ''
+  const curAssignee = currentAssignee ?? ''
+  const curMilestone = currentMilestoneId != null ? String(currentMilestoneId) : ''
   const [adjustOpen, setAdjustOpen] = useState(false)
   const [estimate, setEstimate] = useState(curEstimate)
   const [priority, setPriority] = useState(curPriority)
+  const [assignee, setAssignee] = useState(curAssignee)
+  const [milestone, setMilestone] = useState(curMilestone)
   const [applying, setApplying] = useState(false)
 
   const openAdjust = () => {
     setEstimate(curEstimate)
     setPriority(curPriority)
+    setAssignee(curAssignee)
+    setMilestone(curMilestone)
     setAdjustOpen(true)
   }
 
-  // the concrete changes this dialog would apply, one per axis that differs
+  // the concrete changes this dialog would apply, one per field 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 })
+  if (assignee !== curAssignee)
+    pendingChanges.push({ kind: 'assign', issue: issue.id, assignee: assignee || null })
+  if (milestone !== curMilestone)
+    pendingChanges.push({
+      kind: 'remilestone',
+      issue: issue.id,
+      milestone: milestone ? Number(milestone) : null,
+      milestoneTitle: milestones.find((m) => String(m.id) === milestone)?.title ?? null,
+    })
 
-  const diffs = pendingChanges.map((c) => describeChange(planIssueChange(labels, c)))
+  const diffs = pendingChanges.map((c) => summarizeChange(c, labels))
 
   const apply = async () => {
     if (!onApplyChange || pendingChanges.length === 0) return
@@ -95,6 +117,14 @@ export function IssueScreen({
 
   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 }))]
+  const assigneeOptions = [
+    { value: '', label: 'Unassigned' },
+    ...collaborators.map((c) => ({ value: c.login, label: c.name })),
+  ]
+  const milestoneOptions = [
+    { value: '', label: NONE },
+    ...milestones.map((m) => ({ value: String(m.id), label: m.title })),
+  ]
 
   return (
     <div style={{ display: 'flex', flexDirection: 'column', gap: 16 }}>
@@ -135,7 +165,7 @@ export function IssueScreen({
       <Dialog
         open={adjustOpen}
         onClose={() => setAdjustOpen(false)}
-        title="Adjust estimate & priority"
+        title="Adjust issue"
         footer={
           <>
             <Button variant="ghost" onClick={() => setAdjustOpen(false)}>
@@ -161,15 +191,35 @@ export function IssueScreen({
             onChange={(e) => setPriority(e.target.value)}
           />
         </div>
+        {(collaborators.length > 0 || milestones.length > 0) && (
+          <div style={{ display: 'flex', gap: 14, marginTop: 12 }}>
+            {collaborators.length > 0 ? (
+              <Select
+                label="Assignee"
+                options={assigneeOptions}
+                value={assignee}
+                onChange={(e) => setAssignee(e.target.value)}
+              />
+            ) : null}
+            {milestones.length > 0 ? (
+              <Select
+                label="Milestone"
+                options={milestoneOptions}
+                value={milestone}
+                onChange={(e) => setMilestone(e.target.value)}
+              />
+            ) : null}
+          </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.
+              No change yet — pick a different estimate, priority, assignee, or milestone.
             </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
+                Proposed change
               </p>
               {diffs.map((d) => (
                 <div key={d} style={{ font: '500 13px var(--font-mono)', color: 'var(--ink-1)' }}>
@@ -177,7 +227,7 @@ export function IssueScreen({
                 </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.
+                Writes to gitea and re-runs the plan. Nothing else changes.
               </p>
             </>
           )}

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

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

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

@@ -108,6 +108,7 @@ export function AppShell() {
   const [gate, setGate] = useState<'checking' | 'connect' | 'ready'>('checking')
   const [demo, setDemo] = useState(false)
   const [pubConfig, setPubConfig] = useState<PublicConfig | null>(null)
+  const [collaborators, setCollaborators] = useState<{ login: string; name: string }[]>([])
   const [backlog, refetchBacklog] = useBacklog()
   const capacityMembers = useCapacity()
   const workers = capacityWorkers(capacityMembers)
@@ -189,8 +190,17 @@ export function AppShell() {
       })
       .catch(() => setGate('connect'))
     window.commitea.config.get().then(setPubConfig).catch(() => {})
+    // Assignable people for the Adjust dialog's assignee picker (empty when demo/unconfigured).
+    window.commitea.gitea.collaborators().then(setCollaborators).catch(() => {})
   }, [])
 
+  // The open issue's current assignee + milestone (from the reconciled backlog),
+  // so the Adjust dialog can preselect and diff them. Milestones list feeds its picker.
+  const currentIssue =
+    backlog.status === 'ready' && issue ? backlog.issues.find((i) => i.number === issue.id) : undefined
+  const milestoneOptions =
+    backlog.status === 'ready' ? backlog.milestones.map((m) => ({ id: m.id, title: m.title })) : []
+
   const openIssue = (ref: IssueRef) => {
     if (view !== 'issue') setPrevView(view)
     // Callers into the sidecar (e.g. a "blocks #N" chip) may know only the id.
@@ -296,7 +306,15 @@ export function AppShell() {
               setMilestoneId(id ?? null)
               setView('milestone')
             }}
-            calibration={calibration ? { n: calibration.model.n, coldStart: calibration.model.coldStart } : undefined}
+            calibration={
+              calibration
+                ? {
+                    n: calibration.model.n,
+                    coldStart: calibration.model.coldStart,
+                    excludedSameDay: calibration.coverage.excludedSameDay,
+                  }
+                : undefined
+            }
             milestones={runwayMilestones}
             capacity={capacityMembers}
           />
@@ -343,6 +361,10 @@ export function AppShell() {
             onOpenIssue={openIssue}
             canWrite={backlog.status === 'ready'}
             onApplyChange={applyChange}
+            collaborators={collaborators}
+            milestones={milestoneOptions}
+            currentAssignee={currentIssue?.assignee ?? null}
+            currentMilestoneId={currentIssue?.milestone?.id ?? null}
           />
         ) : null
       case 'states':

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

@@ -1,6 +1,6 @@
 import React, { useEffect, useRef, useState } from 'react'
 
-import { describeChange, type IssueChange } from '@commitea/core'
+import type { IssueChange } from '@commitea/core'
 
 import { useChat } from '../../lib/use-chat.js'
 import { Button, Icon, IconButton } from '../ui/index.js'
@@ -127,7 +127,7 @@ export function ChatPanel({ onOpenDirectives, offline, onApplyChange }: ChatPane
             <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={{ font: '500 13px var(--font-mono)', color: 'var(--ink-1)' }}>{p.summary}</div>
             <div style={{ display: 'flex', gap: 8 }}>
               <Button size="sm" onClick={() => approve(p)} disabled={offline}>
                 Approve

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

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

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

@@ -17,7 +17,8 @@ import type {
 /** The result of a write through the bridge. */
 export type ApplyChangeResult =
   | { ok: false; reason: 'unconfigured' }
-  | { ok: true; plan: LabelPlan; issue: GiteaIssue }
+  // `plan` is present for label swaps (est/p); absent for field writes (assign, milestone).
+  | { ok: true; plan?: LabelPlan; issue: GiteaIssue }
 
 /** The result of filing captured issues. */
 export type CreateIssuesResult =
@@ -85,6 +86,7 @@ export interface GiteaBridge {
   getIssue(index: number): Promise<GiteaIssue | null>
   applyChange(change: IssueChange): Promise<ApplyChangeResult>
   createIssues(issues: ProposedIssue[]): Promise<CreateIssuesResult>
+  collaborators(): Promise<{ login: string; name: string }[]>
 }
 
 /** One agent turn's result. */

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

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

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

@@ -133,14 +133,13 @@ export function useChat(onApplyChange?: (change: IssueChange) => Promise<{ ok: b
     (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.`
+              ? `Done — #${p.change.issue}: ${p.summary}. The plan's been re-run.`
               : `That didn't take — #${p.change.issue} is unchanged.`,
           },
         ])

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

@@ -1,4 +1,4 @@
-import { forecast, inferLifecycle, schedule, workingDaysBetween } from '@commitea/core'
+import { forecast, inferLifecycle, scheduleWithCapacity, workingDaysBetween } from '@commitea/core'
 
 import type { GanttData, GanttRow, GanttWeek } from '../../data/fixtures.js'
 import { addWorkingDays, formatShort } from '../dates.js'
@@ -26,14 +26,15 @@ function toSchedulable(issues: ProjectData['issues']) {
 const roundUpToWeek = (n: number): number => Math.ceil(Math.max(n, 1) / 7) * 7
 
 /**
- * Real Gantt: the deterministic scheduler's serial layout over the open
- * backlog (startDay/endDay/critical), plus a handful of recently-closed
- * issues shown as already-done bars. No per-issue Monte Carlo exists at this
- * grain, so `p80` is a rough single-issue buffer (endDay padded by half its
- * own duration) rather than a simulated percentile — flagged below.
+ * Real Gantt: the capacity-aware scheduler's lane layout over the open backlog
+ * (startDay/endDay/critical/worker) — the SAME layout the Monte Carlo forecast
+ * runs each trial on, so the bars you see match what's forecast. Plus a handful
+ * of recently-closed issues shown as already-done bars. No per-issue Monte Carlo
+ * exists at this grain, so `p80` is a rough single-issue buffer (endDay padded by
+ * half its own duration) rather than a simulated percentile — flagged below.
  */
 export function ganttView(d: ProjectData): GanttData {
-  const plan = schedule(toSchedulable(d.issues), d.deps)
+  const plan = scheduleWithCapacity(toSchedulable(d.issues), d.deps, d.workers)
   const issueByNumber = new Map(d.issues.map((i) => [i.number, i]))
 
   const scheduledRows: GanttRow[] = plan.items.map((item) => {
@@ -44,7 +45,9 @@ export function ganttView(d: ProjectData): GanttData {
     return {
       id: item.number,
       title: item.title,
-      who: initials(issue?.assignee ?? ''),
+      // The lane it actually landed on (capacity-aware) — falls back to the
+      // assignee, then blank, so an unassigned issue shows the lane doing it.
+      who: initials(item.worker ?? issue?.assignee ?? ''),
       start: item.startDay,
       end: item.endDay,
       crit: item.critical,

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

@@ -17,10 +17,11 @@ export const QUERY_PROJECT_TOOL: ToolDecl = {
     properties: {
       view: {
         type: 'string',
-        enum: ['focus', 'board', 'calibration', 'issue', 'search'],
+        enum: ['focus', 'board', 'calibration', 'issue', 'search', 'standup'],
         description:
           'focus = Now/Next/Later; board = issues by lifecycle column; calibration = estimate-vs-actual; ' +
-          'issue = one issue (needs filters.issueId); search = issues matching filters.query.',
+          'issue = one issue (needs filters.issueId); search = issues matching filters.query; ' +
+          "standup = today's plan + overnight drift + the stalest blocker.",
       },
       filters: {
         type: 'object',
@@ -38,15 +39,19 @@ export const QUERY_PROJECT_TOOL: ToolDecl = {
 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.",
+    'Propose a change to an issue — estimate, priority, assignee, and/or milestone. This does NOT apply ' +
+    'anything; it shows the human a diff to approve. Use it whenever the user asks to re-estimate, reprioritize, ' +
+    'assign someone (or unassign), or move an issue to a milestone. Pass a login for `assignee` (null to ' +
+    'unassign) and a milestone id for `milestone` (null to remove). After calling it, tell the user you have ' +
+    '*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'] },
+      assignee: { type: 'string', description: 'gitea login to assign, or null to unassign' },
+      milestone: { type: 'number', description: 'milestone id to set, or null to remove from its milestone' },
     },
     required: ['issue'],
   },
@@ -84,7 +89,7 @@ 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.',
+  'To change an estimate, priority, assignee, or milestone, 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.',

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

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

packages/core/src/agent/memory-v0.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, it } from 'vitest'
+
+import type { DirectiveEntry } from '../directives/record-directive-v0.js'
+import type { Focus, ScheduledItem } from '../scheduler/scheduler-v0.js'
+import {
+  activeDirectives,
+  assembleHotContext,
+  estimateTokens,
+  HOT_CONTEXT_BUDGET_TOKENS,
+} from './memory-v0.js'
+
+const item = (number: number, title: string): ScheduledItem =>
+  ({ number, title, labels: [], order: 0, startDay: 0, endDay: 1, durationDays: 1, blockedBy: [], blocks: [], critical: false, rationale: '' })
+
+const focus: Focus = { now: item(7, 'Fix lifecycle inference'), next: item(8, 'Webhook listener'), later: null }
+
+const directive = (over: Partial<DirectiveEntry>): DirectiveEntry => ({
+  id: 'd1',
+  ts: '2026-02-10T09:00:00Z',
+  status: 'accepted',
+  kind: 'note',
+  quote: 'pilots come first',
+  ...over,
+})
+
+describe('memory-v0 (#27)', () => {
+  it('estimateTokens is a slight over-estimate (~4 chars/token)', () => {
+    expect(estimateTokens('')).toBe(0)
+    expect(estimateTokens('abcd')).toBe(1)
+    expect(estimateTokens('a'.repeat(4001))).toBe(1001)
+  })
+
+  it('activeDirectives keeps accepted/amended, most-recent-first', () => {
+    const ds = [
+      directive({ id: 'a', ts: '2026-02-01T00:00:00Z', status: 'accepted', quote: 'old' }),
+      directive({ id: 'b', ts: '2026-02-11T00:00:00Z', status: 'amended', quote: 'new' }),
+      directive({ id: 'c', ts: '2026-02-12T00:00:00Z', status: 'withdrawn', quote: 'gone' }),
+      directive({ id: 'd', ts: '2026-02-09T00:00:00Z', status: 'proposed', quote: 'maybe' }),
+    ]
+    expect(activeDirectives(ds).map((d) => d.quote)).toEqual(['new', 'old'])
+  })
+
+  it('assembles hot context under the 2k budget even with a huge charter', () => {
+    const huge = 'Charter line that goes on and on. '.repeat(2000) // ~34k tokens
+    const ds = Array.from({ length: 50 }, (_, i) =>
+      directive({ id: `d${i}`, ts: `2026-02-${String((i % 27) + 1).padStart(2, '0')}T00:00:00Z`, quote: `directive number ${i}` }),
+    )
+    const out = assembleHotContext({ charter: huge, directives: ds, focus })
+
+    expect(estimateTokens(out)).toBeLessThanOrEqual(HOT_CONTEXT_BUDGET_TOKENS)
+    // focus (tiny) is always kept; the charter is the part that gets truncated
+    expect(out).toContain('## Focus')
+    expect(out).toContain('#7 Fix lifecycle inference')
+    expect(out).toContain('…') // charter was clamped
+    // at least some recent directives survived
+    expect(out).toContain('## Active directives')
+  })
+
+  it('never inlines ticket bodies — only numbers + titles appear for focus', () => {
+    // The assembler takes no issue bodies by construction; focus shows #number title only.
+    const out = assembleHotContext({ charter: 'Ship the beta.', directives: [directive({})], focus })
+    expect(out).toContain('Now: #7 Fix lifecycle inference')
+    expect(out).toContain('[note] pilots come first')
+    expect(out).not.toMatch(/body|description|comment/i)
+  })
+
+  it('degrades to just focus when there is no charter or directives', () => {
+    const out = assembleHotContext({ charter: '', directives: [], focus })
+    expect(out).toBe(['## Focus', 'Now: #7 Fix lifecycle inference', 'Next: #8 Webhook listener', 'Later: —'].join('\n'))
+  })
+})

packages/core/src/agent/memory-v0.ts

@@ -0,0 +1,102 @@
+/**
+ * Memory layers, v0 (#27). Reginald's context is tiered so the model always sees
+ * what matters without ever copying ticket data into the prompt:
+ *
+ * - HOT (this module) — charter + active directives + the focus snapshot, packed
+ *   under a hard token budget. Assembled fresh each turn; it's the system-prompt seed.
+ * - WARM — the append-only directive/event ledger + periodic digest, in pm-state.
+ *   Not inlined; summarized on demand.
+ * - COLD — gitea + the sidecar, reached through `query_project` tools. Ticket bodies,
+ *   comments, and per-issue detail live here and are NEVER copied into memory —
+ *   the model fetches them by number when it needs them.
+ *
+ * The invariant: HOT stays under budget, and nothing ticket-shaped is inlined.
+ */
+
+import type { DirectiveEntry } from '../directives/record-directive-v0.js'
+import type { Focus } from '../scheduler/scheduler-v0.js'
+
+/** The hot layer's hard ceiling (#27: hot context assembles under 2k tokens). */
+export const HOT_CONTEXT_BUDGET_TOKENS = 2000
+
+/**
+ * Tokenizer-free estimate (~4 chars/token). Deliberately a slight over-estimate so
+ * a real tokenizer never exceeds what this predicts — the budget stays safe.
+ */
+export function estimateTokens(text: string): number {
+  return Math.ceil(text.length / 4)
+}
+
+/** Directives that still bind: accepted or amended, most-recent-first. */
+export function activeDirectives(all: DirectiveEntry[]): DirectiveEntry[] {
+  return all
+    .filter((d) => d.status === 'accepted' || d.status === 'amended')
+    .slice()
+    .sort((a, b) => (a.ts < b.ts ? 1 : a.ts > b.ts ? -1 : 0))
+}
+
+export interface HotContextInputs {
+  /** The project charter markdown (hot-memory seed). */
+  charter: string
+  /** The directive ledger (any status — filtered to active here). */
+  directives: DirectiveEntry[]
+  /** The current Now/Next/Later focus, or null when nothing is scheduled. */
+  focus: Focus | null
+}
+
+function focusBlock(focus: Focus | null): string {
+  if (!focus) return ''
+  const slot = (label: string, item: Focus['now']) => (item ? `${label}: #${item.number} ${item.title}` : `${label}: —`)
+  return ['## Focus', slot('Now', focus.now), slot('Next', focus.next), slot('Later', focus.later)].join('\n')
+}
+
+function directivesBlock(directives: DirectiveEntry[]): string[] {
+  // one compact line each; the verbatim quote is the payload, kind is the tag
+  return directives.map((d) => `- [${d.kind}] ${d.quote}`)
+}
+
+/** Truncate to a token budget on a whitespace boundary, with an ellipsis marker. */
+function clampToTokens(text: string, budgetTokens: number): string {
+  if (estimateTokens(text) <= budgetTokens) return text
+  const maxChars = Math.max(0, budgetTokens * 4 - 1)
+  const cut = text.slice(0, maxChars)
+  const lastBreak = cut.lastIndexOf('\n')
+  return `${(lastBreak > maxChars * 0.6 ? cut.slice(0, lastBreak) : cut).trimEnd()}\n…`
+}
+
+/**
+ * Assemble the HOT context under `budget` tokens. Priority when space is tight:
+ * the focus snapshot (tiny, always kept) → the most recent active directives
+ * (each while they fit) → the charter fills whatever budget remains (truncated).
+ * Never inlines ticket bodies — only charter text, directive quotes, and focus
+ * titles, all authored/short. Returns a single prompt-ready block.
+ */
+export function assembleHotContext(inputs: HotContextInputs, budget = HOT_CONTEXT_BUDGET_TOKENS): string {
+  const focus = focusBlock(inputs.focus)
+  const focusTokens = focus ? estimateTokens(focus) : 0
+
+  // fit the most recent active directives into ~⅔ of what's left after focus
+  const active = activeDirectives(inputs.directives)
+  const directiveCap = Math.max(0, Math.floor((budget - focusTokens) * (2 / 3)))
+  const keptDirectives: string[] = []
+  let directiveTokens = 0
+  for (const line of directivesBlock(active)) {
+    const t = estimateTokens(line) + 1
+    if (directiveTokens + t > directiveCap) break
+    keptDirectives.push(line)
+    directiveTokens += t
+  }
+  const directives = keptDirectives.length ? ['## Active directives', ...keptDirectives].join('\n') : ''
+
+  // Measure the fixed tail (directives + focus, with their joiner) exactly, then
+  // give the charter the true remainder — reserving for the "## Charter" header,
+  // the block joiner, and the truncation ellipsis so the total never exceeds budget.
+  const tail = [directives, focus].filter(Boolean).join('\n\n')
+  const tailTokens = tail ? estimateTokens(tail) : 0
+  const reserve = estimateTokens(`## Charter\n${tail ? '\n\n' : ''}\n…`)
+  const charterBudget = Math.max(0, budget - tailTokens - reserve)
+  const charterBody = inputs.charter.trim() ? clampToTokens(inputs.charter.trim(), charterBudget) : ''
+  const charter = charterBody ? `## Charter\n${charterBody}` : ''
+
+  return [charter, tail].filter(Boolean).join('\n\n')
+}

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,6 +1,13 @@
 import { describe, expect, it } from 'vitest'
 
-import { describeChange, type IssueChange, planIssueChange, proposalsFor } from './apply-changes-v0.js'
+import {
+  describeChange,
+  isLabelChange,
+  type IssueChange,
+  planIssueChange,
+  proposalsFor,
+  summarizeChange,
+} from './apply-changes-v0.js'
 
 describe('planIssueChange', () => {
   it('swaps the estimate label, keeping non-axis labels', () => {
@@ -58,11 +65,31 @@ describe('proposalsFor', () => {
     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[0].summary).toBe('est/2d → est/5d')
     expect(props[1].change).toEqual({ kind: 'reprioritize', issue: 2, priority: 'p/1' })
     expect(props[0].issueTitle).toBe('ChangeSource')
   })
 
+  it('proposes an assignment only when it differs from the current assignee', () => {
+    const change = proposalsFor({ issue: 2, assignee: 'christian' }, [], undefined, { currentAssignee: null })
+    expect(change).toHaveLength(1)
+    expect(change[0].change).toEqual({ kind: 'assign', issue: 2, assignee: 'christian' })
+    expect(change[0].summary).toBe('assign → @christian')
+    expect(change[0].plan).toBeUndefined()
+    // already assigned → no proposal
+    expect(proposalsFor({ issue: 2, assignee: 'christian' }, [], undefined, { currentAssignee: 'christian' })).toEqual([])
+  })
+
+  it('proposes a milestone move, labeled from the milestones list, skipping a no-op', () => {
+    const ctx = { currentMilestoneId: 1, milestones: [{ id: 3, title: 'P5 — Dogfood' }] }
+    const props = proposalsFor({ issue: 2, milestone: 3 }, [], undefined, ctx)
+    expect(props).toHaveLength(1)
+    expect(props[0].change).toEqual({ kind: 'remilestone', issue: 2, milestone: 3, milestoneTitle: 'P5 — Dogfood' })
+    expect(props[0].summary).toBe('milestone → P5 — Dogfood')
+    // same milestone → no proposal
+    expect(proposalsFor({ issue: 2, milestone: 1 }, [], undefined, ctx)).toEqual([])
+  })
+
   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
@@ -77,3 +104,31 @@ describe('proposalsFor', () => {
     expect(proposalsFor({ issue: 2 }, ['est/2d'])).toEqual([])
   })
 })
+
+describe('unified change model (assign + milestone)', () => {
+  it('isLabelChange narrows label kinds only', () => {
+    expect(isLabelChange({ kind: 'reestimate', issue: 1, estimate: 'est/2d' })).toBe(true)
+    expect(isLabelChange({ kind: 'reprioritize', issue: 1, priority: 'p/1' })).toBe(true)
+    expect(isLabelChange({ kind: 'assign', issue: 1, assignee: 'christian' })).toBe(false)
+    expect(isLabelChange({ kind: 'remilestone', issue: 1, milestone: 3 })).toBe(false)
+  })
+
+  it('summarizeChange describes an assignment and an unassignment', () => {
+    expect(summarizeChange({ kind: 'assign', issue: 1, assignee: 'christian' })).toBe('assign → @christian')
+    expect(summarizeChange({ kind: 'assign', issue: 1, assignee: null })).toBe('unassign')
+  })
+
+  it('summarizeChange describes a milestone set (by title) and removal', () => {
+    expect(summarizeChange({ kind: 'remilestone', issue: 1, milestone: 3, milestoneTitle: 'P5 — Dogfood' })).toBe(
+      'milestone → P5 — Dogfood',
+    )
+    expect(summarizeChange({ kind: 'remilestone', issue: 1, milestone: 3 })).toBe('milestone → #3')
+    expect(summarizeChange({ kind: 'remilestone', issue: 1, milestone: null })).toBe('remove from milestone')
+  })
+
+  it('summarizeChange delegates label kinds to describeChange (needs current labels)', () => {
+    const change: IssueChange = { kind: 'reestimate', issue: 1, estimate: 'est/5d' }
+    expect(summarizeChange(change, ['est/2d'])).toBe('est/2d → est/5d')
+    expect(summarizeChange(change, ['est/5d'])).toBe('no change')
+  })
+})

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

@@ -17,6 +17,15 @@ import {
 export type IssueChange =
   | { kind: 'reestimate'; issue: number; estimate: EstimateLabel | null }
   | { kind: 'reprioritize'; issue: number; priority: PriorityLabel | null }
+  | { kind: 'assign'; issue: number; assignee: string | null }
+  | { kind: 'remilestone'; issue: number; milestone: number | null; milestoneTitle?: string | null }
+
+/** The label axes are the only kinds planned as a label swap; the rest are field writes. */
+export function isLabelChange(
+  change: IssueChange,
+): change is Extract<IssueChange, { kind: 'reestimate' | 'reprioritize' }> {
+  return change.kind === 'reestimate' || change.kind === 'reprioritize'
+}
 
 export interface LabelPlan {
   /** The full resulting label-name set (order: kept labels, then the new axis label). */
@@ -29,7 +38,10 @@ export interface LabelPlan {
   noop: boolean
 }
 
-function axisFor(change: IssueChange): { labels: readonly string[]; target: string | null } {
+/** A change that resolves to a label swap (the only kind `planIssueChange` accepts). */
+export type LabelChange = Extract<IssueChange, { kind: 'reestimate' | 'reprioritize' }>
+
+function axisFor(change: LabelChange): { labels: readonly string[]; target: string | null } {
   return change.kind === 'reestimate'
     ? { labels: ESTIMATE_LABELS, target: change.estimate }
     : { labels: PRIORITY_LABELS, target: change.priority }
@@ -40,7 +52,7 @@ function axisFor(change: IssueChange): { labels: readonly string[]; target: stri
  * 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 {
+export function planIssueChange(current: string[], change: LabelChange): LabelPlan {
   const { labels: axis, target } = axisFor(change)
   const onAxis = current.filter((l) => axis.includes(l))
   const removed = onAxis.filter((l) => l !== target)
@@ -58,18 +70,52 @@ export function describeChange(plan: LabelPlan): string {
   return `${from} → ${to}`
 }
 
-/** A change the agent proposes: the concrete op + its diff, ready for approve-then-apply. */
+/**
+ * One human-readable confirm line for ANY change kind — the unified describe for
+ * the propose-approve UI. Label kinds delegate to {@link describeChange} (so they
+ * need the issue's current labels); assign/milestone describe the field write
+ * directly. Pure; no network.
+ */
+export function summarizeChange(change: IssueChange, currentLabels: string[] = []): string {
+  switch (change.kind) {
+    case 'reestimate':
+    case 'reprioritize':
+      return describeChange(planIssueChange(currentLabels, change))
+    case 'assign':
+      return change.assignee ? `assign → @${change.assignee}` : 'unassign'
+    case 'remilestone':
+      return change.milestone == null
+        ? 'remove from milestone'
+        : `milestone → ${change.milestoneTitle ?? `#${change.milestone}`}`
+  }
+}
+
+/** A change the agent proposes: the concrete op + its human diff, ready for approve-then-apply. */
 export interface ChangeProposal {
   change: IssueChange
-  plan: LabelPlan
+  /** One-line diff for the approve UI — always present ({@link summarizeChange}). */
+  summary: string
+  /** The label plan, for label kinds only (absent for assign/milestone). */
+  plan?: LabelPlan
   issueTitle?: string
 }
 
-/** What the `propose_change` tool accepts — a target issue and the axes to set. */
+/** What the `propose_change` tool accepts — a target issue and the fields to set. */
 export interface ProposeChangeArgs {
   issue: number
   estimate?: EstimateLabel
   priority?: PriorityLabel
+  /** Login to assign, or null to unassign. Omit to leave assignee untouched. */
+  assignee?: string | null
+  /** Milestone id to set, or null to clear. Omit to leave the milestone untouched. */
+  milestone?: number | null
+}
+
+/** Current state + lookups a proposal needs to skip noops and label the milestone. */
+export interface ProposalContext {
+  currentAssignee?: string | null
+  currentMilestoneId?: number | null
+  milestones?: { id: number; title: string }[]
 }
 
 function isEstimate(v: unknown): v is EstimateLabel {
@@ -80,25 +126,33 @@ function isPriority(v: unknown): v is PriorityLabel {
 }
 
 /**
- * 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.
+ * Build the concrete, non-noop proposals for a `propose_change` request. Label
+ * axes (est/*, p/*) are validated and never invented; assign/milestone are
+ * emitted only when they differ from the issue's current value (via `ctx`). Each
+ * proposal carries a human `summary`; label kinds also carry the label plan.
  */
 export function proposalsFor(
   args: ProposeChangeArgs,
   currentLabels: string[],
   issueTitle?: string,
+  ctx: ProposalContext = {},
 ): ChangeProposal[] {
   const out: ChangeProposal[] = []
-  if (isEstimate(args.estimate)) {
-    const change: IssueChange = { kind: 'reestimate', issue: args.issue, estimate: args.estimate }
+  const pushLabel = (change: LabelChange) => {
     const plan = planIssueChange(currentLabels, change)
-    if (!plan.noop) out.push({ change, plan, issueTitle })
+    if (!plan.noop) out.push({ change, plan, summary: describeChange(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 })
+  if (isEstimate(args.estimate)) pushLabel({ kind: 'reestimate', issue: args.issue, estimate: args.estimate })
+  if (isPriority(args.priority)) pushLabel({ kind: 'reprioritize', issue: args.issue, priority: args.priority })
+
+  if (args.assignee !== undefined && args.assignee !== (ctx.currentAssignee ?? null)) {
+    const change: IssueChange = { kind: 'assign', issue: args.issue, assignee: args.assignee }
+    out.push({ change, summary: summarizeChange(change), issueTitle })
+  }
+  if (args.milestone !== undefined && args.milestone !== (ctx.currentMilestoneId ?? null)) {
+    const milestoneTitle = ctx.milestones?.find((m) => m.id === args.milestone)?.title ?? null
+    const change: IssueChange = { kind: 'remilestone', issue: args.issue, milestone: args.milestone, milestoneTitle }
+    out.push({ change, summary: summarizeChange(change), issueTitle })
   }
   return out
 }

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

@@ -146,6 +146,22 @@ describe('createGiteaClient.getIssue', () => {
     ])
   })
 
+  it('listCollaborators maps login+name and prepends the owner when absent', async () => {
+    const { fetch } = stubFetch([{ login: 'stephen', full_name: 'Stephen M.' }])
+    const people = await createGiteaClient(CONFIG, fetch).listCollaborators()
+    // owner (christian) prepended since /collaborators omits them; collaborator name preserved
+    expect(people).toEqual([
+      { login: 'christian', name: 'christian' },
+      { login: 'stephen', name: 'Stephen M.' },
+    ])
+  })
+
+  it('listCollaborators does not double-add the owner when already listed', async () => {
+    const { fetch } = stubFetch([{ login: 'christian', full_name: 'Christian L.' }])
+    const people = await createGiteaClient(CONFIG, fetch).listCollaborators()
+    expect(people).toEqual([{ login: 'christian', name: 'Christian L.' }])
+  })
+
   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()

packages/core/src/gitea/client.ts

@@ -101,8 +101,14 @@ export interface GiteaClient {
   getIssueTimeline(index: number): Promise<LifecycleEvent[]>
   /** Every label defined on the repo (id + name), for name→id resolution. */
   listLabels(): Promise<GiteaLabel[]>
+  /** Repo collaborators (login + display name) — the assignable people. */
+  listCollaborators(): Promise<{ login: string; name: string }[]>
   /** Replace an issue's entire label set with the given label ids. Write. */
   setIssueLabels(index: number, labelIds: number[]): Promise<void>
+  /** Replace an issue's assignees (empty array unassigns); returns the updated issue. Write. */
+  setIssueAssignees(index: number, logins: string[]): Promise<GiteaIssue>
+  /** Set (or clear, with null) an issue's milestone by id; returns the updated issue. Write. */
+  setIssueMilestone(index: number, milestoneId: number | null): Promise<GiteaIssue>
   /** 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. */
@@ -229,6 +235,33 @@ export function createGiteaClient(config: GiteaConfig, fetchImpl: FetchLike): Gi
       await request(`/issues/${index}/labels`, { method: 'PUT', body: { labels: labelIds } })
     },
 
+    async listCollaborators() {
+      const raw = await requestAll<{ login: string; full_name?: string }>(
+        (page) => `/collaborators?page=${page}&limit=${PAGE_LIMIT}`,
+      )
+      const collabs = raw.map((u) => ({ login: u.login, name: u.full_name || u.login }))
+      // The owner is assignable but is not returned by /collaborators — prepend them
+      // so a solo-owner repo still has an assignable person.
+      if (!collabs.some((c) => c.login === config.owner)) {
+        collabs.unshift({ login: config.owner, name: config.owner })
+      }
+      return collabs
+    },
+
+    async setIssueAssignees(index, logins) {
+      const raw = (await request(`/issues/${index}`, { method: 'PATCH', body: { assignees: logins } })) as RawIssue
+      return normalizeIssue(raw)
+    },
+
+    async setIssueMilestone(index, milestoneId) {
+      // gitea's EditIssueOption takes a milestone id; 0 clears it.
+      const raw = (await request(`/issues/${index}`, {
+        method: 'PATCH',
+        body: { milestone: milestoneId ?? 0 },
+      })) as RawIssue
+      return normalizeIssue(raw)
+    },
+
     async createIssue(input) {
       const raw = (await request('/issues', {
         method: 'POST',

packages/core/src/index.ts

@@ -23,8 +23,19 @@ export type {
   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 { CACHE_SCHEMA, initCache, readIssue, upsertIssue } from './cache/cache-v0.js'
+export type { CacheDriver } from './cache/cache-v0.js'
+export { affectedIssues, coalesceKey, enqueueWrite, pendingWrites, replayQueue } from './queue/write-queue-v0.js'
+export type { QueuedWrite } from './queue/write-queue-v0.js'
+export { describeChange, isLabelChange, planIssueChange, proposalsFor, summarizeChange } from './changes/apply-changes-v0.js'
+export type {
+  ChangeProposal,
+  IssueChange,
+  LabelChange,
+  LabelPlan,
+  ProposalContext,
+  ProposeChangeArgs,
+} from './changes/apply-changes-v0.js'
 
 export {
   inferColumnV0,
@@ -73,6 +84,7 @@ export type {
 
 export {
   CALIBRATION_BUCKET_FLOOR,
+  calibrationCoverage,
   calibrationSamples,
   COLD_START_THRESHOLD,
   fitCalibration,
@@ -80,6 +92,7 @@ export {
 } from './calibration/calibration-v0.js'
 export type {
   BucketFit,
+  CalibrationCoverage,
   CalibrationModel,
   CalibrationSample,
   PersonBias,
@@ -100,6 +113,8 @@ export {
 } from './agent/agent-tools.js'
 export { buildProjectView } from './agent/query-project.js'
 export type { ProjectSnapshot, ProjectView, QueryFilters } from './agent/query-project.js'
+export { activeDirectives, assembleHotContext, estimateTokens, HOT_CONTEXT_BUDGET_TOKENS } from './agent/memory-v0.js'
+export type { HotContextInputs } from './agent/memory-v0.js'
 export { CAPTURE_SYSTEM, captureWork, parseCaptureArgs, PROPOSE_ISSUES_TOOL } from './agent/capture-work.js'
 export type { CaptureProposal, ProposedIssue } from './agent/capture-work.js'
 

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

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

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

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

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

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

yarn.lock

@@ -261,6 +261,7 @@ __metadata:
     react: "npm:^18.3.1"
     react-dom: "npm:^18.3.1"
     tailwindcss: "npm:^3.4.17"
+    tsx: "npm:^4"
     typescript: "npm:^5.7.3"
     vite: "npm:^6.1.0"
   languageName: unknown
@@ -2687,7 +2688,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"esbuild@npm:^0.27.0 || ^0.28.0":
+"esbuild@npm:^0.27.0 || ^0.28.0, esbuild@npm:~0.28.0":
   version: 0.28.1
   resolution: "esbuild@npm:0.28.1"
   dependencies:
@@ -5330,6 +5331,21 @@ __metadata:
   languageName: node
   linkType: hard
 
+"tsx@npm:^4":
+  version: 4.23.0
+  resolution: "tsx@npm:4.23.0"
+  dependencies:
+    esbuild: "npm:~0.28.0"
+    fsevents: "npm:~2.3.3"
+  dependenciesMeta:
+    fsevents:
+      optional: true
+  bin:
+    tsx: dist/cli.mjs
+  checksum: 10c0/e4fade6bf8a4447424652da3a68f5ab7b927d1cbe5f697dba876c626c5fb7bf7663c4f71777992c9cbbdc8148c63ee1ddcf15536ff9d1863f9fbea25247ee0a9
+  languageName: node
+  linkType: hard
+
 "type-fest@npm:^0.13.1":
   version: 0.13.1
   resolution: "type-fest@npm:0.13.1"