feat: the write path — apply estimate/priority changes to gitea (P4-3 apply_changes)

The first write path. Read, forecast, and calibration were all real; now you can
*manage* CommiTea from CommiTea. Estimates/priority are exclusive label axes, so
a change is a label swap — proposed, approved, then written. Nothing is assumed.

core (@commitea/core):
- planIssueChange(current, change): pure diff planner — swaps the est/*|p/* axis,
  clears on null, dedups a doubled axis; returns the resulting label set + a
  before/after diff + noop flag. describeChange() renders "est/2d → est/5d".
- request() seam extended for writes (method/body, JSON, 204). client gains
  listLabels() (name→id) and setIssueLabels() (PUT /issues/{n}/labels).

app:
- main bridge gitea:applyChange — resolves plan.labels → ids (cached, refetch on
  miss), PUTs, returns the plan + fresh issue. Token never leaves main.
- preload + global.d.ts expose applyChange; useBacklog returns a refetch so a
  write re-reconciles the board + forecast.
- Issue screen: an Adjust button (shown only when configured) opens a
  propose-approve Dialog — estimate/priority pickers, live "est/3d → est/8d"
  consequence, Apply/Cancel. AppShell wires it, reflects new labels on the open
  issue immediately, and refetches.

Verified: 83 core tests green (7 apply-changes + 2 client-write new), desktop
typecheck clean, 14 fixture e2e green. Live spec exercises propose + CANCEL (no
mutation); the real PUT was verified once manually (change #2 est/3d→est/8d→200,
reverted clean). Icon: pencil (no sliders-horizontal in the set).

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

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

@@ -34,6 +34,32 @@ test.describe('live backlog', () => {
     await expect(win.getByText(/Cold-start priors/)).toBeVisible()
     await win.screenshot({ path: join(here, '.artifacts', 'screens', 'live-focus.png'), fullPage: true, animations: 'disabled' })
 
+    // Runway → calibration surface, fitted from real closed-issue actuals (#1).
+    // With <20 estimated closes the repo is honestly cold-start; the note proves
+    // the fit ran on real data, not the fixture's "calibrated on 27".
+    await rail.getByRole('button', { name: 'Runway' }).click()
+    await expect(
+      win.getByText(/cold-start priors · \d+\/20 closed issues estimated|calibrated on \d+ closed/),
+    ).toBeVisible()
+    await win.getByRole('button', { name: 'Full report' }).click()
+    await expect(win.getByText(/cold-start · \d+\/20|curve active · n ≥ 20/)).toBeVisible()
+    await win.screenshot({ path: join(here, '.artifacts', 'screens', 'live-calibration.png'), fullPage: true, animations: 'disabled' })
+
+    // Write path (apply_changes): open the top scheduled issue, propose an
+    // estimate change, and confirm the propose-approve diff renders — then CANCEL
+    // so the live run never mutates the real repo (the PUT is unit-tested; a
+    // one-off change→revert verified it against gitea manually).
+    await rail.getByRole('button', { name: 'Morning service' }).click()
+    await win.getByRole('main').getByRole('link').first().click()
+    await expect(win.getByText(/· stephen\/commitea/)).toBeVisible()
+    await win.getByRole('button', { name: 'Adjust' }).click()
+    await expect(win.getByText('Adjust estimate & priority')).toBeVisible()
+    await win.getByRole('combobox').first().selectOption('est/8d')
+    await expect(win.getByText('Proposed label change')).toBeVisible()
+    await expect(win.getByText(/est\/8d/).last()).toBeVisible()
+    await win.screenshot({ path: join(here, '.artifacts', 'screens', 'live-apply-change.png'), fullPage: true, animations: 'disabled' })
+    await win.getByRole('button', { name: 'Cancel' }).click() // no mutation
+
     await app.close()
   })
 })

apps/desktop/src/main/gitea.ts

@@ -9,7 +9,14 @@
 import { readFileSync } from 'node:fs'
 import { dirname, join } from 'node:path'
 
-import { createGiteaClient, type GiteaConfig, type LifecycleEvent } from '@commitea/core'
+import {
+  createGiteaClient,
+  type GiteaConfig,
+  type GiteaLabel,
+  type IssueChange,
+  type LifecycleEvent,
+  planIssueChange,
+} from '@commitea/core'
 import { ipcMain } from 'electron'
 
 /** Walk up from cwd looking for a .env.local with a GITEA_TOKEN (dev convenience). */
@@ -71,4 +78,31 @@ 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 }
+  })
 }

apps/desktop/src/preload/index.ts

@@ -9,6 +9,8 @@ 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),
   },
 }
 

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

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

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

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

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

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

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

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

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

@@ -1,8 +1,10 @@
 import React, { useEffect, useState } from 'react'
 
 import logoIcon from '../../design/assets/logo-icon.png'
+import type { IssueChange } from '@commitea/core'
+
 import type { IssueRef } from '../../data/fixtures.js'
