apply_changes UI: assign + milestone in the dialog and Reginald's tool (#24)

Surfaces the assign/milestone mutations end-to-end so they're usable in-app and
by the agent — the rest of #24.

Agent path:
- propose_change tool + system prompt now accept `assignee` (login/null) and
  `milestone` (id/null). ProposeChangeArgs + proposalsFor extended: a new
  ProposalContext (current assignee/milestone + milestones list) lets a proposal
  skip no-ops and label the milestone. ChangeProposal gains an always-present
  `summary` (plan is now label-only) — chat-panel, use-chat, and the model
  executor render `summary`, so non-label proposals display correctly.

Dialog path:
- Client `listCollaborators()` (prepends the repo owner — /collaborators omits
  them, so a solo-owner repo still has an assignable person). New
  `gitea:collaborators` bridge. The Adjust dialog gains Assignee + Milestone
  pickers (current values from the reconciled backlog); pending assign/remilestone
  changes flow through the existing apply path.

Tests: +4 core (assign/milestone proposals with no-op skip; collaborators
owner-prepend + no-double-add). 138 core green; core + desktop typecheck clean;
14 fixture e2e green; live-backlog now drives the pickers on real data.
Fixed stale P2 refs in live-backlog (P2 is shipped → correctly off the runway).

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

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

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

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

@@ -0,0 +1,56 @@
+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')
+
+    // 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()
+
+    // it validated + saved + reconciled into the real board — real issue titles prove it
+    const rail = win.getByRole('navigation', { name: 'Primary' })
+    await rail.getByRole('button', { name: 'The pot' }).click()
+    await expect(win.getByText(/Model router|SQLite cache bootstrap|Purity\/rebuild/).first()).toBeVisible({ timeout: 30000 })
+    await win.screenshot({ path: join(here, '.artifacts', 'screens', 'live-onboarding.png'), fullPage: true, animations: 'disabled' })
+
+    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.getByText('Managed repos')).toBeVisible()
+  await expect(window.getByRole('heading', { name: 'Connection' })).toBeVisible()
   await app.screenshot('settings')
   // the Evening (dark) radio drives the shared theme
   await window.getByText('Evening (dark)').click()

apps/desktop/src/main/config-store.ts

@@ -0,0 +1,101 @@
+/**
+ * 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,11 +13,13 @@ 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,
@@ -28,6 +30,7 @@ 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). */
@@ -48,9 +51,15 @@ function loadEnvLocalToken(): string | undefined {
   return undefined
 }
 
-function resolveConfig(): GiteaConfig | null {
+/** Saved config wins (team build); a `.env.local` is the dev fallback; e2e uses fixtures. */
+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 {
@@ -61,8 +70,23 @@ function resolveConfig(): GiteaConfig | null {
   }
 }
 
-// Memoized client so both the gitea and model bridges share one instance.
+/** The pm-state repo name: configured, else `${repo}-pm-state`, else the env override. */
+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()
@@ -73,13 +97,10 @@ 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
+    pmStateClient = config ? createGiteaClient({ ...config, repo: pmStateRepoName(config) }, fetch) : null
-      ? createGiteaClient({ ...config, repo: process.env.COMMITEA_PMSTATE_REPO ?? 'commitea-pm-state' }, fetch)
-      : null
   }
   return pmStateClient
 }
@@ -192,20 +213,38 @@ 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
 
-export function registerGiteaIpc(): void {
+// Label cache is reset with the clients (module-level so resetClients can clear it).
-  const client = getGiteaClient()
+let labelCache: GiteaLabel[] | null = null
-  const repo = client ? `${process.env.GITEA_OWNER ?? 'christian'}/${process.env.GITEA_REPO ?? 'commitea'}` : 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)
+}
 
