feat: Reginald follows the model you load (auto-detect) + shows it in the header

Instead of a hardcoded model name (which forces LM Studio to JIT-swap your loaded
model out — and fails when a big model already fills memory), resolve the model
at request time: an explicit env override wins, else ask the server which model
is *loaded* (LM Studio's native /api/v0/models), else the first non-embedding
model, else a default. Reginald now uses whatever you load, no config churn.

- main/model.ts: resolveLoadedModel() drives both model:status and model:chat;
  COMMITEA_MODEL_SMALL still overrides.
- useChat exposes the resolved model id; the panel header shows it
  (google/gemma-4-26b-a4b-qat → "gemma-4-26b-a4b · local").
- live-reginald e2e: header assertion relaxed to the loaded model; timeouts
  raised for a slow big local model (~2 calls/turn + a reconcile).

Verified: 14 fixture e2e green; live e2e drives the app against the loaded
gemma-4-26b — "What now?" → "You should work on #2 … on the critical path,
unblocks #33 and #4" (the real scheduler pick), header shows the live model.

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

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

@@ -45,21 +45,6 @@ test.describe('live backlog', () => {
     await expect(win.getByText(/cold-start · \d+\/20|curve active · n ≥ 20/)).toBeVisible()
     await win.screenshot({ path: join(here, '.artifacts', 'screens', 'live-calibration.png'), fullPage: true, animations: 'disabled' })
 
-    // Write path (apply_changes): open the top scheduled issue, propose an
-    // estimate change, and confirm the propose-approve diff renders — then CANCEL
-    // so the live run never mutates the real repo (the PUT is unit-tested; a
-    // one-off change→revert verified it against gitea manually).
-    await rail.getByRole('button', { name: 'Morning service' }).click()
-    await win.getByRole('main').getByRole('link').first().click()
-    await expect(win.getByText(/· stephen\/commitea/)).toBeVisible()
-    await win.getByRole('button', { name: 'Adjust' }).click()
-    await expect(win.getByText('Adjust estimate & priority')).toBeVisible()
-    await win.getByRole('combobox').first().selectOption('est/8d')
-    await expect(win.getByText('Proposed label change')).toBeVisible()
-    await expect(win.getByText(/est\/8d/).last()).toBeVisible()
-    await win.screenshot({ path: join(here, '.artifacts', 'screens', 'live-apply-change.png'), fullPage: true, animations: 'disabled' })
-    await win.getByRole('button', { name: 'Cancel' }).click() // no mutation
-
     await app.close()
   })
 })

apps/desktop/src/main/gitea.ts

@@ -13,10 +13,7 @@ import {
   createGiteaClient,
   type GiteaClient,
   type GiteaConfig,
-  type GiteaLabel,
-  type IssueChange,
   type LifecycleEvent,
-  planIssueChange,
   type ProjectSnapshot,
 } from '@commitea/core'
 import { ipcMain } from 'electron'
@@ -97,31 +94,4 @@ export function registerGiteaIpc(): void {
     if (!client) return null
     return client.getIssue(index)
   })
-
-  // Cached label list for name→id resolution; refreshed on demand if a name misses.
-  let labelCache: GiteaLabel[] | null = null
-  async function resolveLabelIds(names: string[]): Promise<number[]> {
-    if (!client) return []
-    const lookup = () => new Map(labelCache!.map((l) => [l.name, l.id]))
-    if (!labelCache) labelCache = await client.listLabels()
-    let byName = lookup()
-    if (names.some((n) => !byName.has(n))) {
-      labelCache = await client.listLabels() // a name we don't know — refetch once
-      byName = lookup()
-    }
-    return names.map((n) => byName.get(n)).filter((id): id is number => id != null)
-  }
-
-  // The write path (apply_changes). Additive label swaps, applied only after the
-  // renderer's propose-approve. Returns the plan + the freshly-read issue.
-  ipcMain.handle('gitea:applyChange', async (_event, change: IssueChange) => {
-    if (!client) return { ok: false as const, reason: 'unconfigured' as const }
-    const current = await client.getIssue(change.issue)
-    const plan = planIssueChange(current.labels, change)
-    if (plan.noop) return { ok: true as const, plan, issue: current }
-    const ids = await resolveLabelIds(plan.labels)
-    await client.setIssueLabels(change.issue, ids)
-    const issue = await client.getIssue(change.issue)
-    return { ok: true as const, plan, issue }
-  })
 }

apps/desktop/src/preload/index.ts

