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>

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 " +
-    'human a diff to approve. Use it whenever the user asks to re-estimate or reprioritize. After calling it, ' +
-    "tell the user you've *proposed* the change for approval — never say it is done.",
+    'Propose a change to an issue — estimate, priority, assignee, and/or milestone. This does NOT apply ' +
+    'anything; it shows the human a diff to approve. Use it whenever the user asks to re-estimate, reprioritize, ' +
+    '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

@@ -65,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

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

@@ -90,18 +90,32 @@ export function summarizeChange(change: IssueChange, currentLabels: string[] = [
   }
 }
 
-/** A change the agent proposes: the concrete op + its diff, ready for approve-then-apply. */
+/** 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 {
@@ -112,25 +126,33 @@ function isPriority(v: unknown): v is PriorityLabel {
 }
 
 /**
- * Build the concrete, non-noop proposals for a `propose_change` request against
- * an issue's current labels. Invalid or unchanged axes are dropped — the agent
- * proposes only real changes, and never a label outside the est/* · p/* axes.
+ * Build the concrete, non-noop proposals for a `propose_change` request. Label
+ * axes (est/*, p/*) are validated and never invented; assign/milestone are
+ * 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 change: IssueChange = { kind: 'reestimate', issue: args.issue, estimate: args.estimate }
+  const pushLabel = (change: LabelChange) => {
     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)) {
-    const change: IssueChange = { kind: 'reprioritize', issue: args.issue, priority: args.priority }
-    const plan = planIssueChange(currentLabels, change)
-    if (!plan.noop) out.push({ change, plan, issueTitle })
+  if (isEstimate(args.estimate)) pushLabel({ kind: 'reestimate', issue: args.issue, estimate: args.estimate })
+  if (isPriority(args.priority)) pushLabel({ kind: 'reprioritize', issue: args.issue, priority: args.priority })
+
+  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,6 +101,8 @@ export interface GiteaClient {
   getIssueTimeline(index: number): Promise<LifecycleEvent[]>
   /** Every label defined on the repo (id + name), for name→id resolution. */
   listLabels(): Promise<GiteaLabel[]>
+  /** Repo collaborators (login + display name) — the assignable people. */
+  listCollaborators(): Promise<{ login: string; name: string }[]>
   /** Replace an issue's entire label set with the given label ids. Write. */
   setIssueLabels(index: number, labelIds: number[]): Promise<void>
   /** Replace an issue's assignees (empty array unassigns); returns the updated issue. Write. */
@@ -233,6 +235,19 @@ 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)

packages/core/src/index.ts

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