-  ipcMain.handle('gitea:status', () => ({ configured: !!client, repo }))
+export function registerGiteaIpc(): void {
+  ipcMain.handle('gitea:status', () => {
+    const cfg = resolveConfig()
+    return {
+      configured: !!cfg,
+      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 (!client) return { configured: false }
+    if (!getGiteaClient()) 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
@@ -220,36 +259,37 @@ export function registerGiteaIpc(): void {
   })
 
   ipcMain.handle('gitea:getIssue', async (_event, index: number) => {
+    const client = getGiteaClient()
     if (!client) return null
     return client.getIssue(index)
   })
 
-  // Cached label list for name→id resolution; refreshed on demand if a name misses.
+  // The write path (apply_changes), applied only after the renderer's propose-
-  let labelCache: GiteaLabel[] | null = null
+  // approve. Label swaps (est/p) return the plan; field writes (assign, milestone)
-  async function resolveLabelIds(names: string[]): Promise<number[]> {
+  // return the freshly-read issue directly. Either way the snapshot is invalidated
-    if (!client) return []
+  // so the board + forecast reflect the change.
-    const lookup = () => new Map(labelCache!.map((l) => [l.name, l.id]))
-    if (!labelCache) labelCache = await client.listLabels()
-    let byName = lookup()
-    if (names.some((n) => !byName.has(n))) {
-      labelCache = await client.listLabels() // a name we don't know — refetch once
-      byName = lookup()
-    }
-    return names.map((n) => byName.get(n)).filter((id): id is number => id != null)
-  }
-
-  // The write path (apply_changes). Additive label swaps, applied only after the
-  // renderer's propose-approve. Returns the plan + the freshly-read issue.
   ipcMain.handle('gitea:applyChange', async (_event, change: IssueChange) => {
+    const client = getGiteaClient()
     if (!client) return { ok: false as const, reason: 'unconfigured' as const }
-    const current = await client.getIssue(change.issue)
+
-    const plan = planIssueChange(current.labels, change)
+    if (isLabelChange(change)) {
-    if (plan.noop) return { ok: true as const, plan, issue: current }
+      const current = await client.getIssue(change.issue)
-    const ids = await resolveLabelIds(plan.labels)
+      const plan = planIssueChange(current.labels, change)
-    await client.setIssueLabels(change.issue, ids)
+      if (plan.noop) return { ok: true as const, plan, issue: current }
-    const issue = await client.getIssue(change.issue)
+      const ids = await resolveLabelIds(client, plan.labels)
-    invalidateSnapshot() // the board + forecast must reflect the label change
+      await client.setIssueLabels(change.issue, ids)
-    return { ok: true as const, plan, issue }
+      const issue = await client.getIssue(change.issue)
+      invalidateSnapshot()
+      return { ok: true as const, plan, issue }
+    }
+
+    // Field writes — the client returns the updated issue.
+    const issue =
+      change.kind === 'assign'
+        ? await client.setIssueAssignees(change.issue, change.assignee ? [change.assignee] : [])
+        : await client.setIssueMilestone(change.issue, change.milestone)
+    invalidateSnapshot()
+    return { ok: true as const, issue }
   })
 
   // capture_work filing: open each approved issue with its est/* + p/* labels.
@@ -257,11 +297,12 @@ 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(names)
+        const labelIds = await resolveLabelIds(client, names)
         const issue = await client.createIssue({ title: it.title, body: it.body, labelIds })
         created.push({ number: issue.number, title: issue.title })
       }
@@ -291,4 +332,44 @@ 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,6 +2,9 @@ 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,7 +13,6 @@ import {
   type ChangeProposal,
   type ChatMessage,
   createChatClient,
-  describeChange,
   type ModelRouter,
   type ProjectView,
   proposalsFor,
@@ -24,8 +23,9 @@ import {
   runAgentTurn,
   toDirectiveInput,
 } from '@commitea/core'
-import { ipcMain } from 'electron'
+import { app, ipcMain } from 'electron'
 
+import { loadConfig } from './config-store.js'
 import {
   AGENT_SNAPSHOT_TTL_MS,
   appendDirectiveEntry,
@@ -37,7 +37,11 @@ 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
-  const baseUrl = process.env.COMMITEA_MODEL_URL ?? 'http://localhost:1234/v1'
+  // Config wins (team build); env is the dev override; localhost is a dev convenience only.
+  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 ?? '' },
@@ -45,6 +49,19 @@ 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
@@ -78,15 +95,15 @@ async function resolveLoadedModel(baseUrl: string, override: string): Promise<st
 }
 
 export function registerModelIpc(): void {
-  const router = resolveModelRouter()
-
   ipcMain.handle('model:status', async () => {
-    if (!router) return { configured: false, model: null }
+    const r = resolveModelRouter() // resolve fresh so a saved modelUrl takes effect
-    const model = await resolveLoadedModel(router.small.baseUrl, router.small.model)
+    if (!r) return { configured: false, model: null }
-    return { configured: true, model }
+    const model = await probeModel(r.small.baseUrl) // only "configured" if a model actually answers
+    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)
@@ -112,10 +129,19 @@ export function registerModelIpc(): void {
         const a = (args ?? {}) as ProposeChangeArgs
         const issue = await client.getIssue(a.issue).catch(() => null)
         if (!issue) return { error: `issue #${a.issue} not found` }
-        const built = proposalsFor(a, issue.labels, issue.title)
+        // Milestone titles + current assignee/milestone let a proposal label the
+        // milestone and skip a no-op assign/move.
+        const milestones = (a.milestone !== undefined ? await client.listMilestones().catch(() => []) : []).map(
+          (m) => ({ id: m.id, title: m.title }),
+        )
+        const built = proposalsFor(a, issue.labels, issue.title, {
+          currentAssignee: issue.assignee,
+          currentMilestoneId: issue.milestone?.id ?? null,
+          milestones,
+        })
         proposals.push(...built)
         return built.length
-          ? { proposed: built.map((p) => ({ issue: a.issue, diff: describeChange(p.plan) })) }
+          ? { proposed: built.map((p) => ({ issue: a.issue, diff: p.summary })) }
           : { proposed: [], note: 'no change — already at that value' }
       }
       if (name === 'record_directive') {
@@ -149,6 +175,7 @@ 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,6 +15,8 @@ const api = {
     applyChange: (change: unknown) => ipcRenderer.invoke('gitea:applyChange', change),
     /** File a set of captured issues with their est/* + p/* labels. */
     createIssues: (issues: unknown) => ipcRenderer.invoke('gitea:createIssues', issues),
+    /** Assignable people (repo collaborators) for the assignee picker. */
+    collaborators: () => ipcRenderer.invoke('gitea:collaborators'),
   },
   pmstate: {
     /** Read the directive ledger from the pm-state repo. */
@@ -22,6 +24,16 @@ 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/connect-screen.tsx

@@ -0,0 +1,117 @@
+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/issue-screen.tsx

@@ -2,13 +2,12 @@
 import React, { useState } from 'react'
 
 import {
-  describeChange,
   type EstimateLabel,
   ESTIMATE_LABELS,
   type IssueChange,
-  planIssueChange,
   type PriorityLabel,
   PRIORITY_LABELS,
+  summarizeChange,
 } from '@commitea/core'
 
 import { ISSUE_DETAIL, type IssueDetail, type IssueRef } from '../../data/fixtures.js'
@@ -22,12 +21,20 @@ export function IssueScreen({
   onOpenIssue,
   canWrite = false,
   onApplyChange,
+  collaborators = [],
+  milestones = [],
+  currentAssignee = null,
+  currentMilestoneId = null,
 }: {
   issue: IssueRef
   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 = ISSUE_DETAIL[issue.id] || {
     state: 'triage',
@@ -60,25 +67,40 @@ export function IssueScreen({
   const labels = issue.labels ?? []
   const curEstimate = labels.find((l) => l.startsWith('est/')) ?? ''
   const curPriority = labels.find((l) => l.startsWith('p/')) ?? ''
+  const curAssignee = currentAssignee ?? ''
+  const curMilestone = currentMilestoneId != null ? String(currentMilestoneId) : ''
   const [adjustOpen, setAdjustOpen] = useState(false)
   const [estimate, setEstimate] = useState(curEstimate)
   const [priority, setPriority] = useState(curPriority)
+  const [assignee, setAssignee] = useState(curAssignee)
+  const [milestone, setMilestone] = useState(curMilestone)
   const [applying, setApplying] = useState(false)
 
   const openAdjust = () => {
     setEstimate(curEstimate)
     setPriority(curPriority)
+    setAssignee(curAssignee)
+    setMilestone(curMilestone)
     setAdjustOpen(true)
   }
 
-  // the concrete changes this dialog would apply, one per axis that differs
+  // the concrete changes this dialog would apply, one per field that differs
   const pendingChanges: IssueChange[] = []
   if (estimate !== curEstimate)
     pendingChanges.push({ kind: 'reestimate', issue: issue.id, estimate: (estimate || null) as EstimateLabel | null })
   if (priority !== curPriority)
     pendingChanges.push({ kind: 'reprioritize', issue: issue.id, priority: (priority || null) as PriorityLabel | null })
+  if (assignee !== curAssignee)
+    pendingChanges.push({ kind: 'assign', issue: issue.id, assignee: assignee || null })
+  if (milestone !== curMilestone)
+    pendingChanges.push({
+      kind: 'remilestone',
+      issue: issue.id,
+      milestone: milestone ? Number(milestone) : null,
+      milestoneTitle: milestones.find((m) => String(m.id) === milestone)?.title ?? null,
+    })
 
-  const diffs = pendingChanges.map((c) => describeChange(planIssueChange(labels, c)))
+  const diffs = pendingChanges.map((c) => summarizeChange(c, labels))
 
   const apply = async () => {
     if (!onApplyChange || pendingChanges.length === 0) return
@@ -93,6 +115,14 @@ export function IssueScreen({
 
   const estOptions = [{ value: '', label: NONE }, ...ESTIMATE_LABELS.map((l) => ({ value: l, label: l }))]
   const prioOptions = [{ value: '', label: NONE }, ...PRIORITY_LABELS.map((l) => ({ value: l, label: l }))]
+  const assigneeOptions = [
+    { value: '', label: 'Unassigned' },
+    ...collaborators.map((c) => ({ value: c.login, label: c.name })),
+  ]
+  const milestoneOptions = [
+    { value: '', label: NONE },
+    ...milestones.map((m) => ({ value: String(m.id), label: m.title })),
+  ]
 
   return (
     <div style={{ display: 'flex', flexDirection: 'column', gap: 16 }}>
@@ -133,7 +163,7 @@ export function IssueScreen({
       <Dialog
         open={adjustOpen}
         onClose={() => setAdjustOpen(false)}
-        title="Adjust estimate & priority"
+        title="Adjust issue"
         footer={
           <>
             <Button variant="ghost" onClick={() => setAdjustOpen(false)}>
@@ -159,15 +189,35 @@ export function IssueScreen({
             onChange={(e) => setPriority(e.target.value)}
           />
         </div>
+        {(collaborators.length > 0 || milestones.length > 0) && (
+          <div style={{ display: 'flex', gap: 14, marginTop: 12 }}>
+            {collaborators.length > 0 ? (
+              <Select
+                label="Assignee"
+                options={assigneeOptions}
+                value={assignee}
+                onChange={(e) => setAssignee(e.target.value)}
+              />
+            ) : null}
+            {milestones.length > 0 ? (
+              <Select
+                label="Milestone"
+                options={milestoneOptions}
+                value={milestone}
+                onChange={(e) => setMilestone(e.target.value)}
+              />
+            ) : null}
+          </div>
+        )}
         <div style={{ marginTop: 14, minHeight: 40 }}>
           {pendingChanges.length === 0 ? (
             <p style={{ font: 'var(--text-agent)', color: 'var(--ink-3)', margin: 0 }}>
-              No change yet — pick a different estimate or priority.
+              No change yet — pick a different estimate, priority, assignee, or milestone.
             </p>
           ) : (
             <>
               <p style={{ font: 'var(--text-overline)', letterSpacing: 'var(--letter-spacing-wide)', textTransform: 'uppercase', color: 'var(--ink-3)', margin: '0 0 6px' }}>
-                Proposed label change
+                Proposed change
               </p>
               {diffs.map((d) => (
                 <div key={d} style={{ font: '500 13px var(--font-mono)', color: 'var(--ink-1)' }}>
@@ -175,7 +225,7 @@ export function IssueScreen({
                 </div>
               ))}
               <p style={{ font: 'var(--text-agent)', color: 'var(--ink-2)', margin: '8px 0 0' }}>
-                Writes the label to gitea and re-runs the plan. Nothing else changes.
+                Writes to gitea and re-runs the plan. Nothing else changes.
               </p>
             </>
           )}

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

@@ -1,9 +1,22 @@
 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({ dark, setDark }: { dark: boolean; setDark: (v: boolean) => void }) {
+export function SettingsScreen({
+  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)
@@ -24,25 +37,35 @@ export function SettingsScreen({ dark, setDark }: { dark: boolean; setDark: (v:
       </header>
 
       <Card overline="Gitea" title="Connection">
-        <div style={{ display: 'flex', flexDirection: 'column', gap: 14 }}>
+        <div style={{ display: 'flex', flexDirection: 'column', gap: 12 }}>
-          <Input label="Base URL" icon="link" mono defaultValue="https://gitea.stephenmann.io" />
+          {connection ? (
-          <Input label="Access token" icon="keyboard" mono type="password" defaultValue="ct_9f2e81c4a7d6" hint="Scopes: repo, issue. Nothing more." />
+            <>
-          <div style={{ display: 'flex', flexDirection: 'column', gap: 8 }}>
+              <Row style={{ padding: '8px 12px', background: 'var(--paper-0)', border: '1px solid var(--line-1)', borderRadius: 'var(--radius-2)' }}>
-            <span style={{ font: '600 13px/1.2 var(--font-sans)', color: 'var(--ink-1)' }}>Managed repos</span>
+                <Icon name="git-branch" size={14} style={{ color: 'var(--ink-3)' }} />
-            <Row style={{ padding: '8px 12px', background: 'var(--paper-0)', border: '1px solid var(--line-1)', borderRadius: 'var(--radius-2)' }}>
+                <span style={{ font: 'var(--text-data)', color: 'var(--ink-1)', flex: 1 }}>{connection.owner}/{connection.repo}</span>
-              <Icon name="git-branch" size={14} style={{ color: 'var(--ink-3)' }} />
+                <Badge tone="ok" dot>connected</Badge>
-              <span style={{ font: 'var(--text-data)', color: 'var(--ink-1)', flex: 1 }}>stephen/commitea</span>
+              </Row>
-              <Badge tone="ok" dot>syncing</Badge>
+              <Row style={{ font: 'var(--text-caption)', color: 'var(--ink-3)', gap: 6 }}>
-              <IconButton icon="x" label="Stop managing" size="sm" />
+                <Icon name="link" size={12} />{connection.baseUrl}
+              </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/shell/app-shell.tsx

@@ -3,7 +3,9 @@ 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,
@@ -97,6 +99,9 @@ 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 [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)
@@ -132,6 +137,25 @@ export function AppShell() {
     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) => 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)
     setIssue(ref)
@@ -250,7 +274,20 @@ export function AppShell() {
       case 'directives':
         return <DirectivesScreen />
       case 'settings':
-        return <SettingsScreen dark={dark} setDark={setDark} />
+        return (
+          <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
@@ -259,6 +296,10 @@ export function AppShell() {
             onOpenIssue={openIssue}
             canWrite={backlog.status === 'ready'}
             onApplyChange={applyChange}
+            collaborators={collaborators}
+            milestones={milestoneOptions}
+            currentAssignee={currentIssue?.assignee ?? null}
+            currentMilestoneId={currentIssue?.milestone?.id ?? null}
           />
         ) : null
       case 'states':
@@ -270,6 +311,23 @@ 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)} />

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

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

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

@@ -17,7 +17,8 @@ import type {
 /** The result of a write through the bridge. */
 export type ApplyChangeResult =
   | { ok: false; reason: 'unconfigured' }
-  | { ok: true; plan: LabelPlan; issue: GiteaIssue }
+  // `plan` is present for label swaps (est/p); absent for field writes (assign, milestone).
+  | { ok: true; plan?: LabelPlan; issue: GiteaIssue }
 
 /** The result of filing captured issues. */
 export type CreateIssuesResult =
@@ -49,14 +50,43 @@ 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 }>
+  status(): Promise<{ configured: boolean; repo: string | null; demo: boolean }>
   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. */
@@ -96,6 +126,7 @@ declare global {
       gitea: GiteaBridge
       model: ModelBridge
       pmstate: PmStateBridge
+      config: ConfigBridge
     }
   }
 }

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

@@ -2,13 +2,18 @@ import { useCallback, useEffect, useRef, useState } from 'react'
 
 import type { ChangeProposal, ChatMessage as WireMessage, IssueChange } from '@commitea/core'
 
-import { CANNED_REPLY, CHAT, type ChatMessage } from '../data/fixtures.js'
+import { 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
@@ -55,10 +60,14 @@ export function useChat(onApplyChange?: (change: IssueChange) => Promise<{ ok: b
     window.commitea.model
       .status()
       .then((s) => {
-        if (alive && s.configured) {
+        if (!alive) return
+        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(() => {})
@@ -78,10 +87,8 @@ export function useChat(onApplyChange?: (change: IssueChange) => Promise<{ ok: b
       setProposals([])
 
       if (!live) {
-        window.setTimeout(() => {
+        // no model configured — nothing to send (composer is disabled anyway)
-          setThinking(false)
+        setThinking(false)
-          setConvo((c) => [...c, { from: 'agent', text: CANNED_REPLY }])
-        }, 900)
         return
       }
 
@@ -126,14 +133,13 @@ export function useChat(onApplyChange?: (change: IssueChange) => Promise<{ ok: b
     (p: ChangeProposal) => {
       if (!onApplyChange) return
       drop(p)
-      const label = p.plan.added[0] ?? p.plan.removed[0] ?? 'change'
       void onApplyChange(p.change).then((res) => {
         setConvo((c) => [
           ...c,
           {
             from: 'agent',
             text: res.ok
-              ? `Done — #${p.change.issue} is now ${label}. The plan's been re-run.`
+              ? `Done — #${p.change.issue}: ${p.summary}. The plan's been re-run.`
               : `That didn't take — #${p.change.issue} is unchanged.`,
           },
         ])

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

@@ -38,15 +38,19 @@ export const QUERY_PROJECT_TOOL: ToolDecl = {
 export const PROPOSE_CHANGE_TOOL: ToolDecl = {
   name: 'propose_change',
   description:
-    "Propose an estimate and/or priority change to an issue. This does NOT apply anything — it shows the " +
+    'Propose a change to an issue — estimate, priority, assignee, and/or milestone. This does NOT apply ' +
-    'human a diff to approve. Use it whenever the user asks to re-estimate or reprioritize. After calling it, ' +
+    'anything; it shows the human a diff to approve. Use it whenever the user asks to re-estimate, reprioritize, ' +
-    "tell the user you've *proposed* the change for approval — never say it is done.",
+    'assign someone (or unassign), or move an issue to a milestone. Pass a login for `assignee` (null to ' +
+    'unassign) and a milestone id for `milestone` (null to remove). After calling it, tell the user you have ' +
+    '*proposed* the change for approval — never say it is done.',
   parameters: {
     type: 'object',
     properties: {
       issue: { type: 'number', description: 'the issue number to change' },
       estimate: { type: 'string', enum: ['est/1d', 'est/2d', 'est/3d', 'est/5d', 'est/8d'] },
       priority: { type: 'string', enum: ['p/1', 'p/2', 'p/3', 'p/4'] },
+      assignee: { type: 'string', description: 'gitea login to assign, or null to unassign' },
+      milestone: { type: 'number', description: 'milestone id to set, or null to remove from its milestone' },
     },
     required: ['issue'],
   },
@@ -84,7 +88,7 @@ export const REGINALD_SYSTEM = [
   'You are Reginald, the calm, dry project manager inside CommiTea — a tool that runs projects on Gitea.',
   'Call query_project to ground every answer in the real project; never invent issues, numbers, or dates.',
   'The scheduler and forecasts are deterministic code — report their output, do not recompute it.',
-  'To change an estimate or priority, call propose_change — it shows the human a diff to approve.',
+  'To change an estimate, priority, assignee, or milestone, call propose_change — it shows the human a diff to approve.',
   'When the PM states standing intent ("pilots first", "freeze scope"), call record_directive to log it.',
   'Never claim a change is applied; you propose, the human approves. Forecasts are ranges, never single dates.',
   'Refer to issues as #<number>. Be brief and plain — a sentence or two. No preamble, no bullet dumps.',

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

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

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

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

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

@@ -146,6 +146,22 @@ describe('createGiteaClient.getIssue', () => {
     ])
   })
 
+  it('listCollaborators maps login+name and prepends the owner when absent', async () => {
+    const { fetch } = stubFetch([{ login: 'stephen', full_name: 'Stephen M.' }])
+    const people = await createGiteaClient(CONFIG, fetch).listCollaborators()
+    // owner (christian) prepended since /collaborators omits them; collaborator name preserved
+    expect(people).toEqual([
+      { login: 'christian', name: 'christian' },
+      { login: 'stephen', name: 'Stephen M.' },
+    ])
+  })
+
+  it('listCollaborators does not double-add the owner when already listed', async () => {
+    const { fetch } = stubFetch([{ login: 'christian', full_name: 'Christian L.' }])
+    const people = await createGiteaClient(CONFIG, fetch).listCollaborators()
+    expect(people).toEqual([{ login: 'christian', name: 'Christian L.' }])
+  })
+
   it('getFile returns null on 404 and content+sha on hit', async () => {
     const miss = stubFetch('nope', 404)
     expect(await createGiteaClient(CONFIG, miss.fetch).getFile('directives/log.jsonl')).toBeNull()

packages/core/src/gitea/client.ts

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

packages/core/src/index.ts

@@ -23,8 +23,15 @@ export type {
   GiteaRequestInit,
 } from './gitea/types.js'
 
-export { describeChange, planIssueChange, proposalsFor } from './changes/apply-changes-v0.js'
+export { describeChange, isLabelChange, planIssueChange, proposalsFor, summarizeChange } from './changes/apply-changes-v0.js'
-export type { ChangeProposal, IssueChange, LabelPlan, ProposeChangeArgs } from './changes/apply-changes-v0.js'
+export type {
+  ChangeProposal,
+  IssueChange,
+  LabelChange,
+  LabelPlan,
+  ProposalContext,
+  ProposeChangeArgs,
+} from './changes/apply-changes-v0.js'
 
 export {
   inferColumnV0,