-import { forecastBacklog, issuesToBoardColumns, scheduleFocus } from '../../lib/backlog.js'
+import { backlogCalibration, forecastBacklog, issuesToBoardColumns, scheduleFocus } from '../../lib/backlog.js'
 import { useBacklog } from '../../lib/use-backlog.js'
 import { PrimitivesGallery } from '../gallery.js'
 import { BoardScreen } from '../screens/board-screen.js'
@@ -85,13 +87,17 @@ export function AppShell() {
   const [offline, setOffline] = useState(false)
   const [issue, setIssue] = useState<IssueRef | null>(null)
   const [readIds, setReadIds] = useState<number[]>([])
-  const backlog = useBacklog()
+  const [backlog, refetchBacklog] = useBacklog()
   const boardColumns =
     backlog.status === 'ready' ? issuesToBoardColumns(backlog.issues, backlog.timelines) : undefined
   const focus =
     backlog.status === 'ready' ? scheduleFocus(backlog.issues, backlog.deps, backlog.timelines) : undefined
+  const calibration =
+    backlog.status === 'ready' ? backlogCalibration(backlog.issues, backlog.timelines) : undefined
   const forecast =
-    backlog.status === 'ready' ? (forecastBacklog(backlog.issues, backlog.deps) ?? undefined) : undefined
+    backlog.status === 'ready'
+      ? (forecastBacklog(backlog.issues, backlog.deps, new Date(), calibration?.model) ?? undefined)
+      : undefined
 
   useEffect(() => {
     document.documentElement.setAttribute('data-theme', dark ? 'dark' : 'light')
@@ -103,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' },
@@ -178,10 +195,11 @@ export function AppShell() {
           <RunwayScreen
             onOpenCalibration={() => setView('calibration')}
             onOpenMilestone={() => setView('milestone')}
+            calibration={calibration ? { n: calibration.model.n, coldStart: calibration.model.coldStart } : undefined}
           />
         )
       case 'calibration':
-        return <CalibrationScreen onBack={() => setView('runway')} />
+        return <CalibrationScreen onBack={() => setView('runway')} data={calibration?.data} />
       case 'milestone':
         return <MilestoneScreen onBack={() => setView('runway')} onOpenIssue={openIssue} />
       case 'inbox':
@@ -201,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')} />

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

@@ -1,4 +1,16 @@
-import type { DependencyEdge, GiteaIssue, GiteaMilestone, LifecycleEvent } from '@commitea/core'
+import type {
+  DependencyEdge,
+  GiteaIssue,
+  GiteaMilestone,
+  IssueChange,
+  LabelPlan,
+  LifecycleEvent,
+} 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 gitea bridge exposed by the preload over IPC (main-process backed). */
 export interface GiteaBridge {
@@ -12,6 +24,7 @@ export interface GiteaBridge {
     timelines: Record<number, LifecycleEvent[]>
   }>
   getIssue(index: number): Promise<GiteaIssue | null>
+  applyChange(change: IssueChange): Promise<ApplyChangeResult>
 }
 
 declare global {

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

@@ -1,17 +1,24 @@
 import {
+  type CalibrationModel,
+  type CalibrationSample,
+  calibrationSamples,
+  COLD_START_THRESHOLD,
   type DependencyEdge,
+  fitCalibration,
   forecast,
   type GiteaIssue,
   inferLifecycle,
   type LifecycleColumn,
   type LifecycleEvent,
   type LifecycleInference,
+  PRIOR_BUCKETS,
   schedule,
   type ScheduledItem,
   selectFocus,
+  toDurationModel,
 } from '@commitea/core'
 
-import { type BoardColumn, type BoardIssue, type FocusIssue } from '../data/fixtures.js'
+import { type BoardColumn, type BoardIssue, type CalibrationData, type FocusIssue } from '../data/fixtures.js'
 import { type BurnUpData, buildBurnUpData } from './dates.js'
 
 type Timelines = Record<number, LifecycleEvent[]>
@@ -100,22 +107,109 @@ export interface ForecastView {
   cone: BurnUpData
   p80Label: string
   rangeLabel: string
+  /** true while the forecast still runs on code priors (calibration not yet trusted). */
+  coldStart: boolean
+  /** Closed-with-estimate issues feeding calibration so far. */
+  calibratedN: number
 }
 
 /**
  * Monte Carlo forecast over the open backlog, mapped onto a calendar-anchored
- * burn-up cone. Returns null when there's nothing to forecast (no open scope) —
- * the UI then falls back to the demo cone. `today` is injectable for tests.
+ * burn-up cone. When a calibration model is supplied and past cold-start, its
+ * fitted params drive the sim. Returns null when there's nothing to forecast.
+ * `today` is injectable for tests.
  */
 export function forecastBacklog(
   issues: GiteaIssue[],
   deps: DependencyEdge[],
   today: Date = new Date(),
+  calibration?: CalibrationModel,
 ): ForecastView | null {
-  const f = forecast(toSchedulable(issues), deps)
+  const model = calibration ? toDurationModel(calibration) : undefined
+  const f = forecast(toSchedulable(issues), deps, model ? { model } : {})
   const cone = buildBurnUpData(f, today)
   if (!cone) return null
-  return { scope: f.scope, cone, p80Label: cone.p80Label, rangeLabel: cone.rangeLabel }
+  return {
+    scope: f.scope,
+    cone,
+    p80Label: cone.p80Label,
+    rangeLabel: cone.rangeLabel,
+    coldStart: f.coldStart,
+    calibratedN: calibration?.n ?? 0,
+  }
+}
+
+/** Fit the calibration model from the closed backlog's inferred actuals (#1). */
+export function calibrateBacklog(
+  issues: GiteaIssue[],
+  timelines: Timelines = {},
+  asOf: Date = new Date(),
+): CalibrationModel {
+  return fitCalibration(calibrationSamples(issues, timelines, asOf))
+}
+
+/** Calibration model + its screen view in one pass over the closed backlog. */
+export function backlogCalibration(
+  issues: GiteaIssue[],
+  timelines: Timelines = {},
+  asOf: Date = new Date(),
+): { model: CalibrationModel; data: CalibrationData } {
+  const samples = calibrationSamples(issues, timelines, asOf)
+  const model = fitCalibration(samples)
+  return { model, data: calibrationData(model, samples, issues) }
+}
+
+const pctFromMu = (mu: number) => Math.round((Math.exp(mu) - 1) * 100)
+
+/**
+ * Shape the calibration model + its samples into the screen's view. Buckets and
+ * people only earn a bias once their sample clears the fit floor; everything
+ * degrades honestly on a thin (cold-start) dataset.
+ */
+export function calibrationData(
+  model: CalibrationModel,
+  samples: CalibrationSample[],
+  openIssues: GiteaIssue[],
+): CalibrationData {
+  const labels = PRIOR_BUCKETS.map((b) => {
+    const inBucket = samples.filter((s) => s.bucket === b)
+    const fit = model.byBucket[b]
+    const mu = fit ? fit.mu : model.global.mu
+    return {
+      label: `est/${b}d`,
+      n: fit ? fit.n : inBucket.length,
+      median: inBucket.length ? `${(b * Math.exp(mu)).toFixed(1)}d` : '—',
+      bias: fit ? pctFromMu(fit.mu) : null,
+    }
+  })
+
+  const people = Object.entries(model.byPerson).map(([who, pb]) => ({
+    who,
+    n: pb.n,
+    bias: pctFromMu(model.global.mu + pb.biasMu),
+    note: '',
+  }))
+
+  const openEst = openIssues
+    .filter((i) => i.state === 'open')
+    .reduce((sum, i) => sum + (i.facts.estimateDays ?? 2), 0)
+  const effect = model.coldStart
+    ? { raw: `${model.n}/${COLD_START_THRESHOLD} estimated closes`, banded: 'cold-start priors', p50: '—' }
+    : {
+        raw: `${openEst}d estimated`,
+        banded: `×${Math.exp(model.global.mu).toFixed(2)} median drift`,
+        p50: `≈${Math.round(openEst * Math.exp(model.global.mu))}d`,
+      }
+
+  return {
+    n: model.n,
+    active: !model.coldStart,
+    labels,
+    people,
+    scatter: samples.map((s) => [s.estimateDays, s.actualWorkingDays]),
+    fit: Number(Math.exp(model.global.mu).toFixed(2)),
+    effect,
+  }
 }
 
 /**

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]
 }

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

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

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

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

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

@@ -0,0 +1,54 @@
+import { describe, expect, it } from 'vitest'
+
+import { describeChange, type IssueChange, planIssueChange } 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')
+  })
+})

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

@@ -0,0 +1,59 @@
+/**
+ * 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}`
+}

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

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

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

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

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

@@ -123,6 +123,29 @@ 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('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,10 @@ 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>
 }
 
 /** Map raw gitea issue JSON to the normalized domain shape. Pure. */
@@ -144,18 +149,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 +211,16 @@ 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 } })
+    },
   }
 }

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 } from './changes/apply-changes-v0.js'
+export type { IssueChange, LabelPlan } from './changes/apply-changes-v0.js'
+
 export {
   inferColumnV0,
   inferLifecycle,
@@ -45,5 +49,32 @@ export type {
   SchedulePlan,
 } from './scheduler/scheduler-v0.js'
 
-export { COLD_START_PRIORS, forecast, priorForEstimate } from './forecast/forecast-v0.js'
-export type { BurnUpPoint, Forecast, ForecastOptions, LognormalPrior } from './forecast/forecast-v0.js'
+export {
+  COLD_START_PRIORS,
+  durationParams,
+  forecast,
+  nearestBucket,
+  PRIOR_BUCKETS,
+  priorForEstimate,
+} from './forecast/forecast-v0.js'
+export type {
+  BurnUpPoint,
+  DurationModel,
+  Forecast,
+  ForecastOptions,
+  LognormalPrior,
+} from './forecast/forecast-v0.js'
+
+export {
+  CALIBRATION_BUCKET_FLOOR,
+  calibrationSamples,
+  COLD_START_THRESHOLD,
+  fitCalibration,
+  toDurationModel,
+} from './calibration/calibration-v0.js'
+export type {
+  BucketFit,
+  CalibrationModel,
+  CalibrationSample,
+  PersonBias,
+} from './calibration/calibration-v0.js'