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

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

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

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

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

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

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

@@ -0,0 +1,54 @@
+import { describe, expect, it } from 'vitest'
+
+import { describeChange, type IssueChange, planIssueChange } from './apply-changes-v0.js'
+
+describe('planIssueChange', () => {
+  it('swaps the estimate label, keeping non-axis labels', () => {
+    const plan = planIssueChange(['est/2d', 'p/1', 'backend'], { kind: 'reestimate', issue: 1, estimate: 'est/5d' })
+    expect(plan.removed).toEqual(['est/2d'])
+    expect(plan.added).toEqual(['est/5d'])
+    expect(plan.labels).toEqual(['p/1', 'backend', 'est/5d'])
+    expect(plan.noop).toBe(false)
+  })
+
+  it('adds an estimate when none was set', () => {
+    const plan = planIssueChange(['p/2'], { kind: 'reestimate', issue: 1, estimate: 'est/1d' })
+    expect(plan.removed).toEqual([])
+    expect(plan.added).toEqual(['est/1d'])
+    expect(plan.labels).toEqual(['p/2', 'est/1d'])
+  })
+
+  it('clears the axis when the target is null', () => {
+    const plan = planIssueChange(['est/3d', 'p/1'], { kind: 'reprioritize', issue: 1, priority: null })
+    expect(plan.removed).toEqual(['p/1'])
+    expect(plan.added).toEqual([])
+    expect(plan.labels).toEqual(['est/3d'])
+  })
+
+  it('is a noop when the target already holds the axis alone', () => {
+    const plan = planIssueChange(['est/2d', 'p/1'], { kind: 'reestimate', issue: 1, estimate: 'est/2d' })
+    expect(plan.noop).toBe(true)
+    expect(plan.labels).toEqual(['p/1', 'est/2d'])
+  })
+
+  it('cleans up a duplicated axis down to the target', () => {
+    // two est/* labels — the change collapses to one
+    const plan = planIssueChange(['est/2d', 'est/5d', 'p/1'], { kind: 'reestimate', issue: 1, estimate: 'est/5d' })
+    expect(plan.removed).toEqual(['est/2d'])
+    expect(plan.added).toEqual([]) // est/5d already present
+    expect(plan.labels).toEqual(['p/1', 'est/5d'])
+    expect(plan.noop).toBe(false)
+  })
+
+  it('reprioritize only touches the priority axis', () => {
+    const plan = planIssueChange(['est/2d', 'p/3'], { kind: 'reprioritize', issue: 1, priority: 'p/1' })
+    expect(plan.labels).toEqual(['est/2d', 'p/1'])
+  })
+
+  it('describeChange renders the diff', () => {
+    const change: IssueChange = { kind: 'reestimate', issue: 1, estimate: 'est/5d' }
+    expect(describeChange(planIssueChange(['est/2d'], change))).toBe('est/2d → est/5d')
+    expect(describeChange(planIssueChange(['p/1'], { kind: 'reprioritize', issue: 1, priority: null }))).toBe('p/1 → ∅')
+    expect(describeChange(planIssueChange(['est/5d'], change))).toBe('no change')
+  })
+})

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

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

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

@@ -123,6 +123,29 @@ describe('createGiteaClient.getIssue', () => {
     )
   })
 