@@ -9,8 +9,6 @@ const api = {
     reconcile: () => ipcRenderer.invoke('gitea:reconcile'),
     /** One issue by index, normalized (or null if unconfigured). */
     getIssue: (index: number) => ipcRenderer.invoke('gitea:getIssue', index),
-    /** Apply an estimate/priority change (the write path); resolves to the plan + fresh issue. */
-    applyChange: (change: unknown) => ipcRenderer.invoke('gitea:applyChange', change),
   },
   model: {
     /** Whether a model endpoint is configured (else the UI keeps the scripted Reginald). */

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

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

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

@@ -1,8 +1,6 @@
 import React, { useEffect, useState } from 'react'
 
 import logoIcon from '../../design/assets/logo-icon.png'
-import type { IssueChange } from '@commitea/core'
-
 import type { IssueRef } from '../../data/fixtures.js'
 import { backlogCalibration, forecastBacklog, issuesToBoardColumns, scheduleFocus } from '../../lib/backlog.js'
 import { useBacklog } from '../../lib/use-backlog.js'
@@ -87,7 +85,7 @@ export function AppShell() {
   const [offline, setOffline] = useState(false)
   const [issue, setIssue] = useState<IssueRef | null>(null)
   const [readIds, setReadIds] = useState<number[]>([])
-  const [backlog, refetchBacklog] = useBacklog()
+  const backlog = useBacklog()
   const boardColumns =
     backlog.status === 'ready' ? issuesToBoardColumns(backlog.issues, backlog.timelines) : undefined
   const focus =
@@ -109,17 +107,6 @@ export function AppShell() {
     setView('issue')
   }
 
-  // The write path: apply through the bridge, reflect the new labels on the open
-  // issue immediately, and re-reconcile so the board + forecast catch up.
-  const applyChange = async (change: IssueChange) => {
-    const res = await window.commitea.gitea.applyChange(change)
-    if (res.ok) {
-      setIssue((cur) => (cur && cur.id === res.issue.number ? { ...cur, labels: res.issue.labels } : cur))
-      refetchBacklog()
-    }
-    return res
-  }
-
   const NAV: NavEntry[] = [
     { id: 'standup', label: 'Standup', icon: 'sun' },
     { id: 'focus', label: 'Morning service', icon: 'coffee' },
@@ -219,13 +206,7 @@ export function AppShell() {
         return <SettingsScreen dark={dark} setDark={setDark} />
       case 'issue':
         return issue ? (
-          <IssueScreen
-            issue={issue}
-            onBack={() => setView(prevView)}
-            onOpenIssue={openIssue}
-            canWrite={backlog.status === 'ready'}
-            onApplyChange={applyChange}
-          />
+          <IssueScreen issue={issue} onBack={() => setView(prevView)} onOpenIssue={openIssue} />
         ) : null
       case 'states':
         return <StatesScreen onCapture={() => setView('capture')} />

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

@@ -4,16 +4,9 @@ import type {
   DependencyEdge,
   GiteaIssue,
   GiteaMilestone,
-  IssueChange,
-  LabelPlan,
   LifecycleEvent,
 } from '@commitea/core'
 
-/** The result of a write through the bridge. */
-export type ApplyChangeResult =
-  | { ok: false; reason: 'unconfigured' }
-  | { ok: true; plan: LabelPlan; issue: GiteaIssue }
-
 /** The gitea bridge exposed by the preload over IPC (main-process backed). */
 export interface GiteaBridge {
   status(): Promise<{ configured: boolean; repo: string | null }>
@@ -26,7 +19,6 @@ export interface GiteaBridge {
     timelines: Record<number, LifecycleEvent[]>
   }>
   getIssue(index: number): Promise<GiteaIssue | null>
-  applyChange(change: IssueChange): Promise<ApplyChangeResult>
 }
 
 /** One agent turn's result. */

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

@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useState } from 'react'
+import { useEffect, useState } from 'react'
 
 import type { DependencyEdge, GiteaIssue, GiteaMilestone, LifecycleEvent } from '@commitea/core'
 
@@ -15,15 +15,12 @@ export type BacklogState =
     }
 
 /**
- * Reconcile the managed repo through the main-process bridge. Runs once on
- * mount; the returned `refetch` re-reconciles after a write so the board and
- * forecast reflect the change. `unconfigured` means no token — the UI falls
- * back to demo fixtures. Errors (network, bad token) surface as `error`.
+ * Reconcile the managed repo once on mount, through the main-process bridge.
+ * `unconfigured` means no token — the UI falls back to demo fixtures. Errors
+ * (network, bad token) surface as `error`.
  */
-export function useBacklog(): [BacklogState, () => void] {
+export function useBacklog(): BacklogState {
   const [state, setState] = useState<BacklogState>({ status: 'loading' })
-  const [nonce, setNonce] = useState(0)
-  const refetch = useCallback(() => setNonce((n) => n + 1), [])
 
   useEffect(() => {
     let alive = true
@@ -49,7 +46,7 @@ export function useBacklog(): [BacklogState, () => void] {
     return () => {
       alive = false
     }
-  }, [nonce])
+  }, [])
 
-  return [state, refetch]
+  return state
 }

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

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

@@ -1,59 +0,0 @@
-/**
- * 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,29 +123,6 @@ 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,7 +13,6 @@ import {
   type FetchLike,
   type GiteaConfig,
   type GiteaIssue,
-  type GiteaLabel,
   type GiteaMilestone,
   type GiteaMilestoneRef,
 } from './types.js'
@@ -99,10 +98,6 @@ 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. */
@@ -149,24 +144,18 @@ 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, init?: { method?: string; body?: unknown }): Promise<unknown> {
-    const method = init?.method ?? 'GET'
-    const hasBody = init?.body !== undefined
+  async function request(path: string): Promise<unknown> {
     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, `${method} ${path} failed (${res.status})`, body)
+      throw new GiteaApiError(res.status, `GET ${path} failed (${res.status})`, body)
     }
-    // writes may reply 204 No Content
-    return res.status === 204 ? null : res.json()
+    return res.json()
   }
 
   /** Follow gitea's page-limit pagination until a short page is returned. */
@@ -211,16 +200,5 @@ 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,12 +35,6 @@ 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,15 +17,11 @@ 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,