test: point the live milestone assertion at P5 after the backlog reconcile

Closed the 15 genuinely-shipped issues on the dogfood repo (scheduler, Monte Carlo,
calibration, lifecycle, model router, query_project, capture_work, record_directive,
etc.) so the board reflects reality: 10 open / 24 done. P2 dropped off Runway once
all its work shipped (a milestone with no open scope isn't runway — correct), so the
live spec now drills into P5 (which still has open scope) instead of P2.

No code change — this only updates the live assertion to match the reconciled backlog.

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

apps/desktop/README.md

@@ -1,42 +0,0 @@
-# CommiTea (desktop)
-
-An AI project manager for Gitea, as an Electron desktop app. The token stays in
-the main process (OS keychain via `safeStorage`); the renderer never sees it.
-
-## Develop
-
-```bash
-yarn dev          # electron-vite dev, HMR renderer + main (logs → desktop.log)
-yarn typecheck
-yarn e2e          # builds, then Playwright against the built main (fixtures/demo)
-```
-
-For a live pass against a real Gitea, put a token in `.env.local`
-(`GITEA_TOKEN=…`) and run `GITEA_LIVE=1 yarn e2e live-onboarding`.
-
-## Package (shareable macOS .dmg)
-
-```bash
-yarn pack         # unpacked .app for the host arch (fast sanity check) → dist/
-yarn dist         # arm64 + x64 .dmg → dist/CommiTea-<version>[-arm64].dmg
-```
-
-Config is `electron-builder.yml`. Builds are **unsigned** (no Apple certs, by
-decision) — electron-builder ad-hoc signs so the app can run, but it is not
-notarized. Bump `version` in `package.json` for a new release; keep
-`electronVersion` in `electron-builder.yml` in sync with the `electron`
-devDependency.
-
-### Installing a shared build (teammates)
-
-macOS Gatekeeper blocks unsigned apps on first launch. To open:
-
-1. Open the `.dmg` and drag **CommiTea** to **Applications**.
-2. In Applications, **right-click CommiTea → Open**, then confirm **Open** in the
-   dialog. (Double-clicking the first time just shows "cannot be opened".)
-3. It opens to the connection screen — enter your Gitea base URL, `owner/repo`,
-   and a personal access token (repo scope). Each teammate uses their own token,
-   so activity is attributed correctly. A model URL is optional; chat is disabled
-   until one is configured, everything else works without it.
-
-Grab the `-arm64` dmg on Apple Silicon, the plain one on Intel.

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

@@ -11,7 +11,6 @@ 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')
@@ -43,15 +42,15 @@ 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 (Beta / Pilot-ready / v1.0). The runway shows milestones with open
+    // fixture (which lists Beta / Pilot-ready / v1.0). Only milestones with open
-    // scope; P5 is active (P2 is fully shipped, so it's correctly omitted).
+    // scope appear (P2 dropped off once all its work shipped — correct).
     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 (active) milestone opens its real detail
+    // Milestone drill-in — clicking a real 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()
@@ -70,15 +69,10 @@ 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 issue')).toBeVisible()
+    await expect(win.getByText('Adjust estimate & priority')).toBeVisible()
     await win.getByRole('combobox').first().selectOption('est/8d')
-    await expect(win.getByText('Proposed change')).toBeVisible()
+    await expect(win.getByText('Proposed label 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/e2e/live-onboarding.spec.ts

@@ -1,85 +0,0 @@
-import { dirname, join } from 'node:path'
-import { mkdtempSync, readFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { fileURLToPath } from 'node:url'
-
-import { _electron as electron, expect, test } from '@playwright/test'
-
-const here = dirname(fileURLToPath(import.meta.url))
-const MAIN = join(here, '..', 'out', 'main', 'index.js')
-
-/** Read the real token from .env.local (walking up) so the test can fill the form. */
-function readToken(): string | null {
-  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 */
-    }
-    dir = dirname(dir)
-  }
-  return null
-}
-
-// Opt-in (GITEA_LIVE=1). Forces the onboarding path (COMMITEA_NO_ENV_LOCAL) with a
-// fresh userData, fills the real connection form, and asserts it lands on real data.
-test.describe('live onboarding', () => {
-  test('connect form → real board', async () => {
-    const token = process.env.GITEA_LIVE ? readToken() : null
-    test.skip(!token, 'GITEA_LIVE + a .env.local token required')
-    test.setTimeout(90_000)
-
-    const app = await electron.launch({
-      args: [MAIN],
-      env: { ...process.env, COMMITEA_NO_ENV_LOCAL: '1', COMMITEA_USERDATA: mkdtempSync(join(tmpdir(), 'commitea-')) },
-    })
-    const win = await app.firstWindow()
-    await win.waitForLoadState('domcontentloaded')
-
-    // Any uncaught render error in a real-data view builder must fail the test —
-    // this is the "it actually works on real data" guarantee.
-    const pageErrors: string[] = []
-    win.on('pageerror', (e) => pageErrors.push(e.message))
-
-    // the connection gate, not the app
-    await expect(win.getByText(/Connect your Gitea/)).toBeVisible({ timeout: 15000 })
-    await win.getByPlaceholder('your-org').fill('christian')
-    await win.getByPlaceholder('your-repo').fill('commitea')
-    await win.getByPlaceholder(/gitea PAT/).fill(token!)
-    await win.getByRole('button', { name: 'Connect' }).click()
-
-    const rail = win.getByRole('navigation', { name: 'Primary' })
-    const realTitle = /Model router|SQLite cache bootstrap|Purity\/rebuild/
-
-    // Board (real reconciled columns) — real issue titles prove the sync landed.
-    await rail.getByRole('button', { name: 'The pot' }).click()
-    await expect(win.getByText(realTitle).first()).toBeVisible({ timeout: 30000 })
-
-    // Gantt tab — scheduler-derived bars over the real open backlog.
-    await win.getByRole('tab', { name: 'Gantt' }).click()
-    await expect(win.getByText(realTitle).first()).toBeVisible()
-
-    // Dependencies tab — real dep graph. Just needs to render without throwing.
-    await win.getByRole('tab', { name: 'Dependencies' }).click()
-    await win.waitForTimeout(300)
-
-    // Issue drill-in — the machine-derived sidecar (lifecycle/forecast/deps) on a real issue.
-    await win.getByRole('tab', { name: 'Board' }).click()
-    await win.getByText(realTitle).first().click()
-    await expect(win.getByText('Machine-derived')).toBeVisible()
-    await win.getByRole('button', { name: 'Back' }).click()
-
-    // Standup + Inbox — scheduler plan / nag / inbox feed over real data.
-    await rail.getByRole('button', { name: 'Standup' }).click()
-    await expect(win.getByRole('heading', { name: 'Morning standup' })).toBeVisible()
-    await rail.getByRole('button', { name: 'Inbox' }).click()
-    await expect(win.getByRole('heading', { name: 'Inbox' })).toBeVisible()
-
-    await win.screenshot({ path: join(here, '.artifacts', 'screens', 'live-onboarding.png'), fullPage: true, animations: 'disabled' })
-    expect(pageErrors, `uncaught render errors: ${pageErrors.join(' · ')}`).toEqual([])
-
-    await app.close()
-  })
-})

apps/desktop/e2e/smoke.spec.ts

@@ -97,7 +97,7 @@ test('Directives: consequence diff + append-only ledger', async ({ app, window }
 test('Settings: connection, schema, and appearance sync with theme', async ({ app, window }) => {
   await app.nav('Settings').click()
   await expect(window.getByRole('heading', { name: 'Settings' })).toBeVisible()
-  await expect(window.getByRole('heading', { name: 'Connection' })).toBeVisible()
+  await expect(window.getByText('Managed repos')).toBeVisible()
   await app.screenshot('settings')
   // the Evening (dark) radio drives the shared theme
   await window.getByText('Evening (dark)').click()

apps/desktop/electron-builder.yml

@@ -1,51 +0,0 @@
-appId: io.stephenmann.commitea
-productName: CommiTea
-copyright: © CommiTea
-
-# Pinned because electron is hoisted by the yarn workspace and declared with a
-# caret range, which electron-builder can't resolve on its own. Keep in sync with
-# the electron devDependency.
-electronVersion: 34.5.8
-
-directories:
-  buildResources: build
-  output: dist
-
-# The renderer, preload, and main are already bundled into out/ by electron-vite
-# (@commitea/core, react, react-dom are all inlined). So the packaged app needs
-# nothing from node_modules except the Electron runtime that electron-builder
-# supplies — ship only the build output.
-files:
-  - out/**
-  - '!**/*.map'
-npmRebuild: false
-electronLanguages:
-  - en
-
-mac:
-  target:
-    - target: dmg
-      arch:
-        - arm64
-        - x64
-  category: public.app-category.developer-tools
-  icon: build/icon.png
-  # Unsigned, per the distribution decision (macOS, no certs). Teammates
-  # right-click → Open the first time to get past Gatekeeper.
-  identity: null
-  # Keep hardened-runtime off — it only matters for signed/notarized builds
-  # and can block an unsigned app from launching.
-  hardenedRuntime: false
-  gatekeeperAssess: false
-
-dmg:
-  title: CommiTea ${version}
-  # A plain drag-to-Applications layout.
-  contents:
-    - x: 130
-      y: 220
-      type: file
-    - x: 410
-      y: 220
-      type: link
-      path: /Applications

apps/desktop/package.json

@@ -1,8 +1,5 @@
 {
   "name": "@commitea/desktop",
-  "version": "0.1.0",
-  "description": "CommiTea — an AI project manager for Gitea",
-  "author": "CommiTea",
   "private": true,
   "type": "module",
   "main": "./out/main/index.js",
@@ -13,9 +10,7 @@
     "typecheck": "tsc --noEmit",
     "e2e": "electron-vite build && playwright test",
     "e2e:only": "playwright test",
-    "e2e:report": "playwright show-report e2e/.artifacts/report",
+    "e2e:report": "playwright show-report e2e/.artifacts/report"
-    "pack": "electron-vite build && electron-builder --dir",
-    "dist": "electron-vite build && electron-builder --mac"
   },
   "dependencies": {
     "@commitea/core": "workspace:*",
@@ -30,11 +25,9 @@
     "@vitejs/plugin-react": "^4.3.4",
     "autoprefixer": "^10.4.20",
     "electron": "^34.0.0",
-    "electron-builder": "^25",
     "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

@@ -1,142 +0,0 @@
-/**
- * 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/config-store.ts

@@ -1,101 +0,0 @@
-/**
- * Persistent app config for a shared/team build. The gitea PAT is encrypted at
- * rest with Electron's safeStorage (OS keychain-backed) and only ever lives in
- * the main process — the renderer receives everything *except* the token. Config
- * lives in userData so each teammate has their own; a `.env.local` remains a dev
- * fallback (see resolveConfig). Nothing here runs under COMMITEA_E2E.
- */
-
-import { readFileSync, writeFileSync } from 'node:fs'
-import { join } from 'node:path'
-
-import { app, safeStorage } from 'electron'
-
-export interface AppConfig {
-  baseUrl: string
-  owner: string
-  repo: string
-  token: string
-  /** Defaults to `${repo}-pm-state` when omitted. */
-  pmStateRepo?: string
-  /** OpenAI-compatible base for Reginald; chat stays off when absent. */
-  modelUrl?: string
-}
-
-/** The renderer-safe view — everything but the token, plus whether one is set. */
-export type PublicConfig = Omit<AppConfig, 'token'> & { hasToken: boolean }
-
-interface StoredConfig {
-  baseUrl: string
-  owner: string
-  repo: string
-  tokenEnc: string | null // base64 of safeStorage-encrypted token
-  pmStateRepo?: string
-  modelUrl?: string
-}
-
-function configPath(): string {
-  return join(app.getPath('userData'), 'commitea-config.json')
-}
-
-function readStored(): StoredConfig | null {
-  try {
-    return JSON.parse(readFileSync(configPath(), 'utf8')) as StoredConfig
-  } catch {
-    return null
-  }
-}
-
-/** Full config incl. the decrypted token, or null when unset. Main-process only. */
-export function loadConfig(): AppConfig | null {
-  const s = readStored()
-  if (!s || !s.baseUrl || !s.owner || !s.repo) return null
-  let token = ''
-  if (s.tokenEnc) {
-    try {
-      token = safeStorage.decryptString(Buffer.from(s.tokenEnc, 'base64'))
-    } catch {
-      token = '' // key rotated / different machine — treat as no token
-    }
-  }
-  if (!token) return null
-  return { baseUrl: s.baseUrl, owner: s.owner, repo: s.repo, token, pmStateRepo: s.pmStateRepo, modelUrl: s.modelUrl }
-}
-
-/** The renderer-safe view of the saved config (never includes the token). */
-export function publicConfig(): PublicConfig | null {
-  const s = readStored()
-  if (!s) return null
-  return {
-    baseUrl: s.baseUrl,
-    owner: s.owner,
-    repo: s.repo,
-    pmStateRepo: s.pmStateRepo,
-    modelUrl: s.modelUrl,
-    hasToken: !!s.tokenEnc,
-  }
-}
-
-/** Encrypt the token + persist. Best-effort; throws only on a genuine write failure. */
-export function saveConfig(cfg: AppConfig): void {
-  const tokenEnc = cfg.token
-    ? Buffer.from(safeStorage.encryptString(cfg.token)).toString('base64')
-    : (readStored()?.tokenEnc ?? null) // keep the existing token if none supplied
-  const stored: StoredConfig = {
-    baseUrl: cfg.baseUrl.trim().replace(/\/+$/, ''),
-    owner: cfg.owner.trim(),
-    repo: cfg.repo.trim(),
-    tokenEnc,
-    pmStateRepo: cfg.pmStateRepo?.trim() || undefined,
-    modelUrl: cfg.modelUrl?.trim() || undefined,
-  }
-  writeFileSync(configPath(), JSON.stringify(stored, null, 2), 'utf8')
-}
-
-export function clearConfig(): void {
-  try {
-    writeFileSync(configPath(), JSON.stringify({ baseUrl: '', owner: '', repo: '', tokenEnc: null }), 'utf8')
-  } catch {
-    // ignore
-  }
-}

apps/desktop/src/main/gitea.ts

@@ -13,13 +13,11 @@ import { dirname, join } from 'node:path'
 import {
   appendDirective,
   createGiteaClient,
-  GiteaApiError,
   type DirectiveEntry,
   type GiteaClient,
   type GiteaConfig,
   type GiteaLabel,
   type IssueChange,
-  isLabelChange,
   type LifecycleEvent,
   makeDirectiveEntry,
   parseCapacityConfig,
@@ -30,7 +28,6 @@ import {
 } from '@commitea/core'
 import { ipcMain } from 'electron'
 
-import { type AppConfig, clearConfig, loadConfig, publicConfig, saveConfig } from './config-store.js'
 import { loadSnapshot, saveSnapshot } from './snapshot-store.js'
 
 /** Walk up from cwd looking for a .env.local with a GITEA_TOKEN (dev convenience). */
@@ -51,15 +48,9 @@ function loadEnvLocalToken(): string | undefined {
   return undefined
 }
 
-/** Saved config wins (team build); a `.env.local` is the dev fallback; e2e uses fixtures. */
+function resolveConfig(): GiteaConfig | null {
-export function resolveConfig(): GiteaConfig | null {
   // E2E runs against fixtures — never hit the network from the test harness.
   if (process.env.COMMITEA_E2E === '1') return null
-  const saved = loadConfig()
-  if (saved) return { baseUrl: saved.baseUrl, token: saved.token, owner: saved.owner, repo: saved.repo }
-  // COMMITEA_NO_ENV_LOCAL forces the onboarding path (no .env.local fallback) for testing.
-  if (process.env.COMMITEA_NO_ENV_LOCAL === '1') return null
-  // dev fallback — .env.local / env vars
   const token = process.env.GITEA_TOKEN ?? loadEnvLocalToken()
   if (!token) return null
   return {
@@ -70,23 +61,8 @@ export function resolveConfig(): GiteaConfig | null {
   }
 }
 
-/** The pm-state repo name: configured, else `${repo}-pm-state`, else the env override. */
+// Memoized client so both the gitea and model bridges share one instance.
-function pmStateRepoName(config: GiteaConfig): string {
-  return loadConfig()?.pmStateRepo ?? process.env.COMMITEA_PMSTATE_REPO ?? `${config.repo}-pm-state`
-}
-
-// Memoized clients; reset via resetClients() when the config changes.
 let sharedClient: GiteaClient | null | undefined
-let pmStateClient: GiteaClient | null | undefined
-
-/** Drop the cached clients + snapshot so the next call re-reads the new config. */
-export function resetClients(): void {
-  sharedClient = undefined
-  pmStateClient = undefined
-  labelCache = null
-  invalidateSnapshot()
-}
-
 export function getGiteaClient(): GiteaClient | null {
   if (sharedClient === undefined) {
     const config = resolveConfig()
@@ -97,10 +73,13 @@ export function getGiteaClient(): GiteaClient | null {
 
 // The pm-state repo holds machine-derived state (the directive ledger). Same
 // token/host as the work repo, a different repo (the purity split, decisions D4).
+let pmStateClient: GiteaClient | null | undefined
 export function getPmStateClient(): GiteaClient | null {
   if (pmStateClient === undefined) {
     const config = resolveConfig()
-    pmStateClient = config ? createGiteaClient({ ...config, repo: pmStateRepoName(config) }, fetch) : null
+    pmStateClient = config
+      ? createGiteaClient({ ...config, repo: process.env.COMMITEA_PMSTATE_REPO ?? 'commitea-pm-state' }, fetch)
+      : null
   }
   return pmStateClient
 }
@@ -213,38 +192,20 @@ export function bootSnapshot(): (Snapshot & { savedAt: string }) | null {
 /** Agent tool calls tolerate a slightly stale snapshot (seconds) to stay responsive. */
 export const AGENT_SNAPSHOT_TTL_MS = 30_000
 
-// Label cache is reset with the clients (module-level so resetClients can clear it).
-let labelCache: GiteaLabel[] | null = null
-async function resolveLabelIds(client: GiteaClient, names: string[]): Promise<number[]> {
-  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)
-}
-
 export function registerGiteaIpc(): void {
-  ipcMain.handle('gitea:status', () => {
+  const client = getGiteaClient()
-    const cfg = resolveConfig()
+  const repo = client ? `${process.env.GITEA_OWNER ?? 'christian'}/${process.env.GITEA_REPO ?? 'commitea'}` : null
-    return {
+
-      configured: !!cfg,
+  ipcMain.handle('gitea:status', () => ({ configured: !!client, repo }))
-      repo: cfg ? `${cfg.owner}/${cfg.repo}` : null,
-      demo: process.env.COMMITEA_E2E === '1',
-    }
-  })
 
   // Instant boot: the last persisted snapshot, shown before the fresh reconcile lands.
   ipcMain.handle('gitea:boot', () => {
-    if (!getGiteaClient()) return { configured: false }
+    if (!client) return { configured: false }
     const persisted = bootSnapshot()
     return persisted ? { configured: true, cached: true, ...persisted } : { configured: true, cached: false }
   })
 
   ipcMain.handle('gitea:reconcile', async () => {
-    const client = getGiteaClient()
     if (!client) return { configured: false, issues: [], milestones: [], deps: [], timelines: {} }
     try {
       // explicit UI sync — force fresh, and warm the cache for agent tool calls
@@ -259,37 +220,36 @@ export function registerGiteaIpc(): void {
   })
 
   ipcMain.handle('gitea:getIssue', async (_event, index: number) => {
-    const client = getGiteaClient()
     if (!client) return null
     return client.getIssue(index)
   })
 
-  // The write path (apply_changes), applied only after the renderer's propose-
+  // Cached label list for name→id resolution; refreshed on demand if a name misses.
-  // approve. Label swaps (est/p) return the plan; field writes (assign, milestone)
+  let labelCache: GiteaLabel[] | null = null
-  // return the freshly-read issue directly. Either way the snapshot is invalidated
+  async function resolveLabelIds(names: string[]): Promise<number[]> {
-  // so the board + forecast reflect the change.
+    if (!client) return []
-  ipcMain.handle('gitea:applyChange', async (_event, change: IssueChange) => {
+    const lookup = () => new Map(labelCache!.map((l) => [l.name, l.id]))
-    const client = getGiteaClient()
+    if (!labelCache) labelCache = await client.listLabels()
-    if (!client) return { ok: false as const, reason: 'unconfigured' as const }
+    let byName = lookup()
-
+    if (names.some((n) => !byName.has(n))) {
-    if (isLabelChange(change)) {
+      labelCache = await client.listLabels() // a name we don't know — refetch once
-      const current = await client.getIssue(change.issue)
+      byName = lookup()
-      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()
-      return { ok: true as const, plan, issue }
     }
+    return names.map((n) => byName.get(n)).filter((id): id is number => id != null)
+  }
 
-    // Field writes — the client returns the updated issue.
+  // The write path (apply_changes). Additive label swaps, applied only after the
-    const issue =
+  // renderer's propose-approve. Returns the plan + the freshly-read issue.
-      change.kind === 'assign'
+  ipcMain.handle('gitea:applyChange', async (_event, change: IssueChange) => {
-        ? await client.setIssueAssignees(change.issue, change.assignee ? [change.assignee] : [])
+    if (!client) return { ok: false as const, reason: 'unconfigured' as const }
-        : await client.setIssueMilestone(change.issue, change.milestone)
+    const current = await client.getIssue(change.issue)
-    invalidateSnapshot()
+    const plan = planIssueChange(current.labels, change)
-    return { ok: true as const, issue }
+    if (plan.noop) return { ok: true as const, plan, issue: current }
+    const ids = await resolveLabelIds(plan.labels)
+    await client.setIssueLabels(change.issue, ids)
+    const issue = await client.getIssue(change.issue)
+    invalidateSnapshot() // the board + forecast must reflect the label change
+    return { ok: true as const, plan, issue }
   })
 
   // capture_work filing: open each approved issue with its est/* + p/* labels.
@@ -297,12 +257,11 @@ export function registerGiteaIpc(): void {
   ipcMain.handle(
     'gitea:createIssues',
     async (_event, issues: { title: string; body?: string; estimate?: string; priority?: string }[]) => {
-      const client = getGiteaClient()
       if (!client) return { ok: false as const, reason: 'unconfigured' as const }
       const created: { number: number; title: string }[] = []
       for (const it of issues) {
         const names = [it.estimate, it.priority].filter((n): n is string => !!n)
-        const labelIds = await resolveLabelIds(client, names)
+        const labelIds = await resolveLabelIds(names)
         const issue = await client.createIssue({ title: it.title, body: it.body, labelIds })
         created.push({ number: issue.number, title: issue.title })
       }
@@ -332,44 +291,4 @@ export function registerGiteaIpc(): void {
       return { ok: true as const, members: [] }
     }
   })
-
-  // 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())
-
-  ipcMain.handle('config:set', (_event, cfg: AppConfig) => {
-    saveConfig(cfg)
-    resetClients() // new config takes effect without a restart
-    return { ok: true as const }
-  })
-
-  ipcMain.handle('config:clear', () => {
-    clearConfig()
-    resetClients()
-    return { ok: true as const }
-  })
-
-  // Validate a token + repo before saving: any authed read on the repo proves access.
-  ipcMain.handle('config:test', async (_event, cfg: AppConfig) => {
-    try {
-      const c = createGiteaClient(
-        { baseUrl: cfg.baseUrl.replace(/\/+$/, ''), owner: cfg.owner.trim(), repo: cfg.repo.trim(), token: cfg.token },
-        fetch,
-      )
-      await c.listLabels()
-      return { ok: true as const }
-    } catch (e) {
-      return { ok: false as const, error: e instanceof GiteaApiError ? `${e.status}` : e instanceof Error ? e.message : String(e) }
-    }
-  })
 }

apps/desktop/src/main/index.ts

@@ -2,9 +2,6 @@ import { join } from 'node:path'
 
 import { BrowserWindow, app, shell } from 'electron'
 
-// Test hook: isolate config/cache to a throwaway dir (must run before any getPath).
-if (process.env.COMMITEA_USERDATA) app.setPath('userData', process.env.COMMITEA_USERDATA)
-
 import { registerGiteaIpc } from './gitea.js'
 import { registerModelIpc } from './model.js'
 

apps/desktop/src/main/model.ts

@@ -13,6 +13,7 @@ import {
   type ChangeProposal,
   type ChatMessage,
   createChatClient,
+  describeChange,
   type ModelRouter,
   type ProjectView,
   proposalsFor,
@@ -23,9 +24,8 @@ import {
   runAgentTurn,
   toDirectiveInput,
 } from '@commitea/core'
-import { app, ipcMain } from 'electron'
+import { ipcMain } from 'electron'
 
-import { loadConfig } from './config-store.js'
 import {
   AGENT_SNAPSHOT_TTL_MS,
   appendDirectiveEntry,
@@ -37,11 +37,7 @@ import {
 /** Small local model for prose + the read tool; big model reserved for later decomposition. */
 function resolveModelRouter(): ModelRouter | null {
   if (process.env.COMMITEA_E2E === '1') return null // e2e uses the scripted fixture Reginald
-  // Config wins (team build); env is the dev override; localhost is a dev convenience only.
+  const baseUrl = process.env.COMMITEA_MODEL_URL ?? 'http://localhost:1234/v1'
-  const baseUrl =
-    loadConfig()?.modelUrl ??
-    process.env.COMMITEA_MODEL_URL ??
-    (app.isPackaged ? undefined : 'http://localhost:1234/v1')
   if (!baseUrl) return null
   return {
     small: { baseUrl, model: process.env.COMMITEA_MODEL_SMALL ?? '' },
@@ -49,19 +45,6 @@ function resolveModelRouter(): ModelRouter | null {
   }
 }
 
-/** Probe the endpoint for a usable model; null when unreachable (chat then stays off). */
-async function probeModel(baseUrl: string): Promise<string | null> {
-  try {
-    const model = await resolveLoadedModel(baseUrl, process.env.COMMITEA_MODEL_SMALL ?? '')
-    // resolveLoadedModel only returns a real id when the server answered; the default
-    // fallback means unreachable, so confirm with a lightweight models call.
-    const res = await fetch(`${baseUrl.replace(/\/+$/, '')}/models`)
-    return res.ok ? model : null
-  } catch {
-    return null
-  }
-}
-
 /**
  * Resolve which model to actually ask for. An explicit env override wins;
  * otherwise ask the server which model is *loaded* (LM Studio's native
@@ -95,15 +78,15 @@ async function resolveLoadedModel(baseUrl: string, override: string): Promise<st
 }
 
 export function registerModelIpc(): void {
+  const router = resolveModelRouter()
+
   ipcMain.handle('model:status', async () => {
-    const r = resolveModelRouter() // resolve fresh so a saved modelUrl takes effect
+    if (!router) return { configured: false, model: null }
-    if (!r) return { configured: false, model: null }
+    const model = await resolveLoadedModel(router.small.baseUrl, router.small.model)
-    const model = await probeModel(r.small.baseUrl) // only "configured" if a model actually answers
+    return { configured: true, model }
-    return { configured: !!model, model }
   })
 
   ipcMain.handle('model:chat', async (event, messages: ChatMessage[]) => {
-    const router = resolveModelRouter()
     if (!router) return { ok: false as const, reason: 'unconfigured' as const }
     const client = getGiteaClient()
     const model = await resolveLoadedModel(router.small.baseUrl, router.small.model)
@@ -129,19 +112,10 @@ 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` }
-        // Milestone titles + current assignee/milestone let a proposal label the
+        const built = proposalsFor(a, issue.labels, issue.title)
-        // 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: p.summary })) }
+          ? { proposed: built.map((p) => ({ issue: a.issue, diff: describeChange(p.plan) })) }
           : { proposed: [], note: 'no change — already at that value' }
       }
       if (name === 'record_directive') {
@@ -175,7 +149,6 @@ export function registerModelIpc(): void {
   // decomposition (with one loaded local model, that's the loaded one). Returns
   // a proposal; nothing is filed until the Capture tray approves it.
   ipcMain.handle('model:capture', async (_event, braindump: string) => {
-    const router = resolveModelRouter()
     if (!router) return { ok: false as const, reason: 'unconfigured' as const }
     const model = await resolveLoadedModel(router.big.baseUrl, router.big.model)
     const chat = createChatClient({ ...router.big, model }, fetch)

apps/desktop/src/preload/index.ts

@@ -15,8 +15,6 @@ 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. */
@@ -24,16 +22,6 @@ const api = {
     /** Read the capacity config from the pm-state repo. */
     capacity: () => ipcRenderer.invoke('pmstate:capacity'),
   },
-  config: {
-    /** The saved config (never the token) — null when unset. */
-    get: () => ipcRenderer.invoke('config:get'),
-    /** Validate a token + repo before saving. */
-    test: (cfg: unknown) => ipcRenderer.invoke('config:test', cfg),
-    /** Save config (token encrypted in main); takes effect without restart. */
-    set: (cfg: unknown) => ipcRenderer.invoke('config:set', cfg),
-    /** Forget the saved config. */
-    clear: () => ipcRenderer.invoke('config:clear'),
-  },
   model: {
     /** Whether a model endpoint is configured (else the UI keeps the scripted Reginald). */
     status: () => ipcRenderer.invoke('model:status'),

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

@@ -1,6 +1,6 @@
 import React from 'react'
 
-import { COLUMNS, type BoardColumn, type BoardIssue, type DepsData, type GanttData, type IssueRef } from '../../data/fixtures.js'
+import { COLUMNS, type BoardColumn, type BoardIssue, type IssueRef } from '../../data/fixtures.js'
 import { Card, Tag, Badge, Tabs, IconButton, Input, Icon } from '../ui/index.js'
 import { EmptyState } from '../shell/states.js'
 import { GanttView } from './gantt-view.js'
@@ -12,14 +12,10 @@ import { DepsGraph } from './deps-graph.js'
 export function BoardScreen({
   onOpenIssue,
   columns = COLUMNS,
-  gantt,
-  deps,
   loading = false,
 }: {
   onOpenIssue: (issue: IssueRef) => void
   columns?: BoardColumn[]
-  gantt?: GanttData
-  deps?: DepsData
   loading?: boolean
 }) {
   const [tab, setTab] = React.useState('board');
@@ -94,9 +90,9 @@ export function BoardScreen({
           </div>
         )
       ) : tab === 'deps' ? (
-        <DepsGraph onOpenIssue={onOpenIssue} data={deps} />
+        <DepsGraph onOpenIssue={onOpenIssue} />
       ) : (
-        <GanttView onOpenIssue={onOpenIssue} data={gantt} />
+        <GanttView onOpenIssue={onOpenIssue} />
       )}
     </div>
   );

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

@@ -178,9 +178,6 @@ 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/connect-screen.tsx

@@ -1,117 +0,0 @@
-import React from 'react'
-
-import type { PublicConfig } from '../../global.js'
-import logoIcon from '../../design/assets/logo-icon.png'
-import { Button, Card, Input } from '../ui/index.js'
-
-/**
- * Real onboarding — each teammate connects their own Gitea with a personal access
- * token. The token is validated (an authed read on the repo) then saved encrypted
- * in the main process (never exposed to this renderer). Optional model URL wires
- * Reginald; leave it blank and chat simply stays off.
- */
-export function ConnectScreen({ onConnected, existing }: { onConnected: () => void; existing?: PublicConfig | null }) {
-  const [baseUrl, setBaseUrl] = React.useState(existing?.baseUrl ?? 'https://gitea.stephenmann.io')
-  const [owner, setOwner] = React.useState(existing?.owner ?? '')
-  const [repo, setRepo] = React.useState(existing?.repo ?? '')
-  const [token, setToken] = React.useState('')
-  const [modelUrl, setModelUrl] = React.useState(existing?.modelUrl ?? '')
-  const [state, setState] = React.useState<'idle' | 'testing' | 'saving'>('idle')
-  const [error, setError] = React.useState<string | null>(null)
-
-  const cfg = () => ({ baseUrl, owner, repo, token, modelUrl: modelUrl.trim() || undefined })
-  const ready = baseUrl.trim() && owner.trim() && repo.trim() && (token.trim() || existing?.hasToken)
-
-  const connect = async () => {
-    setError(null)
-    setState('testing')
-    // reuse the saved token when editing and the field is left blank
-    const payload = token.trim() ? cfg() : { ...cfg(), token: '' }
-    if (token.trim()) {
-      const test = await window.commitea.config.test(cfg()).catch(() => ({ ok: false, error: 'unreachable' }))
-      if (!test.ok) {
-        setState('idle')
-        setError(
-          test.error === '404'
-            ? "Couldn't find that repo — check owner/name and that the token can see it."
-            : test.error === '401' || test.error === '403'
-              ? 'The token was rejected — check it has repo + issue scopes.'
-              : `Connection failed${test.error ? ` (${test.error})` : ''}.`,
-        )
-        return
-      }
-    }
-    setState('saving')
-    await window.commitea.config.set(payload)
-    onConnected()
-  }
-
-  const field = (
-    label: string,
-    value: string,
-    set: (v: string) => void,
-    opts: { placeholder?: string; type?: string; hint?: string } = {},
-  ) => (
-    <div style={{ display: 'flex', flexDirection: 'column', gap: 5 }}>
-      <Input
-        label={label}
-        value={value}
-        type={opts.type}
-        placeholder={opts.placeholder}
-        onChange={(e) => set(e.target.value)}
-      />
-      {opts.hint ? <span style={{ font: 'var(--text-caption)', color: 'var(--ink-3)' }}>{opts.hint}</span> : null}
-    </div>
-  )
-
-  return (
-    <div
-      style={{
-        height: '100vh',
-        display: 'flex',
-        alignItems: 'center',
-        justifyContent: 'center',
-        background: 'var(--surface-app)',
-        padding: 24,
-      }}
-    >
-      <Card style={{ width: 460, maxWidth: '100%' }}>
-        <div style={{ display: 'flex', alignItems: 'center', gap: 10, marginBottom: 6 }}>
-          <img src={logoIcon} width="28" height="28" alt="" style={{ borderRadius: 7, display: 'block' }} />
-          <span style={{ font: '400 24px/1 var(--font-serif-display)', color: 'var(--ink-1)' }}>
-            Commi<span style={{ color: 'var(--accent-text)' }}>Tea</span>
-          </span>
-        </div>
-        <p style={{ font: 'var(--text-body)', color: 'var(--ink-2)', margin: '0 0 18px' }}>
-          Connect your Gitea. Your token is stored encrypted on this machine and never leaves it.
-        </p>
-
-        <div style={{ display: 'flex', flexDirection: 'column', gap: 12 }}>
-          {field('Gitea URL', baseUrl, setBaseUrl, { placeholder: 'https://gitea.example.com' })}
-          <div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: 12 }}>
-            {field('Owner', owner, setOwner, { placeholder: 'your-org' })}
-            {field('Repository', repo, setRepo, { placeholder: 'your-repo' })}
-          </div>
-          {field('Access token', token, setToken, {
-            type: 'password',
-            placeholder: existing?.hasToken ? '•••••••• (saved — leave blank to keep)' : 'gitea PAT · scopes: repo + issue',
-          })}
-          {field('Model URL', modelUrl, setModelUrl, {
-            placeholder: 'http://localhost:1234/v1',
-            hint: 'Optional — an OpenAI-compatible endpoint for Reginald. Leave blank to keep chat off.',
-          })}
-        </div>
-
-        {error ? (
-          <p style={{ font: 'var(--text-agent)', color: 'var(--danger)', margin: '12px 0 0' }}>{error}</p>
-        ) : null}
-
-        <div style={{ display: 'flex', gap: 10, marginTop: 18 }}>
-          <Button onClick={() => void connect()} disabled={!ready || state !== 'idle'}>
-            {state === 'testing' ? 'Checking…' : state === 'saving' ? 'Connecting…' : existing ? 'Save' : 'Connect'}
-          </Button>
-        </div>
-      </Card>
-    </div>
-  )
-}

apps/desktop/src/renderer/src/components/screens/deps-graph.tsx

@@ -1,11 +1,11 @@
 import React from 'react'
 
-import { DEPS, type DepsData, type IssueRef } from '../../data/fixtures.js'
+import { DEPS, type IssueRef } from '../../data/fixtures.js'
 import { Tag, Icon } from '../ui/index.js'
 
 // Dependency graph drill-in — layered DAG, critical path in spruce
-export function DepsGraph({ onOpenIssue, data }: { onOpenIssue: (issue: IssueRef) => void; data?: DepsData }) {
+export function DepsGraph({ onOpenIssue }: { onOpenIssue: (issue: IssueRef) => void }) {
-  const g = data ?? DEPS
+  const g = DEPS
 
   const PAD = 14, COLW = 206, ROWH = 106, NW = 176, NH = 84
   const X = (c: number) => PAD + c * COLW

apps/desktop/src/renderer/src/components/screens/gantt-view.tsx

@@ -1,11 +1,11 @@
 import React from 'react'
 
-import { GANTT, type GanttData, type IssueRef } from '../../data/fixtures.js'
+import { GANTT, type IssueRef } from '../../data/fixtures.js'
 import { Icon } from '../ui/index.js'
 
 // Gantt drill-in — scheduler-derived bars, critical chain, 80% forecast tails
-export function GanttView({ onOpenIssue, data }: { onOpenIssue: (issue: IssueRef) => void; data?: GanttData }) {
+export function GanttView({ onOpenIssue }: { onOpenIssue: (issue: IssueRef) => void }) {
-  const g = data ?? GANTT;
+  const g = GANTT;
 
   const LABELW = 232, DAYW = 21, ROWH = 36, HEADH = 30;
   const chartW = g.days * DAYW;

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

@@ -9,15 +9,13 @@ export function InboxScreen({
   onOpenDirectives,
   readIds,
   setReadIds,
-  data,
 }: {
   onOpenIssue: (issue: IssueRef) => void
   onOpenDirectives: () => void
   readIds: number[]
   setReadIds: React.Dispatch<React.SetStateAction<number[]>>
-  data?: InboxItem[]
 }) {
-  const all = data ?? INBOX
+  const all = INBOX
   const [tab, setTab] = React.useState('all')
 
   const isRead = (n: InboxItem) => !n.unread || readIds.includes(n.id)

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

@@ -2,12 +2,13 @@
 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'
@@ -17,28 +18,18 @@ const NONE = '—'
 
 export function IssueScreen({
   issue,
-  detail,
   onBack,
   onOpenIssue,
   canWrite = false,
   onApplyChange,
-  collaborators = [],
-  milestones = [],
-  currentAssignee = null,
-  currentMilestoneId = null,
 }: {
   issue: IssueRef
-  detail?: IssueDetail
   onBack: () => void
   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] ?? {
+  const det: IssueDetail = ISSUE_DETAIL[issue.id] || {
     state: 'triage',
     assignee: 'Stephen',
     milestone: 'Beta',
@@ -69,40 +60,25 @@ 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 field that differs
+  // 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 })
-  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) => summarizeChange(c, labels))
+  const diffs = pendingChanges.map((c) => describeChange(planIssueChange(labels, c)))
 
   const apply = async () => {
     if (!onApplyChange || pendingChanges.length === 0) return
@@ -117,14 +93,6 @@ 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 }}>
@@ -165,7 +133,7 @@ export function IssueScreen({
       <Dialog
         open={adjustOpen}
         onClose={() => setAdjustOpen(false)}
-        title="Adjust issue"
+        title="Adjust estimate & priority"
         footer={
           <>
             <Button variant="ghost" onClick={() => setAdjustOpen(false)}>
@@ -191,35 +159,15 @@ 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, priority, assignee, or milestone.
+              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 change
+                Proposed label change
               </p>
               {diffs.map((d) => (
                 <div key={d} style={{ font: '500 13px var(--font-mono)', color: 'var(--ink-1)' }}>
@@ -227,7 +175,7 @@ export function IssueScreen({
                 </div>
               ))}
               <p style={{ font: 'var(--text-agent)', color: 'var(--ink-2)', margin: '8px 0 0' }}>
-                Writes to gitea and re-runs the plan. Nothing else changes.
+                Writes the label to gitea and re-runs the plan. Nothing else changes.
               </p>
             </>
           )}
@@ -319,7 +267,7 @@ export function IssueScreen({
                       <span style={{ font: '400 11px var(--font-mono)', color: 'var(--ink-3)' }}>blocks</span>
                       {det.blocks.map((b) => (
                         <button key={b} type="button"
-                          onClick={() => onOpenIssue({ id: b })}
+                          onClick={() => onOpenIssue({ id: b, title: b === 91 ? 'Webhook listener: reconcile on reconnect' : 'Monte Carlo engine: percentile bands', labels: b === 91 ? ['est/3d', 'p/2'] : ['est/5d', 'p/1'] })}
                           style={{ font: '500 11px var(--font-mono)', color: 'var(--accent-text)', background: 'var(--spruce-1)', border: '1px solid var(--spruce-2)', borderRadius: 'var(--radius-1)', padding: '2px 7px', cursor: 'pointer' }}>
                           #{b}
                         </button>

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; excludedSameDay?: number }
+  calibration?: { n: number; coldStart: boolean }
   milestones?: RunwayMilestone[]
   capacity?: CapacityMember[]
 }) {
@@ -30,11 +30,9 @@ 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/screens/settings-screen.tsx

@@ -1,22 +1,9 @@
 import React from 'react'
 
-import type { PublicConfig } from '../../global.js'
 import { Badge, Button, Card, Icon, IconButton, Input, Radio, Select, Switch, Tag } from '../ui/index.js'
 
 // Settings — gitea connection, sync, model roles, labels, rituals, appearance
-export function SettingsScreen({
+export function SettingsScreen({ dark, setDark }: { dark: boolean; setDark: (v: boolean) => void }) {
-  dark,
-  setDark,
-  connection,
-  onReconnect,
-  onDisconnect,
-}: {
-  dark: boolean
-  setDark: (v: boolean) => void
-  connection?: PublicConfig | null
-  onReconnect?: () => void
-  onDisconnect?: () => void
-}) {
   const [webhooks, setWebhooks] = React.useState(true)
   const [reconcile, setReconcile] = React.useState(true)
   const [poll, setPoll] = React.useState(true)
@@ -37,35 +24,25 @@ export function SettingsScreen({
       </header>
 
       <Card overline="Gitea" title="Connection">
-        <div style={{ display: 'flex', flexDirection: 'column', gap: 12 }}>
+        <div style={{ display: 'flex', flexDirection: 'column', gap: 14 }}>
-          {connection ? (
+          <Input label="Base URL" icon="link" mono defaultValue="https://gitea.stephenmann.io" />
-            <>
+          <Input label="Access token" icon="keyboard" mono type="password" defaultValue="ct_9f2e81c4a7d6" hint="Scopes: repo, issue. Nothing more." />
-              <Row style={{ padding: '8px 12px', background: 'var(--paper-0)', border: '1px solid var(--line-1)', borderRadius: 'var(--radius-2)' }}>
+          <div style={{ display: 'flex', flexDirection: 'column', gap: 8 }}>
-                <Icon name="git-branch" size={14} style={{ color: 'var(--ink-3)' }} />
+            <span style={{ font: '600 13px/1.2 var(--font-sans)', color: 'var(--ink-1)' }}>Managed repos</span>
-                <span style={{ font: 'var(--text-data)', color: 'var(--ink-1)', flex: 1 }}>{connection.owner}/{connection.repo}</span>
+            <Row style={{ padding: '8px 12px', background: 'var(--paper-0)', border: '1px solid var(--line-1)', borderRadius: 'var(--radius-2)' }}>
-                <Badge tone="ok" dot>connected</Badge>
+              <Icon name="git-branch" size={14} style={{ color: 'var(--ink-3)' }} />
-              </Row>
+              <span style={{ font: 'var(--text-data)', color: 'var(--ink-1)', flex: 1 }}>stephen/commitea</span>
-              <Row style={{ font: 'var(--text-caption)', color: 'var(--ink-3)', gap: 6 }}>
+              <Badge tone="ok" dot>syncing</Badge>
-                <Icon name="link" size={12} />{connection.baseUrl}
+              <IconButton icon="x" label="Stop managing" size="sm" />
-              </Row>
-              <Row style={{ font: 'var(--text-caption)', color: 'var(--ink-3)', gap: 6 }}>
-                <Icon name="layers" size={12} />sidecar: {connection.pmStateRepo ?? `${connection.repo}-pm-state`}
-              </Row>
-              <Row style={{ font: 'var(--text-caption)', color: 'var(--ink-3)', gap: 6 }}>
-                <Icon name="sparkles" size={12} />model: {connection.modelUrl ?? 'not set — chat off'}
-              </Row>
-              <Note>Your token is stored encrypted on this machine. Delete the sidecar and resync — no truth is lost.</Note>
-              <Row style={{ gap: 8, marginTop: 2 }}>
-                <Button variant="secondary" size="sm" icon="settings-2" onClick={onReconnect}>Reconfigure</Button>
-                <Button variant="ghost" size="sm" onClick={onDisconnect}>Disconnect</Button>
-              </Row>
-            </>
-          ) : (
-            <Row style={{ gap: 8 }}>
-              <Note>Not connected.</Note>
-              <Button variant="secondary" size="sm" onClick={onReconnect}>Connect</Button>
             </Row>
-          )}
+            <Row style={{ padding: '8px 12px', background: 'var(--paper-0)', border: '1px solid var(--line-1)', borderRadius: 'var(--radius-2)' }}>
+              <Icon name="layers" size={14} style={{ color: 'var(--ink-3)' }} />
+              <span style={{ font: 'var(--text-data)', color: 'var(--ink-1)', flex: 1 }}>stephen/pm-state</span>
+              <Badge>sidecar</Badge>
+            </Row>
+            <Note>The sidecar holds machine-derived state only. Delete it and resync — no truth is lost.</Note>
+            <Button variant="secondary" size="sm" icon="plus" style={{ alignSelf: 'flex-start' }}>Add repo</Button>
+          </div>
         </div>
       </Card>
 

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

@@ -1,6 +1,6 @@
 import React from 'react'
 
-import { type IssueRef, STANDUP, type StandupData } from '../../data/fixtures.js'
+import { type IssueRef, STANDUP } from '../../data/fixtures.js'
 import { Badge, Button, Icon } from '../ui/index.js'
 
 const standupCSS = `
@@ -36,15 +36,15 @@ const toneColor: Record<string, string> = {
 export function StandupScreen({
   onBegin,
   onOpenIssue,
-  data,
 }: {
   onBegin: () => void
   onOpenIssue: (issue: IssueRef) => void
-  data?: StandupData
 }) {
-  const s = data ?? STANDUP
+  const s = STANDUP
   const NAG_REF: IssueRef = {
     id: s.nag.id,
+    title: 'Fix lifecycle inference on merge events',
+    labels: ['est/2d', 'p/1'],
     days: s.nag.days,
   }
 

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

@@ -3,9 +3,7 @@ import React, { useEffect, useState } from 'react'
 import logoIcon from '../../design/assets/logo-icon.png'
 import type { IssueChange } from '@commitea/core'
 
-import type { PublicConfig } from '../../global.js'
 import type { IssueRef } from '../../data/fixtures.js'
-import { ConnectScreen } from '../screens/connect-screen.js'
 import {
   backlogCalibration,
   capacityWorkers,
@@ -17,12 +15,6 @@ import {
 } from '../../lib/backlog.js'
 import { useBacklog } from '../../lib/use-backlog.js'
 import { useCapacity } from '../../lib/use-capacity.js'
-import { depsGraphView } from '../../lib/views/deps-graph.js'
-import { ganttView } from '../../lib/views/gantt-view.js'
-import { inboxView } from '../../lib/views/inbox-view.js'
-import { issueDetailView } from '../../lib/views/issue-detail.js'
-import type { ProjectData } from '../../lib/views/project-data.js'
-import { standupView } from '../../lib/views/standup-view.js'
 import { PrimitivesGallery } from '../gallery.js'
 import { BoardScreen } from '../screens/board-screen.js'
 import { CalibrationScreen } from '../screens/calibration-screen.js'
@@ -105,10 +97,6 @@ export function AppShell() {
   const [issue, setIssue] = useState<IssueRef | null>(null)
   const [readIds, setReadIds] = useState<number[]>([])
   const [milestoneId, setMilestoneId] = useState<number | null>(null)
-  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)
@@ -140,78 +128,13 @@ export function AppShell() {
         ) ?? undefined)
       : undefined
 
-  // The uniform input every real-data view builder consumes. Assembled once from
-  // the reconciled backlog + capacity; undefined until the first reconcile lands.
-  const projectData: ProjectData | undefined =
-    backlog.status === 'ready'
-      ? {
-          issues: backlog.issues,
-          milestones: backlog.milestones,
-          deps: backlog.deps,
-          timelines: backlog.timelines,
-          calibration: calibration?.model,
-          workers,
-          today: new Date(),
-        }
-      : undefined
-  const issueDetail =
-    projectData && issue ? (issueDetailView(issue.id, projectData) ?? undefined) : undefined
-  const standup = projectData ? standupView(projectData) : undefined
-  const inbox = projectData ? inboxView(projectData) : undefined
-  const gantt = projectData ? ganttView(projectData) : undefined
-  const depsGraph = projectData ? depsGraphView(projectData) : undefined
-  // The rail's unread badge tracks the real inbox once reconciled (still-unread
-  // minus what's been opened); demo shows the fixture count.
-  const inboxUnread = inbox
-    ? inbox.filter((n) => n.unread && !readIds.includes(n.id)).length
-    : INBOX_UNREAD
-
-  // The real connected host (from the saved config), for the rail's status line.
-  const hostLabel = (() => {
-    try {
-      return pubConfig?.baseUrl ? new URL(pubConfig.baseUrl).host : 'gitea'
-    } catch {
-      return pubConfig?.baseUrl ?? 'gitea'
-    }
-  })()
-
   useEffect(() => {
     document.documentElement.setAttribute('data-theme', dark ? 'dark' : 'light')
   }, [dark])
 
-  // Gate: e2e/demo → the shell (fixtures); configured → the shell (real data);
-  // otherwise → the connect screen (each teammate brings their own token).
-  useEffect(() => {
-    window.commitea.gitea
-      .status()
-      .then((s) => {
-        setDemo(s.demo)
-        setGate(s.demo || s.configured ? 'ready' : 'connect')
-      })
-      .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.
+    setIssue(ref)
-    // Backfill the real title + labels from the reconciled backlog so the header
-    // isn't blank; fall back to whatever the caller passed (demo fixtures).
-    let full = ref
-    if (backlog.status === 'ready' && (!ref.title || !ref.labels)) {
-      const found = backlog.issues.find((i) => i.number === ref.id)
-      if (found) full = { ...ref, id: found.number, title: found.title, labels: found.labels }
-    }
-    setIssue(full)
     setView('issue')
   }
 
@@ -229,7 +152,7 @@ export function AppShell() {
   const NAV: NavEntry[] = [
     { id: 'standup', label: 'Standup', icon: 'sun' },
     { id: 'focus', label: 'Morning service', icon: 'coffee' },
-    { id: 'inbox', label: 'Inbox', icon: 'bell', count: inboxUnread || null },
+    { id: 'inbox', label: 'Inbox', icon: 'bell', count: INBOX_UNREAD || null },
     { id: 'capture', label: 'Capture', icon: 'plus' },
     { id: 'board', label: 'The pot', icon: 'square-kanban' },
     { id: 'runway', label: 'Runway', icon: 'chart-line' },
@@ -287,14 +210,12 @@ export function AppShell() {
       case 'focus':
         return <FocusScreen onOpenIssue={openIssue} focus={focus} forecast={forecast} />
       case 'standup':
-        return <StandupScreen onBegin={() => setView('focus')} onOpenIssue={openIssue} data={standup} />
+        return <StandupScreen onBegin={() => setView('focus')} onOpenIssue={openIssue} />
       case 'board':
         return (
           <BoardScreen
             onOpenIssue={openIssue}
             columns={boardColumns}
-            gantt={gantt}
-            deps={depsGraph}
             loading={backlog.status === 'loading'}
           />
         )
@@ -306,15 +227,7 @@ export function AppShell() {
               setMilestoneId(id ?? null)
               setView('milestone')
             }}
-            calibration={
+            calibration={calibration ? { n: calibration.model.n, coldStart: calibration.model.coldStart } : undefined}
-              calibration
-                ? {
-                    n: calibration.model.n,
-                    coldStart: calibration.model.coldStart,
-                    excludedSameDay: calibration.coverage.excludedSameDay,
-                  }
-                : undefined
-            }
             milestones={runwayMilestones}
             capacity={capacityMembers}
           />
@@ -330,7 +243,6 @@ export function AppShell() {
             onOpenDirectives={() => setView('directives')}
             readIds={readIds}
             setReadIds={setReadIds}
-            data={inbox}
           />
         )
       case 'capture':
@@ -338,33 +250,15 @@ export function AppShell() {
       case 'directives':
         return <DirectivesScreen />
       case 'settings':
-        return (
+        return <SettingsScreen dark={dark} setDark={setDark} />
-          <SettingsScreen
-            dark={dark}
-            setDark={setDark}
-            connection={pubConfig}
-            onReconnect={() => setGate('connect')}
-            onDisconnect={() => {
-              void window.commitea.config.clear().then(() => {
-                setPubConfig(null)
-                setGate('connect')
-              })
-            }}
-          />
-        )
       case 'issue':
         return issue ? (
           <IssueScreen
             issue={issue}
-            detail={issueDetail}
             onBack={() => setView(prevView)}
             onOpenIssue={openIssue}
             canWrite={backlog.status === 'ready'}
             onApplyChange={applyChange}
-            collaborators={collaborators}
-            milestones={milestoneOptions}
-            currentAssignee={currentIssue?.assignee ?? null}
-            currentMilestoneId={currentIssue?.milestone?.id ?? null}
           />
         ) : null
       case 'states':
@@ -376,23 +270,6 @@ export function AppShell() {
     }
   }
 
-  // Connection gate (real onboarding) comes before everything else.
-  if (gate === 'checking') {
-    return <div style={{ height: '100vh', background: 'var(--surface-app)' }} />
-  }
-  if (gate === 'connect') {
-    return (
-      <ConnectScreen
-        existing={pubConfig}
-        onConnected={() => {
-          window.commitea.config.get().then(setPubConfig).catch(() => {})
-          setGate('ready')
-          refetchBacklog()
-        }}
-      />
-    )
-  }
-
   // First run is full-window — no rail, no chat panel
   if (view === 'firstrun') {
     return <OnboardingScreen onDone={(dest) => setView(dest)} />
@@ -435,15 +312,9 @@ export function AppShell() {
 
         <div style={{ borderTop: '1px solid var(--line-1)', margin: '10px 8px' }} />
         <NavItem item={{ id: 'settings', label: 'Settings', icon: 'settings-2' }} />
-        {/* Dev-only surfaces (fixture galleries / onboarding preview) — shown in dev
+        <NavItem item={{ id: 'firstrun', label: 'First run', icon: 'play' }} />
-            and in demo/e2e mode; hidden in a real configured, packaged app. */}
+        <NavItem item={{ id: 'states', label: 'States', icon: 'circle-dashed' }} />
-        {import.meta.env.DEV || demo ? (
+        <NavItem item={{ id: 'primitives', label: 'Primitives', icon: 'layers' }} />
-          <>
-            <NavItem item={{ id: 'firstrun', label: 'First run', icon: 'play' }} />
-            <NavItem item={{ id: 'states', label: 'States', icon: 'circle-dashed' }} />
-            <NavItem item={{ id: 'primitives', label: 'Primitives', icon: 'layers' }} />
-          </>
-        ) : null}
 
         <div style={{ marginTop: 'auto', padding: '0 12px', display: 'flex', flexDirection: 'column', gap: 12 }}>
           <button
@@ -473,7 +344,7 @@ export function AppShell() {
                 display: 'inline-block',
               }}
             />
-            {hostLabel}
+            gitea.stephenmann.io
           </button>
           <Switch
             label={<span style={{ font: 'var(--text-caption)' }}>Evening service</span>}

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

@@ -1,6 +1,6 @@
 import React, { useEffect, useRef, useState } from 'react'
 
-import type { IssueChange } from '@commitea/core'
+import { describeChange, type IssueChange } from '@commitea/core'
 
 import { useChat } from '../../lib/use-chat.js'
 import { Button, Icon, IconButton } from '../ui/index.js'
@@ -62,7 +62,7 @@ export function ChatPanel({ onOpenDirectives, offline, onApplyChange }: ChatPane
         <Icon name="sparkles" size={16} style={{ color: offline ? 'var(--ink-3)' : 'var(--jade)' }} />
         <span style={{ font: 'var(--text-body-strong)', color: 'var(--ink-1)' }}>Reginald</span>
         <span style={{ font: '400 11px var(--font-mono)', color: 'var(--ink-3)', marginLeft: 'auto' }}>
-          {offline ? 'offline · queueing' : live ? `${modelLabel} · local` : 'no model'}
+          {offline ? 'offline · queueing' : live ? `${modelLabel} · local` : 'demo · scripted'}
         </span>
         <IconButton icon="history" label="Directive log" size="sm" onClick={onOpenDirectives} />
       </header>
@@ -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)' }}>{p.summary}</div>
+            <div style={{ font: '500 13px var(--font-mono)', color: 'var(--ink-1)' }}>{describeChange(p.plan)}</div>
             <div style={{ display: 'flex', gap: 8 }}>
               <Button size="sm" onClick={() => approve(p)} disabled={offline}>
                 Approve
@@ -161,8 +161,8 @@ export function ChatPanel({ onOpenDirectives, offline, onApplyChange }: ChatPane
                 send()
               }
             }}
-            placeholder={offline ? 'Writes wait for the connection…' : live ? 'Tell me what to do…' : 'Add a Model URL in Settings…'}
+            placeholder={offline ? 'Writes wait for the connection…' : 'Tell me what to do…'}
-            disabled={offline || !live}
+            disabled={offline}
             rows={1}
             style={{
               flex: 1,
@@ -180,15 +180,15 @@ export function ChatPanel({ onOpenDirectives, offline, onApplyChange }: ChatPane
             type="button"
             onClick={send}
             aria-label="Send"
-            disabled={offline || !live}
+            disabled={offline}
             style={{
               width: 30,
               height: 30,
               borderRadius: 'var(--radius-2)',
               border: 'none',
-              cursor: offline || !live ? 'not-allowed' : 'pointer',
+              cursor: offline ? 'not-allowed' : 'pointer',
-              background: offline || !live ? 'var(--paper-3)' : 'var(--accent)',
+              background: offline ? 'var(--paper-3)' : 'var(--accent)',
-              color: offline || !live ? 'var(--ink-3)' : 'var(--ink-inverse)',
+              color: offline ? 'var(--ink-3)' : 'var(--ink-inverse)',
               display: 'inline-flex',
               alignItems: 'center',
               justifyContent: 'center',

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

@@ -361,14 +361,11 @@ 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,8 +17,7 @@ import type {
 /** The result of a write through the bridge. */
 export type ApplyChangeResult =
   | { ok: false; reason: 'unconfigured' }
-  // `plan` is present for label swaps (est/p); absent for field writes (assign, milestone).
+  | { ok: true; plan: LabelPlan; issue: GiteaIssue }
-  | { ok: true; plan?: LabelPlan; issue: GiteaIssue }
 
 /** The result of filing captured issues. */
 export type CreateIssuesResult =
@@ -50,43 +49,14 @@ export type BootPayload =
   | { configured: true; cached: false }
   | ({ configured: true; cached: true } & Omit<SnapshotPayload, 'configured'>)
 
-/** The saved connection config (never includes the token). */
-export interface PublicConfig {
-  baseUrl: string
-  owner: string
-  repo: string
-  pmStateRepo?: string
-  modelUrl?: string
-  hasToken: boolean
-}
-
-/** What the onboarding/settings form submits. */
-export interface ConfigInput {
-  baseUrl: string
-  owner: string
-  repo: string
-  token: string
-  pmStateRepo?: string
-  modelUrl?: string
-}
-
-/** The config bridge for team onboarding. */
-export interface ConfigBridge {
-  get(): Promise<PublicConfig | null>
-  test(cfg: ConfigInput): Promise<{ ok: boolean; error?: string }>
-  set(cfg: ConfigInput): Promise<{ ok: boolean }>
-  clear(): Promise<{ ok: boolean }>
-}
-
 /** The gitea bridge exposed by the preload over IPC (main-process backed). */
 export interface GiteaBridge {
-  status(): Promise<{ configured: boolean; repo: string | null; demo: boolean }>
+  status(): Promise<{ configured: boolean; repo: string | null }>
   boot(): Promise<BootPayload>
   reconcile(): Promise<SnapshotPayload>
   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. */
@@ -126,7 +96,6 @@ declare global {
       gitea: GiteaBridge
       model: ModelBridge
       pmstate: PmStateBridge
-      config: ConfigBridge
     }
   }
 }

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

@@ -1,8 +1,6 @@
 import {
-  type CalibrationCoverage,
   type CalibrationModel,
   type CalibrationSample,
-  calibrationCoverage,
   calibrationSamples,
   type CapacityMember,
   capacityPerWorkday,
@@ -173,11 +171,10 @@ export function backlogCalibration(
   issues: GiteaIssue[],
   timelines: Timelines = {},
   asOf: Date = new Date(),
-): { model: CalibrationModel; data: CalibrationData; coverage: CalibrationCoverage } {
+): { model: CalibrationModel; data: CalibrationData } {
   const samples = calibrationSamples(issues, timelines, asOf)
   const model = fitCalibration(samples)
-  const coverage = calibrationCoverage(issues, timelines, asOf)
+  return { model, data: calibrationData(model, samples, issues) }
-  return { model, coverage, data: calibrationData(model, samples, issues, coverage.excludedSameDay) }
 }
 
 const pctFromMu = (mu: number) => Math.round((Math.exp(mu) - 1) * 100)
@@ -191,7 +188,6 @@ 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)
@@ -231,7 +227,6 @@ 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

@@ -2,18 +2,13 @@ import { useCallback, useEffect, useRef, useState } from 'react'
 
 import type { ChangeProposal, ChatMessage as WireMessage, IssueChange } from '@commitea/core'
 
-import { CHAT, type ChatMessage } from '../data/fixtures.js'
+import { CANNED_REPLY, CHAT, type ChatMessage } from '../data/fixtures.js'
 
 const LIVE_GREETING: ChatMessage = {
   from: 'agent',
   text: 'Morning. Ask me anything about the project — I check the real board before I answer.',
 }
 
-const NO_MODEL: ChatMessage = {
-  from: 'agent',
-  text: "Reginald is off — I need a model. Add a Model URL in Settings and chat turns on.",
-}
-
 export interface ChatState {
   msgs: ChatMessage[]
   thinking: boolean
@@ -60,14 +55,10 @@ export function useChat(onApplyChange?: (change: IssueChange) => Promise<{ ok: b
     window.commitea.model
       .status()
       .then((s) => {
-        if (!alive) return
+        if (alive && s.configured) {
-        if (s.configured) {
           setLive(true)
           setModel(s.model)
           setSeed([LIVE_GREETING])
-        } else {
-          // no model → clean "off" state, not a scripted fixture reply
-          setSeed([NO_MODEL])
         }
       })
       .catch(() => {})
@@ -87,8 +78,10 @@ export function useChat(onApplyChange?: (change: IssueChange) => Promise<{ ok: b
       setProposals([])
 
       if (!live) {
-        // no model configured — nothing to send (composer is disabled anyway)
+        window.setTimeout(() => {
-        setThinking(false)
+          setThinking(false)
+          setConvo((c) => [...c, { from: 'agent', text: CANNED_REPLY }])
+        }, 900)
         return
       }
 
@@ -133,13 +126,14 @@ 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}: ${p.summary}. The plan's been re-run.`
+              ? `Done — #${p.change.issue} is now ${label}. The plan's been re-run.`
               : `That didn't take — #${p.change.issue} is unchanged.`,
           },
         ])

apps/desktop/src/renderer/src/lib/views/deps-graph.ts

@@ -1,195 +0,0 @@
-import { inferLifecycle, schedule } from '@commitea/core'
-
-import type { DepEdge, DepNode, DepsData } from '../../data/fixtures.js'
-import { formatShort } from '../dates.js'
-import type { ProjectData } from './project-data.js'
-
-/** Copy of backlog.ts's private toSchedulable — open issues → scheduler input. Not exported there. */
-function toSchedulable(issues: ProjectData['issues']) {
-  return issues
-    .filter((i) => i.state === 'open')
-    .map((i) => ({
-      number: i.number,
-      title: i.title,
-      labels: i.labels,
-      estimateDays: i.facts.estimateDays,
-      priority: i.facts.priority,
-      assignee: i.assignee,
-    }))
-}
-
-function median(values: number[]): number {
-  if (values.length === 0) return 0
-  const sorted = [...values].sort((a, b) => a - b)
-  const mid = Math.floor(sorted.length / 2)
-  return sorted.length % 2 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2
-}
-
-/**
- * Real Deps-graph view: dependency topology of every issue that appears in a
- * real gitea dependency edge, laid out into columns (longest dependency depth)
- * and rows (index within its column, ordered by issue number). Critical path
- * comes from the deterministic scheduler over the open backlog — closed issues
- * never schedule, so they can't be critical, which is honest (they're done).
- * The milestone node is the open milestone with the most open in-scope issues;
- * when nothing links to a real milestone we fall back to the first open one,
- * then to a bare '—' placeholder — never a fabricated name/date.
- */
-export function depsGraphView(d: ProjectData): DepsData {
-  const byNumber = new Map(d.issues.map((i) => [i.number, i]))
-
-  // Participating set: anything that shows up as either end of a real edge,
-  // restricted to issues we actually have (dangling refs to unknown issues
-  // are dropped — nothing honest to draw for them).
-  const participating = new Set<number>()
-  for (const e of d.deps) {
-    if (byNumber.has(e.issue)) participating.add(e.issue)
-    if (byNumber.has(e.dependsOn)) participating.add(e.dependsOn)
-  }
-
-  if (participating.size === 0) {
-    const fallback = d.milestones.find((m) => m.state === 'open')
-    return {
-      nodes: [],
-      milestone: fallback
-        ? { name: fallback.title, due: fallback.dueOn ? formatShort(new Date(fallback.dueOn)) : 'no date', col: 0, row: 0 }
-        : { name: '—', due: 'no date', col: 0, row: 0 },
-      edges: [],
-      critical: [],
-      unattached: [],
-    }
-  }
-
-  // In-scope deps: both endpoints participating.
-  const depsMap = new Map<number, number[]>() // issue -> its dependencies
-  const dependentsMap = new Map<number, number[]>() // issue -> who depends on it
-  for (const id of participating) {
-    depsMap.set(id, [])
-    dependentsMap.set(id, [])
-  }
-  for (const e of d.deps) {
-    if (participating.has(e.issue) && participating.has(e.dependsOn)) {
-      depsMap.get(e.issue)!.push(e.dependsOn)
-      dependentsMap.get(e.dependsOn)!.push(e.issue)
-    }
-  }
-
-  // Column = longest dependency depth. Cycle-guarded (shouldn't happen — real
-  // gitea deps are DAG-shaped in practice — but recursion must not hang).
-  const colMemo = new Map<number, number>()
-  function colOf(id: number, visiting: Set<number>): number {
-    const cached = colMemo.get(id)
-    if (cached != null) return cached
-    if (visiting.has(id)) return 0 // cycle guard: treat as a root
-    visiting.add(id)
-    const deps = depsMap.get(id) ?? []
-    const col = deps.length === 0 ? 0 : 1 + Math.max(...deps.map((dep) => colOf(dep, visiting)))
-    visiting.delete(id)
-    colMemo.set(id, col)
-    return col
-  }
-  for (const id of participating) colOf(id, new Set())
-
-  // Row = index within column, ordered deterministically by issue number.
-  const byCol = new Map<number, number[]>()
-  for (const id of participating) {
-    const col = colMemo.get(id)!
-    if (!byCol.has(col)) byCol.set(col, [])
-    byCol.get(col)!.push(id)
-  }
-  const rowOf = new Map<number, number>()
-  for (const ids of byCol.values()) {
-    ids.sort((a, b) => a - b)
-    ids.forEach((id, i) => rowOf.set(id, i))
-  }
-
-  const maxCol = Math.max(...[...colMemo.values()])
-
-  // Critical path from the real scheduler over the open backlog.
-  const plan = schedule(toSchedulable(d.issues), d.deps)
-  const critical = new Set(plan.items.filter((i) => i.critical).map((i) => i.number))
-  const scheduledByNumber = new Map(plan.items.map((i) => [i.number, i]))
-
-  const nodes: DepNode[] = [...participating].sort((a, b) => a - b).map((id) => {
-    const issue = byNumber.get(id)!
-    const inf = inferLifecycle(issue, d.timelines[id] ?? [], d.today)
-    const scheduled = scheduledByNumber.get(id)
-    return {
-      id,
-      title: issue.title,
-      tags: issue.labels,
-      state: inf.column,
-      days: inf.steepingDays != null ? `${inf.steepingDays}d` : undefined,
-      col: colMemo.get(id)!,
-      row: rowOf.get(id)!,
-      // Reuse the scheduler's own rationale where one exists (open issues
-      // only) — never invented commentary for closed/unscheduled nodes.
-      rationale: scheduled?.rationale,
-    }
-  })
-
-  // Nearest open milestone with the most open in-scope issues.
-  const openMilestones = d.milestones.filter((m) => m.state === 'open')
-  let chosenMilestoneId: number | null = null
-  let milestone: DepsData['milestone']
-  const medianRow = median(nodes.map((n) => n.row))
-  if (openMilestones.length === 0) {
-    milestone = { name: '—', due: 'no date', col: maxCol + 1, row: medianRow }
-  } else {
-    let best: { id: number; title: string; dueOn: string | null | undefined; count: number } | null = null
-    for (const m of openMilestones) {
-      const count = [...participating].filter((id) => {
-        const issue = byNumber.get(id)!
-        return issue.milestone?.id === m.id && issue.state === 'open'
-      }).length
-      if (
-        best === null ||
-        count > best.count ||
-        (count === best.count && dueRank(m.dueOn) < dueRank(best.dueOn))
-      ) {
-        best = { id: m.id, title: m.title, dueOn: m.dueOn, count }
-      }
-    }
-    // best is non-null since openMilestones.length > 0
-    chosenMilestoneId = best!.count > 0 ? best!.id : null
-    milestone = {
-      name: best!.title,
-      due: best!.dueOn ? formatShort(new Date(best!.dueOn)) : 'no date',
-      col: maxCol + 1,
-      row: medianRow,
-    }
-  }
-
-  const edges: DepEdge[] = []
-  for (const e of d.deps) {
-    if (!participating.has(e.issue) || !participating.has(e.dependsOn)) continue
-    const crit = critical.has(e.dependsOn) && critical.has(e.issue)
-    edges.push(crit ? { from: e.dependsOn, to: e.issue, crit: true } : { from: e.dependsOn, to: e.issue })
-  }
-
-  // Terminal nodes (nothing in scope depends on them) that belong to the
-  // chosen milestone's scope get an edge into it.
-  if (chosenMilestoneId != null) {
-    for (const id of participating) {
-      const dependents = dependentsMap.get(id) ?? []
-      if (dependents.length > 0) continue
-      const issue = byNumber.get(id)!
-      if (issue.milestone?.id !== chosenMilestoneId) continue
-      edges.push(critical.has(id) ? { from: id, to: 'ms', crit: true } : { from: id, to: 'ms' })
-    }
-  }
-
-  const linked = new Set<number>()
-  for (const e of edges) {
-    linked.add(e.from)
-    if (e.to !== 'ms') linked.add(e.to)
-  }
-  const unattached = [...participating].filter((id) => !linked.has(id)).sort((a, b) => a - b)
-
-  return { nodes, milestone, edges, critical: [...critical], unattached }
-}
-
-/** Rank a due date for "nearest" comparisons; undated milestones sort last. */
-function dueRank(dueOn: string | null | undefined): number {
-  return dueOn ? new Date(dueOn).getTime() : Number.POSITIVE_INFINITY
-}

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

@@ -1,130 +0,0 @@
-import { forecast, inferLifecycle, scheduleWithCapacity, workingDaysBetween } from '@commitea/core'
-
-import type { GanttData, GanttRow, GanttWeek } from '../../data/fixtures.js'
-import { addWorkingDays, formatShort } from '../dates.js'
-import type { ProjectData } from './project-data.js'
-
-/** Same 2-char scheme as backlog.ts's `initials()`; copied inline (not exported there). */
-function initials(login: string): string {
-  return login.slice(0, 2).toUpperCase()
-}
-
-/** Copy of backlog.ts's private `toSchedulable` — not exported, so mirrored here. */
-function toSchedulable(issues: ProjectData['issues']) {
-  return issues
-    .filter((i) => i.state === 'open')
-    .map((i) => ({
-      number: i.number,
-      title: i.title,
-      labels: i.labels,
-      estimateDays: i.facts.estimateDays,
-      priority: i.facts.priority,
-      assignee: i.assignee,
-    }))
-}
-
-const roundUpToWeek = (n: number): number => Math.ceil(Math.max(n, 1) / 7) * 7
-
-/**
- * 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 = 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) => {
-    const issue = issueByNumber.get(item.number)
-    const inf = issue ? inferLifecycle(issue, d.timelines[item.number] ?? [], d.today) : null
-    const state: GanttRow['state'] =
-      inf?.column === 'done' ? 'done' : inf?.column === 'steeping' ? 'steeping' : inf?.column === 'review' ? 'review' : 'scheduled'
-    return {
-      id: item.number,
-      title: item.title,
-      // 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,
-      state,
-      // Rough single-issue buffer (no Monte Carlo at this grain): pad the end
-      // by half its own duration as a stand-in p80.
-      p80: Math.ceil(item.endDay + (item.endDay - item.startDay) * 0.5),
-    }
-  })
-
-  // Recently-closed issues (closed within ~14 calendar days) as already-done bars.
-  const doneRows: GanttRow[] = d.issues
-    .filter((i) => {
-      if (i.state !== 'closed' || !i.closedAt) return false
-      const ageDays = (d.today.getTime() - new Date(i.closedAt).getTime()) / (24 * 60 * 60 * 1000)
-      return ageDays >= 0 && ageDays <= 14
-    })
-    .map((i) => ({
-      id: i.number,
-      title: i.title,
-      who: initials(i.assignee ?? ''),
-      start: 0,
-      end: 1,
-      state: 'done' as const,
-    }))
-
-  const rows = [...doneRows, ...scheduledRows]
-
-  // Nearest open milestone with a due date, for the horizon + `due` marker.
-  const dueCandidates = d.milestones
-    .filter((m) => m.state === 'open' && m.dueOn)
-    .map((m) => ({ m, day: Math.max(0, workingDaysBetween(d.today, new Date(m.dueOn as string))) }))
-    .sort((a, b) => a.day - b.day)
-  const nearestDue = dueCandidates[0] ?? null
-
-  const days = roundUpToWeek(Math.max(7, ...rows.map((r) => r.end), nearestDue?.day ?? 0))
-
-  const weeks: GanttWeek[] = []
-  for (let at = 0; at <= days; at += 7) {
-    weeks.push({ at, label: formatShort(addWorkingDays(d.today, at)) })
-  }
-
-  const due = nearestDue
-    ? { at: nearestDue.day, label: `${nearestDue.m.title} due` }
-    : { at: days, label: 'horizon' }
-
-  // 80% window: forecast the nearest open milestone's open scope, if any has
-  // one; otherwise fall back to a generic band over the last third of the
-  // horizon (no milestone scope to anchor it to).
-  const open = d.issues.filter((i) => i.state === 'open')
-  const milestoneWithScope = d.milestones
-    .filter((m) => m.state === 'open')
-    .map((m) => ({ m, scope: open.filter((i) => i.milestone?.id === m.id) }))
-    .filter((x) => x.scope.length > 0)
-    .sort((a, b) => {
-      const da = a.m.dueOn ? workingDaysBetween(d.today, new Date(a.m.dueOn)) : Number.POSITIVE_INFINITY
-      const db = b.m.dueOn ? workingDaysBetween(d.today, new Date(b.m.dueOn)) : Number.POSITIVE_INFINITY
-      return da - db
-    })[0]
-
-  let band: GanttData['band']
-  if (milestoneWithScope) {
-    const f = forecast(toSchedulable(milestoneWithScope.scope), d.deps, { workers: d.workers })
-    const p90 = f.curve.length ? f.curve[f.curve.length - 1].p90Day : f.p95Day
-    band = { from: Math.round(f.p50Day), to: Math.round(p90), label: '80% window' }
-  } else {
-    // No milestone with open scope to anchor a real forecast to — degrade to
-    // a generic band over the last third of the horizon.
-    band = { from: Math.round((days * 2) / 3), to: days, label: '80% window' }
-  }
-
-  return {
-    days,
-    weeks,
-    today: 0,
-    band,
-    due,
-    rows,
-  }
-}

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

@@ -1,112 +0,0 @@
-import { inferLifecycle } from '@commitea/core'
-
-import type { InboxItem } from '../../data/fixtures.js'
-import type { ProjectData } from './project-data.js'
-
-const CLOSED_CAP = 5
-const TOTAL_CAP = 12
-
-/** "HH:MM" from an ISO timestamp; '—' when absent (never fabricated). */
-function hhmm(iso: string | null | undefined): string {
-  if (!iso) return '—'
-  const d = new Date(iso)
-  const hh = String(d.getHours()).padStart(2, '0')
-  const mm = String(d.getMinutes()).padStart(2, '0')
-  return `${hh}:${mm}`
-}
-
-/**
- * Real Inbox feed: steeping nags, review-waiting issues, recently-closed
- * issues, and closed milestones — all derived straight from the reconciled
- * backlog + inferred lifecycle. No mentions, no outages, no people-activity:
- * ProjectData carries none of that, so those fixture item `type`s never
- * appear here (an honest degrade, not an oversight).
- */
-export function inboxView(d: ProjectData): InboxItem[] {
-  const items: InboxItem[] = []
-  let id = 1
-
-  const open = d.issues.filter((i) => i.state === 'open')
-
-  // 1. Steeping nags — open issues that have sat past first-commit for 2+ working days.
-  for (const issue of open) {
-    const inf = inferLifecycle(issue, d.timelines[issue.number] ?? [], d.today)
-    if (inf.steepingDays == null || inf.steepingDays < 2) continue
-    const blocks = d.deps.filter((e) => e.dependsOn === issue.number).map((e) => e.issue)
-    items.push({
-      id: id++,
-      day: 'Today',
-      type: 'nag',
-      icon: 'clock',
-      tone: 'warn',
-      text: `#${issue.number} is steeping · ${inf.steepingDays}d`,
-      detail: blocks.length ? `blocks ${blocks.map((b) => `#${b}`).join(' and ')}` : 'worth a look',
-      time: hhmm(inf.stages.steeping),
-      unread: true,
-      issue: { id: issue.number, title: issue.title, labels: issue.labels, days: `${inf.steepingDays}d` },
-    })
-  }
-
-  // 2. Review-waiting — open issues whose lifecycle has reached the review column.
-  for (const issue of open) {
-    const inf = inferLifecycle(issue, d.timelines[issue.number] ?? [], d.today)
-    if (inf.column !== 'review') continue
-    items.push({
-      id: id++,
-      day: 'Today',
-      type: 'review',
-      icon: 'git-pull-request',
-      tone: 'info',
-      text: `#${issue.number} awaits review`,
-      detail: issue.title,
-      time: hhmm(inf.stages.review),
-      unread: true,
-      issue: { id: issue.number, title: issue.title, labels: issue.labels },
-    })
-  }
-
-  // 3. Recently shipped — closed issues, newest close first, capped.
-  const closed = d.issues
-    .filter((i) => i.state === 'closed')
-    .slice()
-    .sort((a, b) => {
-      const at = a.closedAt ? new Date(a.closedAt).getTime() : -Infinity
-      const bt = b.closedAt ? new Date(b.closedAt).getTime() : -Infinity
-      return bt - at
-    })
-    .slice(0, CLOSED_CAP)
-  for (const issue of closed) {
-    items.push({
-      id: id++,
-      day: 'Yesterday',
-      type: 'milestone',
-      icon: 'circle-check',
-      tone: 'ok',
-      text: `#${issue.number} shipped`,
-      detail: issue.title,
-      time: hhmm(issue.closedAt),
-      unread: false,
-      issue: { id: issue.number, title: issue.title, labels: issue.labels },
-    })
-  }
-
-  // 4. Milestone completion — milestones gitea reports as closed.
-  for (const m of d.milestones) {
-    if (m.state !== 'closed') continue
-    items.push({
-      id: id++,
-      day: 'Earlier',
-      type: 'milestone',
-      icon: 'milestone',
-      tone: 'ok',
-      // No milestone-close timestamp is available on GiteaMilestone, so time is
-      // left at the honest placeholder rather than borrowed from an issue.
-      text: `${m.title} closed`,
-      detail: 'milestone complete',
-      time: '—',
-      unread: false,
-    })
-  }
-
-  return items.slice(0, TOTAL_CAP)
-}

apps/desktop/src/renderer/src/lib/views/issue-detail.ts

@@ -1,72 +0,0 @@
-import {
-  forecast,
-  inferLifecycle,
-  type LifecycleStages,
-  toDurationModel,
-} from '@commitea/core'
-
-import type { IssueDetail } from '../../data/fixtures.js'
-import { addWorkingDays, formatRange, formatShort } from '../dates.js'
-import type { ProjectData } from './project-data.js'
-
-const MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
-
-/** "Feb 6 · 11:47" from an ISO timestamp; "pending" when absent. */
-function when(iso: string | undefined): string {
-  if (!iso) return 'pending'
-  const d = new Date(iso)
-  const hh = String(d.getHours()).padStart(2, '0')
-  const mm = String(d.getMinutes()).padStart(2, '0')
-  return `${MONTHS[d.getMonth()]} ${d.getDate()} · ${hh}:${mm}`
-}
-
-function lifecycle(stages: LifecycleStages): IssueDetail['lifecycle'] {
-  return [
-    { stage: 'Diagnosis', event: 'issue opened', when: when(stages.opened), icon: 'circle-dot', done: true },
-    { stage: 'Triage', event: 'labeled / milestoned', when: when(stages.triaged), icon: 'tag', done: !!stages.triaged },
-    { stage: 'Work start', event: 'first commit ref', when: when(stages.steeping), icon: 'git-commit-horizontal', done: !!stages.steeping },
-    { stage: 'In review', event: 'PR referenced', when: when(stages.review), icon: 'git-merge', done: !!stages.review },
-    { stage: 'Complete', event: 'issue closed', when: when(stages.done), icon: 'circle-check', done: !!stages.done },
-  ]
-}
-
-/**
- * Real Issue-detail sidecar: lifecycle timeline (from event inference), a
- * single-issue forecast range, and the real dependency edges. Returns null for
- * an unknown id → the screen shows the demo fixture. Comments aren't reconciled,
- * so they stay empty (the screen degrades gracefully).
- */
-export function issueDetailView(id: number, d: ProjectData): IssueDetail | null {
-  const issue = d.issues.find((i) => i.number === id)
-  if (!issue) return null
-  const inf = inferLifecycle(issue, d.timelines[id] ?? [], d.today)
-  const blockedBy = d.deps.filter((e) => e.issue === id).map((e) => e.dependsOn)
-  const blocks = d.deps.filter((e) => e.dependsOn === id).map((e) => e.issue)
-
-  let forecastLine = { p80: 'closed', note: 'shipped' }
-  if (issue.state === 'open') {
-    const f = forecast(
-      [{ number: id, title: issue.title, labels: issue.labels, estimateDays: issue.facts.estimateDays, priority: issue.facts.priority, assignee: issue.assignee }],
-      [],
-      { ...(d.calibration ? { model: toDurationModel(d.calibration) } : {}), workers: d.workers },
-    )
-    const p90 = f.curve.length ? f.curve[f.curve.length - 1].p90Day : f.p95Day
-    forecastLine = {
-      p80: `done ${formatRange(addWorkingDays(d.today, f.p50Day), addWorkingDays(d.today, p90))}`,
-      note: d.calibration && !d.calibration.coldStart ? `from your history · n=${d.calibration.n}` : 'cold-start priors',
-    }
-  }
-
-  return {
-    state: inf.column === 'review' ? 'review' : inf.column,
-    assignee: issue.assignee ?? 'unassigned',
-    milestone: issue.milestone?.title ?? '—',
-    body: issue.body,
-    comments: [],
-    lifecycle: lifecycle(inf.stages),
-    forecast: forecastLine,
-    blocks,
-    blockedBy,
-    note: inf.steepingDays != null ? `Steeping ${inf.steepingDays}d.${blocks.length ? ` Blocks ${blocks.map((b) => `#${b}`).join(', ')}.` : ''}` : '',
-  }
-}

apps/desktop/src/renderer/src/lib/views/project-data.ts

@@ -1,17 +0,0 @@
-import type { CalibrationModel, DependencyEdge, GiteaIssue, GiteaMilestone, LifecycleEvent, Worker } from '@commitea/core'
-
-/**
- * The reconciled backlog + derived config that every real-data view builder
- * consumes. AppShell assembles it once from the backlog + capacity, so each
- * screen's builder gets a uniform input. `calibration`/`workers` are optional —
- * views degrade to cold-start / single-worker when absent.
- */
-export interface ProjectData {
-  issues: GiteaIssue[]
-  milestones: GiteaMilestone[]
-  deps: DependencyEdge[]
-  timelines: Record<number, LifecycleEvent[]>
-  calibration?: CalibrationModel
-  workers: Worker[]
-  today: Date
-}

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

@@ -1,157 +0,0 @@
-import {
-  type DependencyEdge,
-  type GiteaIssue,
-  inferLifecycle,
-  schedule,
-  type ScheduledItem,
-} from '@commitea/core'
-
-import type { DriftItem, Nag, PlanItem, StandupData } from '../../data/fixtures.js'
-import type { ProjectData } from './project-data.js'
-
-/** Same shape as backlog.ts's private toSchedulable — not exported there, so copied inline. */
-function toSchedulable(issues: GiteaIssue[]) {
-  return issues
-    .filter((i) => i.state === 'open')
-    .map((i) => ({
-      number: i.number,
-      title: i.title,
-      labels: i.labels,
-      estimateDays: i.facts.estimateDays,
-      priority: i.facts.priority,
-      assignee: i.assignee,
-    }))
-}
-
-function whyFor(item: ScheduledItem): string {
-  if (item.critical) return 'On the critical path.'
-  if (item.blocks.length) return `Blocks ${item.blocks.map((b) => `#${b}`).join(', ')}.`
-  return 'Next by dependency + priority order.'
-}
-
-/**
- * Top scheduled pick per distinct assignee. Iterates the (already dependency-
- * + priority-ordered) plan once, keeping the first item seen per assignee —
- * that's their earliest-starting pick since the v0 scheduler lays out a single
- * serial lane (order ascending ⇒ startDay ascending). Ordered by `d.workers`
- * when present (assignees absent from the roster are appended after the named
- * workers; unassigned work last), else by discovery order. Capped at 4 people.
- */
-function buildPlan(d: ProjectData, open: GiteaIssue[], items: ScheduledItem[]): PlanItem[] {
-  const assigneeByNumber = new Map(open.map((i) => [i.number, i.assignee]))
-  const firstPickByPerson = new Map<string, ScheduledItem>()
-  for (const item of items) {
-    const key = assigneeByNumber.get(item.number) ?? 'Unassigned'
-    if (!firstPickByPerson.has(key)) firstPickByPerson.set(key, item)
-  }
-
-  let order: string[]
-  if (d.workers.length) {
-    const workerOrder = d.workers.map((w) => w.person)
-    const known = workerOrder.filter((p) => firstPickByPerson.has(p))
-    const extra = [...firstPickByPerson.keys()].filter((k) => k !== 'Unassigned' && !workerOrder.includes(k))
-    order = [...known, ...extra]
-    if (firstPickByPerson.has('Unassigned')) order.push('Unassigned')
-  } else {
-    order = [...firstPickByPerson.keys()]
-  }
-
-  return order.slice(0, 4).map((who) => {
-    const item = firstPickByPerson.get(who)!
-    return { who, pick: `#${item.number}`, title: item.title, why: whyFor(item) }
-  })
-}
-
-/**
- * The single longest-steeping open issue (inferLifecycle's steepingDays, whole
- * working days since first commit ref). `blocks` comes from the scheduler's
- * in-scope dependents of that same issue. Falls back to a calm, honest nag
- * when nothing is currently steeping.
- */
-function buildNag(d: ProjectData, open: GiteaIssue[], items: ScheduledItem[]): Nag {
-  let worst: { issue: GiteaIssue; days: number } | null = null
-  for (const issue of open) {
-    const inf = inferLifecycle(issue, d.timelines[issue.number] ?? [], d.today)
-    if (inf.steepingDays != null && (worst == null || inf.steepingDays > worst.days)) {
-      worst = { issue, days: inf.steepingDays }
-    }
-  }
-  if (!worst) {
-    return { id: 0, days: '0d', blocks: [], text: 'Nothing is over-steeping. The pot is calm.' }
-  }
-
-  const scheduled = items.find((it) => it.number === worst!.issue.number)
-  const blocks = (scheduled?.blocks ?? []).map((n) => `#${n}`)
-  const days = `${worst.days}d`
-  return {
-    id: worst.issue.number,
-    days,
-    blocks,
-    text: `${days} steeping. ${blocks.length ? `Blocks ${blocks.join(', ')}.` : 'Worth a look.'}`,
-  }
-}
-
-/**
- * Honest drift signals only — ProjectData carries no notification/webhook
- * stream, so drift is limited to what lifecycle inference can actually see:
- * open issues sitting in review (age isn't measurable from the data we have,
- * so every review-column issue is flagged rather than fabricating a duration)
- * and open issues steeping past their own estimate. Sorted most-severe first
- * (steeping overage ranks by days over estimate; review-sitting is a flat,
- * lower severity since it has no measured age) and capped at 4.
- */
-function buildDrift(d: ProjectData, open: GiteaIssue[]): DriftItem[] {
-  const candidates: (DriftItem & { severity: number })[] = []
-  for (const issue of open) {
-    const inf = inferLifecycle(issue, d.timelines[issue.number] ?? [], d.today)
-    if (inf.column === 'review') {
-      candidates.push({
-        tone: 'warn',
-        text: `#${issue.number} ${issue.title} is sitting in review.`,
-        delta: 'idle in review',
-        severity: 1,
-      })
-    }
-    if (inf.steepingDays != null) {
-      const est = issue.facts.estimateDays ?? 2
-      if (inf.steepingDays > est) {
-        candidates.push({
-          tone: 'warn',
-          text: `#${issue.number} ${issue.title} has steeped past its estimate.`,
-          delta: `${inf.steepingDays}d vs ${est}d est`,
-          severity: inf.steepingDays - est + 1,
-        })
-      }
-    }
-  }
-  return candidates
-    .sort((a, b) => b.severity - a.severity)
-    .slice(0, 4)
-    .map(({ tone, text, delta }) => ({ tone, text, delta }))
-}
-
-/**
- * Morning-standup sidecar: per-person top pick from the deterministic
- * scheduler, the single longest-steeping issue as the day's nag, and drift
- * limited to real lifecycle anomalies (review-sitting, steeping-past-estimate).
- * Never throws — an empty/cold backlog degrades to an empty plan, empty drift,
- * and a calm nag.
- */
-export function standupView(d: ProjectData): StandupData {
-  const date = d.today.toLocaleDateString('en-GB', {
-    weekday: 'long',
-    day: 'numeric',
-    month: 'long',
-    year: 'numeric',
-  })
-  const open = d.issues.filter((i) => i.state === 'open')
-  const deps: DependencyEdge[] = d.deps
-  const { items } = schedule(toSchedulable(open), deps)
-
-  return {
-    date,
-    plan: buildPlan(d, open, items),
-    nag: buildNag(d, open, items),
-    drift: buildDrift(d, open),
-  }
-}

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

@@ -17,11 +17,10 @@ export const QUERY_PROJECT_TOOL: ToolDecl = {
     properties: {
       view: {
         type: 'string',
-        enum: ['focus', 'board', 'calibration', 'issue', 'search', 'standup'],
+        enum: ['focus', 'board', 'calibration', 'issue', 'search'],
         description:
           'focus = Now/Next/Later; board = issues by lifecycle column; calibration = estimate-vs-actual; ' +
-          'issue = one issue (needs filters.issueId); search = issues matching filters.query; ' +
+          'issue = one issue (needs filters.issueId); search = issues matching filters.query.',
-          "standup = today's plan + overnight drift + the stalest blocker.",
       },
       filters: {
         type: 'object',
@@ -39,19 +38,15 @@ export const QUERY_PROJECT_TOOL: ToolDecl = {
 export const PROPOSE_CHANGE_TOOL: ToolDecl = {
   name: 'propose_change',
   description:
-    'Propose a change to an issue — estimate, priority, assignee, and/or milestone. This does NOT apply ' +
+    "Propose an estimate and/or priority change to an issue. This does NOT apply anything — it shows the " +
-    'anything; it shows the human a diff to approve. Use it whenever the user asks to re-estimate, reprioritize, ' +
+    'human a diff to approve. Use it whenever the user asks to re-estimate or reprioritize. After calling it, ' +
-    'assign someone (or unassign), or move an issue to a milestone. Pass a login for `assignee` (null to ' +
+    "tell the user you've *proposed* the change for approval — never say it is done.",
-    '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'],
   },
@@ -89,7 +84,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, priority, assignee, or milestone, call propose_change — it shows the human a diff to approve.',
+  'To change an estimate or priority, call propose_change — it shows the human a diff to approve.',
   'When the PM states standing intent ("pilots first", "freeze scope"), call record_directive to log it.',
   'Never claim a change is applied; you propose, the human approves. Forecasts are ranges, never single dates.',
   'Refer to issues as #<number>. Be brief and plain — a sentence or two. No preamble, no bullet dumps.',

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

@@ -1,71 +0,0 @@
-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

@@ -1,102 +0,0 @@
-/**
- * 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

@@ -1,74 +0,0 @@
-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).
  *
- * Serves focus / board / calibration / issue / search / standup. The remaining
+ * v0 serves focus / board / calibration / issue. The remaining views
- * views (milestone / runway) return a `notImplemented` marker so the model
+ * (milestone / runway / standup / search) return a `notImplemented` marker so
- * degrades honestly instead of inventing data.
+ * the model degrades honestly instead of inventing data.
  */
 
 import { fitCalibration, calibrationSamples } from '../calibration/calibration-v0.js'
@@ -121,62 +121,6 @@ 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,
@@ -196,8 +140,6 @@ 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

@@ -1,92 +0,0 @@
-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

@@ -1,159 +0,0 @@
-/**
- * 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,7 +5,6 @@ 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,
@@ -119,26 +118,4 @@ 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,40 +125,3 @@ 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,13 +1,6 @@
 import { describe, expect, it } from 'vitest'
 
-import {
+import { describeChange, type IssueChange, planIssueChange, proposalsFor } from './apply-changes-v0.js'
-  describeChange,
-  isLabelChange,
-  type IssueChange,
-  planIssueChange,
-  proposalsFor,
-  summarizeChange,
-} from './apply-changes-v0.js'
 
 describe('planIssueChange', () => {
   it('swaps the estimate label, keeping non-axis labels', () => {
@@ -65,31 +58,11 @@ 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(props[0].summary).toBe('est/2d → est/5d')
+    expect(describeChange(props[0].plan)).toBe('est/2d → est/5d')
     expect(props[1].change).toEqual({ kind: 'reprioritize', issue: 2, priority: 'p/1' })
     expect(props[0].issueTitle).toBe('ChangeSource')
   })
 
-  it('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
@@ -104,31 +77,3 @@ 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,15 +17,6 @@ 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). */
@@ -38,10 +29,7 @@ export interface LabelPlan {
   noop: boolean
 }
 
-/** A change that resolves to a label swap (the only kind `planIssueChange` accepts). */
+function axisFor(change: IssueChange): { labels: readonly string[]; target: string | null } {
-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 }
@@ -52,7 +40,7 @@ function axisFor(change: LabelChange): { 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: LabelChange): LabelPlan {
+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)
@@ -70,52 +58,18 @@ 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
-  /** One-line diff for the approve UI — always present ({@link summarizeChange}). */
+  plan: LabelPlan
-  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 fields to set. */
+/** What the `propose_change` tool accepts — a target issue and the axes 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 {
@@ -126,33 +80,25 @@ function isPriority(v: unknown): v is PriorityLabel {
 }
 
 /**
- * Build the concrete, non-noop proposals for a `propose_change` request. Label
+ * Build the concrete, non-noop proposals for a `propose_change` request against
- * axes (est/*, p/*) are validated and never invented; assign/milestone are
+ * an issue's current labels. Invalid or unchanged axes are dropped — the agent
- * emitted only when they differ from the issue's current value (via `ctx`). Each
+ * proposes only real changes, and never a label outside the est/* · p/* axes.
- * 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[] = []
-  const pushLabel = (change: LabelChange) => {
+  if (isEstimate(args.estimate)) {
+    const change: IssueChange = { kind: 'reestimate', issue: args.issue, estimate: args.estimate }
     const plan = planIssueChange(currentLabels, change)
-    if (!plan.noop) out.push({ change, plan, summary: describeChange(plan), issueTitle })
+    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)) {
-  if (isPriority(args.priority)) pushLabel({ kind: 'reprioritize', issue: args.issue, priority: args.priority })
+    const change: IssueChange = { kind: 'reprioritize', issue: args.issue, priority: args.priority }
-
+    const plan = planIssueChange(currentLabels, change)
-  if (args.assignee !== undefined && args.assignee !== (ctx.currentAssignee ?? null)) {
+    if (!plan.noop) out.push({ change, plan, issueTitle })
-    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,22 +146,6 @@ 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,14 +101,8 @@ 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. */
@@ -235,33 +229,6 @@ 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,17 +23,8 @@ export type {
   GiteaRequestInit,
 } from './gitea/types.js'
 
-export { CACHE_SCHEMA, initCache, readIssue, upsertIssue } from './cache/cache-v0.js'
+export { describeChange, planIssueChange, proposalsFor } from './changes/apply-changes-v0.js'
-export type { CacheDriver } from './cache/cache-v0.js'
+export type { ChangeProposal, IssueChange, LabelPlan, ProposeChangeArgs } from './changes/apply-changes-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,
@@ -82,7 +73,6 @@ export type {
 
 export {
   CALIBRATION_BUCKET_FLOOR,
-  calibrationCoverage,
   calibrationSamples,
   COLD_START_THRESHOLD,
   fitCalibration,
@@ -90,7 +80,6 @@ export {
 } from './calibration/calibration-v0.js'
 export type {
   BucketFit,
-  CalibrationCoverage,
   CalibrationModel,
   CalibrationSample,
   PersonBias,
@@ -111,8 +100,6 @@ 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'