+  it('setIssueLabels PUTs the label ids to the issue labels endpoint', async () => {
+    const { fetch, calls } = stubFetch(null, 204)
+    await createGiteaClient(CONFIG, fetch).setIssueLabels(9, [3, 7])
+
+    expect(calls).toHaveLength(1)
+    expect(calls[0].url).toBe('https://gitea.stephenmann.io/api/v1/repos/christian/commitea/issues/9/labels')
+    expect(calls[0].init?.method).toBe('PUT')
+    expect(calls[0].init?.headers?.['Content-Type']).toBe('application/json')
+    expect(JSON.parse(calls[0].init?.body ?? '{}')).toEqual({ labels: [3, 7] })
+  })
+
+  it('listLabels returns id+name pairs', async () => {
+    const { fetch } = stubFetch([
+      { id: 3, name: 'est/2d', color: 'fff' },
+      { id: 7, name: 'p/1', color: '000' },
+    ])
+    const labels = await createGiteaClient(CONFIG, fetch).listLabels()
+    expect(labels).toEqual([
+      { id: 3, name: 'est/2d' },
+      { id: 7, name: 'p/1' },
+    ])
+  })
+
   it('throws GiteaApiError carrying status + body on a non-2xx response', async () => {
     const { fetch } = stubFetch('not found', 404)
     const client = createGiteaClient(CONFIG, fetch)

packages/core/src/gitea/client.ts

@@ -13,6 +13,7 @@ import {
   type FetchLike,
   type GiteaConfig,
   type GiteaIssue,
+  type GiteaLabel,
   type GiteaMilestone,
   type GiteaMilestoneRef,
 } from './types.js'
@@ -98,6 +99,10 @@ export interface GiteaClient {
   getIssueDependencies(index: number): Promise<number[]>
   /** Normalized lifecycle events for one issue (all pages of its timeline). */
   getIssueTimeline(index: number): Promise<LifecycleEvent[]>
+  /** Every label defined on the repo (id + name), for name→id resolution. */
+  listLabels(): Promise<GiteaLabel[]>
+  /** Replace an issue's entire label set with the given label ids. Write. */
+  setIssueLabels(index: number, labelIds: number[]): Promise<void>
 }
 
 /** Map raw gitea issue JSON to the normalized domain shape. Pure. */
@@ -144,18 +149,24 @@ export function createGiteaClient(config: GiteaConfig, fetchImpl: FetchLike): Gi
   const apiBase = `${config.baseUrl.replace(/\/+$/, '')}/api/v1`
   const repoBase = `${apiBase}/repos/${config.owner}/${config.repo}`
 
-  async function request(path: string): Promise<unknown> {
+  async function request(path: string, init?: { method?: string; body?: unknown }): Promise<unknown> {
+    const method = init?.method ?? 'GET'
+    const hasBody = init?.body !== undefined
     const res = await fetchImpl(`${repoBase}${path}`, {
+      method,
       headers: {
         Authorization: `token ${config.token}`,
         Accept: 'application/json',
+        ...(hasBody ? { 'Content-Type': 'application/json' } : {}),
       },
+      body: hasBody ? JSON.stringify(init!.body) : undefined,
     })
     if (!res.ok) {
       const body = await res.text().catch(() => '')
-      throw new GiteaApiError(res.status, `GET ${path} failed (${res.status})`, body)
+      throw new GiteaApiError(res.status, `${method} ${path} failed (${res.status})`, body)
     }
-    return res.json()
+    // writes may reply 204 No Content
+    return res.status === 204 ? null : res.json()
   }
 
   /** Follow gitea's page-limit pagination until a short page is returned. */
@@ -200,5 +211,16 @@ export function createGiteaClient(config: GiteaConfig, fetchImpl: FetchLike): Gi
       )
       return normalizeTimeline(raw)
     },
+
+    async listLabels() {
+      const raw = await requestAll<{ id: number; name: string }>(
+        (page) => `/labels?page=${page}&limit=${PAGE_LIMIT}`,
+      )
+      return raw.map((l) => ({ id: l.id, name: l.name }))
+    },
+
+    async setIssueLabels(index, labelIds) {
+      await request(`/issues/${index}/labels`, { method: 'PUT', body: { labels: labelIds } })
+    },
   }
 }

packages/core/src/gitea/types.ts

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

packages/core/src/index.ts

@@ -17,11 +17,15 @@ export type {
   GiteaConfig,
   GiteaHttpResponse,
   GiteaIssue,
+  GiteaLabel,
   GiteaMilestone,
   GiteaMilestoneRef,
   GiteaRequestInit,
 } from './gitea/types.js'
 
+export { describeChange, planIssueChange } from './changes/apply-changes-v0.js'
+export type { IssueChange, LabelPlan } from './changes/apply-changes-v0.js'
+
 export {
   inferColumnV0,
   inferLifecycle,