Function updateIssueFields

src/workspaces/issues/mutate.ts:109–164

(
  wsDir: string,
  id: string,
  patch: IssueFieldPatch,
)

 * IssueRecord, or `not_found` when the file is absent.
 */
export async function updateIssueFields(
  wsDir: string,
  id: string,
  patch: IssueFieldPatch,
): Promise<MutateResult> {
  if (!ID_RE.test(id)) return { ok: false, reason: 'not_found' }
  const raw = await readWorkspaceFile(wsDir, relFor(id))
  if (raw === null) return { ok: false, reason: 'not_found' }

  const split = splitFrontmatter(raw)
  if (!split) return { ok: false, reason: 'invalid', error: 'missing YAML frontmatter' }

  // Re-validate the existing content first so we never write back a file that
  // was already broken, and so the merge starts from a known-good frontmatter.
  const current = parseIssueContent(id, raw)
  if (!current.ok) return { ok: false, reason: 'invalid', error: current.error }

  // Parse the raw frontmatter object (NOT the zod-defaulted record) so we
  // preserve every author-written key verbatim and only overwrite what changed.
  const data = parseFrontmatterObject(split.frontmatter)
  if (!data) return { ok: false, reason: 'invalid', error: 'frontmatter is not a mapping' }

  if (patch.status !== undefined) {
    if (!ISSUE_STATUSES.includes(patch.status)) {
      return { ok: false, reason: 'invalid', error: `invalid status: ${patch.status}` }
    }
    data.status = patch.status
  }
  if (patch.priority !== undefined) {
    if (!ISSUE_PRIORITIES.includes(patch.priority)) {
      return { ok: false, reason: 'invalid', error: `invalid priority: ${patch.priority}` }
    }
    data.priority = patch.priority
  }
  if (patch.assignee !== undefined) {
    const a = patch.assignee.trim()
    if (a.length === 0) return { ok: false, reason: 'invalid', error: 'assignee must be a non-empty string' }
    data.assignee = a
  }
  if (patch.agent !== undefined) {
    if (patch.agent === null) {
      delete data.agent
    } else {
      const a = patch.agent.trim()
      if (a.length === 0) return { ok: false, reason: 'invalid', error: 'agent must be a non-empty string or null' }
      data.agent = a
    }
  }

  const content = serializeIssue(data, split.body)
  // Final guard: never persist a file that wouldn't read back cleanly.
  const reparsed = parseIssueContent(id, content)
  if (!reparsed.ok) return { ok: false, reason: 'invalid', error: reparsed.error }
  await writeWorkspaceFile(wsDir, relFor(id), content)
  return { ok: true, issue: reparsed.issue }
}

/**