acdev 1.0.13 → 1.0.14

package/README.md

@@ -206,7 +206,7 @@ On first run, creates `.acdev/config.json`:
 
 | Action | Jira | GitHub |
 |--------|------|--------|
-| `set_status` | Workflow transition to a status whose name matches `targetStatus` (case-insensitive) | Applies a label named after `targetStatus` via `gh issue edit --add-label` (Projects board API is not used) |
+| `set_status` | Workflow transition to a status whose name matches `targetStatus` (case-insensitive). Settings loads live board statuses. | Sets GitHub Projects v2 **Status** (adds the issue to the project if needed); falls back to a label with that name |
 | `add_label` | Adds the Jira label via REST `update.labels` `{ add }` | Adds the issue label via `gh` |
 | `close_issue` | Transitions to a Done-category status, or else a Done/Closed/Resolved-like name | Closes the GitHub issue |
 
@@ -264,6 +264,8 @@ npm test
 | `GET` | `/api/models` | `{ models, selected, source }` — live Anthropic list or curated fallback |
 | `PATCH` | `/api/config` | Partial update including `ticketSource`, `jiraBaseUrl`; secrets (`jiraEmail`, etc.) → `.env` |
 | `POST` | `/api/jira/test` | Test Jira credentials (`GET /rest/api/3/myself`) |
+| `GET` | `/api/jira/statuses` | Live Jira board/workflow statuses for Rules |
+| `GET` | `/api/github/statuses` | Live GitHub Project Status options (or labels) |
 
 ### Branch naming
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "acdev",
-  "version": "1.0.13",
+  "version": "1.0.14",
   "description": "Local CLI + web UI for running AI agents on GitHub issues via git worktrees",
   "type": "module",
   "bin": {

package/public/app.js

@@ -162,6 +162,10 @@ let availableModels = [];
 let ticketSource = 'github';
 /** @type {'claude' | 'openrouter'} */
 let llmProvider = 'claude';
+/** @type {Array<{ name: string, column?: string, board?: string }>} */
+let jiraStatusOptions = [];
+/** @type {Array<{ name: string, projectTitle?: string }>} */
+let githubStatusOptions = [];
 /** @type {{
  *   repoName?: string,
  *   baseBranch?: string,
@@ -319,12 +323,14 @@ const els = {
   settingsJiraRuleAction: document.getElementById('settings-jira-rule-action'),
   settingsJiraRuleStatus: document.getElementById('settings-jira-rule-status'),
   settingsJiraRuleStatusField: document.getElementById('settings-jira-rule-status-field'),
+  settingsJiraRuleStatusHint: document.getElementById('settings-jira-rule-status-hint'),
   settingsJiraRuleLabel: document.getElementById('settings-jira-rule-label'),
   settingsJiraRuleLabelField: document.getElementById('settings-jira-rule-label-field'),
   settingsGithubRuleEnabled: document.getElementById('settings-github-rule-enabled'),
   settingsGithubRuleAction: document.getElementById('settings-github-rule-action'),
   settingsGithubRuleStatus: document.getElementById('settings-github-rule-status'),
   settingsGithubRuleStatusField: document.getElementById('settings-github-rule-status-field'),
+  settingsGithubRuleStatusHint: document.getElementById('settings-github-rule-status-hint'),
   settingsGithubRuleLabel: document.getElementById('settings-github-rule-label'),
   settingsGithubRuleLabelField: document.getElementById('settings-github-rule-label-field'),
   settingsGhStatus: document.getElementById('settings-gh-status'),
@@ -3817,6 +3823,9 @@ function setSettingsTab(tab) {
   if (next === 'config') {
     void fetchModels();
   }
+  if (next === 'rules') {
+    void fetchRuleStatuses();
+  }
 }
 
 /**
@@ -4008,7 +4017,12 @@ function fillSettingsForm(cfg) {
     els.settingsJiraRuleAction.value = action;
   }
   if (els.settingsJiraRuleStatus) {
-    els.settingsJiraRuleStatus.value = jiraRule.targetStatus || 'In Review';
+    fillStatusSelect(
+      els.settingsJiraRuleStatus,
+      jiraStatusOptions,
+      jiraRule.targetStatus || '',
+      { hintEl: els.settingsJiraRuleStatusHint }
+    );
   }
   if (els.settingsJiraRuleLabel) {
     els.settingsJiraRuleLabel.value = jiraRule.label || '';
@@ -4025,7 +4039,12 @@ function fillSettingsForm(cfg) {
     els.settingsGithubRuleAction.value = action;
   }
   if (els.settingsGithubRuleStatus) {
-    els.settingsGithubRuleStatus.value = ghRule.targetStatus || 'In Review';
+    fillStatusSelect(
+      els.settingsGithubRuleStatus,
+      githubStatusOptions,
+      ghRule.targetStatus || '',
+      { hintEl: els.settingsGithubRuleStatusHint }
+    );
   }
   if (els.settingsGithubRuleLabel) {
     els.settingsGithubRuleLabel.value = ghRule.label || '';
@@ -4097,6 +4116,131 @@ function fillSettingsForm(cfg) {
   }
 }
 
+/**
+ * @param {HTMLSelectElement | null} selectEl
+ * @param {Array<{ name: string, column?: string, board?: string, projectTitle?: string }>} statuses
+ * @param {string} selected
+ * @param {{ loading?: boolean, error?: string, empty?: string, hintEl?: HTMLElement | null, hintOk?: string }} [meta]
+ */
+function fillStatusSelect(selectEl, statuses, selected, meta = {}) {
+  if (!selectEl) return;
+  const current = String(selected || '').trim();
+  selectEl.innerHTML = '';
+  if (meta.loading) {
+    selectEl.disabled = true;
+    const opt = document.createElement('option');
+    opt.value = current;
+    opt.textContent = current ? `${current} (loading…)` : 'Loading statuses…';
+    selectEl.appendChild(opt);
+    selectEl.value = current;
+    if (meta.hintEl) meta.hintEl.textContent = 'Fetching live statuses…';
+    return;
+  }
+  selectEl.disabled = false;
+  const list = Array.isArray(statuses) ? statuses : [];
+  if (current && !list.some((s) => s.name === current)) {
+    const saved = document.createElement('option');
+    saved.value = current;
+    saved.textContent = `${current} (saved)`;
+    selectEl.appendChild(saved);
+  }
+  for (const st of list) {
+    const name = String(st.name || '').trim();
+    if (!name) continue;
+    const opt = document.createElement('option');
+    opt.value = name;
+    const extra = st.column && st.column !== name
+      ? st.column
+      : st.board || st.projectTitle || '';
+    opt.textContent = extra ? `${name} — ${extra}` : name;
+    selectEl.appendChild(opt);
+  }
+  if (!selectEl.options.length) {
+    const opt = document.createElement('option');
+    opt.value = current;
+    opt.textContent = meta.error || meta.empty || 'No statuses found';
+    selectEl.appendChild(opt);
+  }
+  if (current) selectEl.value = current;
+  if (meta.hintEl) {
+    if (meta.error) meta.hintEl.textContent = meta.error;
+    else if (meta.hintOk) meta.hintEl.textContent = meta.hintOk;
+  }
+}
+
+async function fetchJiraRuleStatuses() {
+  const selected =
+    els.settingsJiraRuleStatus?.value?.trim() ||
+    appConfig.jiraRules?.afterPrOpened?.targetStatus ||
+    '';
+  fillStatusSelect(els.settingsJiraRuleStatus, jiraStatusOptions, selected, {
+    loading: true,
+    hintEl: els.settingsJiraRuleStatusHint,
+  });
+  try {
+    const res = await fetch('/api/jira/statuses');
+    const data = await readJson(res);
+    if (!res.ok || !data.ok) {
+      fillStatusSelect(els.settingsJiraRuleStatus, jiraStatusOptions, selected, {
+        error: data.error || `Failed to load Jira statuses (HTTP ${res.status})`,
+        hintEl: els.settingsJiraRuleStatusHint,
+      });
+      return;
+    }
+    jiraStatusOptions = Array.isArray(data.statuses) ? data.statuses : [];
+    const source = data.source === 'board' ? 'Jira board' : 'Jira workflow catalog';
+    fillStatusSelect(els.settingsJiraRuleStatus, jiraStatusOptions, selected, {
+      hintEl: els.settingsJiraRuleStatusHint,
+      hintOk: `Live statuses from ${source}. Must match a reachable workflow status.`,
+    });
+  } catch (err) {
+    fillStatusSelect(els.settingsJiraRuleStatus, jiraStatusOptions, selected, {
+      error: err.message || 'Failed to load Jira statuses',
+      hintEl: els.settingsJiraRuleStatusHint,
+    });
+  }
+}
+
+async function fetchGithubRuleStatuses() {
+  const selected =
+    els.settingsGithubRuleStatus?.value?.trim() ||
+    appConfig.githubRules?.afterPrOpened?.targetStatus ||
+    '';
+  fillStatusSelect(els.settingsGithubRuleStatus, githubStatusOptions, selected, {
+    loading: true,
+    hintEl: els.settingsGithubRuleStatusHint,
+  });
+  try {
+    const res = await fetch('/api/github/statuses');
+    const data = await readJson(res);
+    if (!res.ok || !data.ok) {
+      fillStatusSelect(els.settingsGithubRuleStatus, githubStatusOptions, selected, {
+        error: data.error || `Failed to load GitHub statuses (HTTP ${res.status})`,
+        hintEl: els.settingsGithubRuleStatusHint,
+      });
+      return;
+    }
+    githubStatusOptions = Array.isArray(data.statuses) ? data.statuses : [];
+    const hintOk =
+      data.source === 'project'
+        ? 'Live GitHub Project Status options for this repo.'
+        : 'No Project Status field — listing repo labels instead.';
+    fillStatusSelect(els.settingsGithubRuleStatus, githubStatusOptions, selected, {
+      hintEl: els.settingsGithubRuleStatusHint,
+      hintOk,
+    });
+  } catch (err) {
+    fillStatusSelect(els.settingsGithubRuleStatus, githubStatusOptions, selected, {
+      error: err.message || 'Failed to load GitHub statuses',
+      hintEl: els.settingsGithubRuleStatusHint,
+    });
+  }
+}
+
+function fetchRuleStatuses() {
+  return Promise.all([fetchJiraRuleStatuses(), fetchGithubRuleStatuses()]);
+}
+
 /**
  * Show status / label fields based on the selected post-PR action.
  * @param {'jira' | 'github'} source
@@ -4846,6 +4990,7 @@ els.jiraTestBtn?.addEventListener('click', async () => {
     }
     els.jiraStatus.textContent = `Connected as ${data.displayName || 'OK'}`;
     els.jiraStatus.className = 'jira-status ok';
+    if (settingsTab === 'rules') void fetchJiraRuleStatuses();
   } catch (err) {
     els.jiraStatus.textContent = err.message || 'Test failed';
     els.jiraStatus.className = 'jira-status err';

package/public/index.html

@@ -604,9 +604,9 @@
                         </select>
                       </div>
                       <div class="settings-field" id="settings-jira-rule-status-field">
-                        <label class="field-label" for="settings-jira-rule-status">Target status name</label>
-                        <input id="settings-jira-rule-status" class="input" type="text" name="jiraRuleTargetStatus" autocomplete="off" placeholder="In Review">
-                        <p class="field-hint">Must match a status reachable from the issue’s current workflow (exact name, any casing).</p>
+                        <label class="field-label" for="settings-jira-rule-status">Target status</label>
+                        <select id="settings-jira-rule-status" class="input" name="jiraRuleTargetStatus"></select>
+                        <p class="field-hint" id="settings-jira-rule-status-hint">Live statuses from your Jira kanban/scrum boards. Must match a reachable workflow status.</p>
                       </div>
                       <div class="settings-field" id="settings-jira-rule-label-field">
                         <label class="field-label" for="settings-jira-rule-label">Label</label>
@@ -619,7 +619,7 @@
                   <div id="github-rules-panel" class="rules-block">
                     <div class="field-label">GitHub Issues — after PR opened</div>
                     <p class="field-hint">
-                      GitHub issues don’t have Jira-like workflow statuses. Move status applies a label named after the target status (e.g. <code>In Review</code>). You can also add a different label or close the issue. Projects board status is not supported.
+                      Move status uses a live board Status when the repo has a GitHub Project; otherwise a matching issue label. Add label uses the labels API. Close closes the issue.
                     </p>
                     <div class="settings-grid">
                       <div class="settings-field settings-field-full">
@@ -638,9 +638,9 @@
                         </select>
                       </div>
                       <div class="settings-field" id="settings-github-rule-status-field">
-                        <label class="field-label" for="settings-github-rule-status">Target status name</label>
-                        <input id="settings-github-rule-status" class="input" type="text" name="githubRuleTargetStatus" autocomplete="off" placeholder="In Review">
-                        <p class="field-hint">Applied as an issue label (exact name). Create the label in the repo first if it doesn’t exist.</p>
+                        <label class="field-label" for="settings-github-rule-status">Target status</label>
+                        <select id="settings-github-rule-status" class="input" name="githubRuleTargetStatus"></select>
+                        <p class="field-hint" id="settings-github-rule-status-hint">Live GitHub Project Status options, or repo labels if no Status field exists.</p>
                       </div>
                       <div class="settings-field" id="settings-github-rule-label-field">
                         <label class="field-label" for="settings-github-rule-label">Label</label>

package/src/afterPrRules.js

@@ -4,7 +4,8 @@
  */
 
 import { normalizeGithubRules, normalizeJiraRules } from './config.js';
-import { addIssueLabel, closeIssue } from './github.js';
+import { addIssueLabel, closeIssue, setGithubIssueProjectStatus } from './github.js';
+import { originRemoteInfo } from './gh-auth.js';
 import {
   addJiraIssueLabel,
   closeJiraIssue,
@@ -30,6 +31,7 @@ import {
  *     closeJiraIssue?: typeof closeJiraIssue,
  *     addIssueLabel?: typeof addIssueLabel,
  *     closeIssue?: typeof closeIssue,
+ *     setGithubIssueProjectStatus?: typeof setGithubIssueProjectStatus,
  *     resolveJiraCredentials?: typeof resolveJiraCredentials,
  *   },
  * }} params
@@ -47,6 +49,7 @@ export async function applyAfterPrOpenedRules({
   const doCloseJira = deps.closeJiraIssue || closeJiraIssue;
   const doAddLabel = deps.addIssueLabel || addIssueLabel;
   const doClose = deps.closeIssue || closeIssue;
+  const doSetProjectStatus = deps.setGithubIssueProjectStatus || setGithubIssueProjectStatus;
   const doResolveCreds = deps.resolveJiraCredentials || resolveJiraCredentials;
 
   const source = job.ticketSource === 'jira' || job.jiraKey ? 'jira' : 'github';
@@ -133,9 +136,22 @@ export async function applyAfterPrOpenedRules({
         appendLog(job, 'warn', msg);
         return { applied: false, message: msg };
       }
-      // GitHub issues have no workflow statuses; model status as an issue label.
+      const originUrl = originRemoteInfo(repoRoot).url;
+      const project = await doSetProjectStatus({
+        issueNumber: job.issueNumber,
+        statusName: status,
+        cwd,
+        originUrl,
+      });
+      if (project?.ok) {
+        const board = project.projectTitle ? ` on "${project.projectTitle}"` : '';
+        const msg = `Moved GitHub issue #${job.issueNumber} status to "${project.statusName}"${board} after PR opened`;
+        appendLog(job, 'info', msg);
+        return { applied: true, message: msg };
+      }
       await doAddLabel(job.issueNumber, status, cwd);
-      const msg = `Moved GitHub issue #${job.issueNumber} status to "${status}" (label) after PR opened`;
+      const fallback = project?.error ? ` (${project.error})` : '';
+      const msg = `Moved GitHub issue #${job.issueNumber} status to "${status}" (label)${fallback} after PR opened`;
       appendLog(job, 'info', msg);
       return { applied: true, message: msg };
     }

package/src/config.js

@@ -31,7 +31,7 @@ export const LLM_PROVIDERS = /** @type {const} */ (['claude', 'openrouter']);
 /**
  * Shared post-PR actions for Jira and GitHub Issues rules.
  * - Jira `set_status` / `close_issue`: workflow transitions (close → Done-like status).
- * - GitHub `set_status`: applies a label named after `targetStatus` (no board API).
+ * - GitHub `set_status`: GitHub Projects v2 Status field, else a label named after `targetStatus`.
  * - Both `add_label`: add the configured label name.
  */
 export const AFTER_PR_ACTIONS = /** @type {const} */ ([

package/src/github.js

@@ -5,6 +5,63 @@ const execFileAsync = promisify(execFile);
 
 const ISSUE_URL_RE = /github\.com\/([^/]+)\/([^/]+)\/issues\/(\d+)/;
 
+const REPO_FROM_REMOTE_RE =
+  /(?:github\.com[:/]|github\.com\/)([^/]+)\/([^/]+?)(?:\.git)?$/i;
+
+const PROJECT_STATUS_FIELDS_QUERY = `query($owner: String!, $name: String!) {
+  repository(owner: $owner, name: $name) {
+    projectsV2(first: 20) {
+      nodes {
+        id
+        title
+        fields(first: 30) {
+          nodes {
+            __typename
+            ... on ProjectV2SingleSelectField {
+              id
+              name
+              options { id name }
+            }
+          }
+        }
+      }
+    }
+  }
+}`;
+
+const ISSUE_PROJECT_ITEMS_QUERY = `query($owner: String!, $name: String!, $number: Int!) {
+  repository(owner: $owner, name: $name) {
+    issue(number: $number) {
+      id
+      projectItems(first: 20) {
+        nodes {
+          id
+          project { id title }
+        }
+      }
+    }
+  }
+}`;
+
+const ADD_PROJECT_ITEM_MUTATION = `mutation($projectId: ID!, $contentId: ID!) {
+  addProjectV2ItemById(input: { projectId: $projectId, contentId: $contentId }) {
+    item { id }
+  }
+}`;
+
+const SET_PROJECT_STATUS_MUTATION = `mutation($projectId: ID!, $itemId: ID!, $fieldId: ID!, $optionId: String!) {
+  updateProjectV2ItemFieldValue(
+    input: {
+      projectId: $projectId
+      itemId: $itemId
+      fieldId: $fieldId
+      value: { singleSelectOptionId: $optionId }
+    }
+  ) {
+    projectV2Item { id }
+  }
+}`;
+
 /**
  * @param {string} issueUrl
  * @returns {{ owner: string, repo: string, number: number }}
@@ -18,6 +75,272 @@ export function parseIssueUrl(issueUrl) {
   return { owner, repo, number: Number(number) };
 }
 
+/**
+ * Owner/repo from an origin remote (HTTPS or SSH).
+ * @param {string | null | undefined} remoteUrl
+ * @returns {{ owner: string, repo: string } | null}
+ */
+export function parseGithubRepoFromRemote(remoteUrl) {
+  const raw = String(remoteUrl || '').trim().replace(/\/+$/, '');
+  if (!raw) return null;
+  const match = raw.match(REPO_FROM_REMOTE_RE);
+  if (!match) return null;
+  const owner = match[1];
+  const repo = match[2];
+  if (!owner || !repo) return null;
+  return { owner, repo };
+}
+
+/**
+ * @param {{
+ *   query: string,
+ *   variables?: Record<string, string | number | boolean>,
+ *   cwd: string,
+ *   runGh?: typeof execFileAsync,
+ * }} params
+ */
+async function ghGraphql({ query, variables = {}, cwd, runGh = execFileAsync }) {
+  const args = ['api', 'graphql', '-f', `query=${query}`];
+  for (const [key, value] of Object.entries(variables)) {
+    if (typeof value === 'number' || typeof value === 'boolean') {
+      args.push('-F', `${key}=${value}`);
+    } else {
+      args.push('-f', `${key}=${value}`);
+    }
+  }
+  const { stdout } = await runGh('gh', args, { cwd });
+  const payload = JSON.parse(stdout);
+  if (Array.isArray(payload.errors) && payload.errors.length > 0) {
+    throw new Error(payload.errors.map((e) => e.message || String(e)).join('; '));
+  }
+  return payload.data;
+}
+
+/**
+ * @param {unknown} data
+ * @returns {Array<{
+ *   name: string,
+ *   id?: string,
+ *   projectId?: string,
+ *   projectTitle?: string,
+ *   fieldId?: string,
+ * }>}
+ */
+export function extractProjectStatusOptions(data) {
+  const nodes = data?.repository?.projectsV2?.nodes;
+  const projects = Array.isArray(nodes) ? nodes : [];
+  /** @type {Array<{ name: string, id?: string, projectId?: string, projectTitle?: string, fieldId?: string }>} */
+  const out = [];
+  const seen = new Set();
+  for (const project of projects) {
+    if (!project || typeof project !== 'object') continue;
+    const projectId = project.id != null ? String(project.id) : '';
+    const projectTitle = String(project.title || '').trim();
+    const fields = Array.isArray(project.fields?.nodes) ? project.fields.nodes : [];
+    for (const field of fields) {
+      if (!field || typeof field !== 'object') continue;
+      const fieldName = String(field.name || '').trim();
+      if (!/status/i.test(fieldName)) continue;
+      const fieldId = field.id != null ? String(field.id) : '';
+      const options = Array.isArray(field.options) ? field.options : [];
+      for (const opt of options) {
+        const name = String(opt?.name || '').trim();
+        if (!name) continue;
+        const key = name.toLowerCase();
+        if (seen.has(key)) continue;
+        seen.add(key);
+        out.push({
+          name,
+          ...(opt?.id != null ? { id: String(opt.id) } : {}),
+          ...(projectId ? { projectId } : {}),
+          ...(projectTitle ? { projectTitle } : {}),
+          ...(fieldId ? { fieldId } : {}),
+        });
+      }
+    }
+  }
+  return out;
+}
+
+/**
+ * @param {{
+ *   cwd: string,
+ *   originUrl?: string | null,
+ *   runGh?: typeof execFileAsync,
+ * }} opts
+ * @returns {Promise<{
+ *   ok: true,
+ *   source: 'project' | 'labels',
+ *   statuses: Array<{ name: string, id?: string, projectId?: string, projectTitle?: string, fieldId?: string }>,
+ * } | {
+ *   ok: false,
+ *   error: string,
+ *   statuses: [],
+ * }>}
+ */
+export async function listGithubIssueStatuses(opts) {
+  const runGh = opts.runGh || execFileAsync;
+  const cwd = opts.cwd;
+  const parsed = parseGithubRepoFromRemote(opts.originUrl);
+  try {
+    if (parsed) {
+      try {
+        const data = await ghGraphql({
+          query: PROJECT_STATUS_FIELDS_QUERY,
+          variables: { owner: parsed.owner, name: parsed.repo },
+          cwd,
+          runGh,
+        });
+        const statuses = extractProjectStatusOptions(data);
+        if (statuses.length > 0) {
+          return { ok: true, source: 'project', statuses };
+        }
+      } catch {
+        // Projects v2 may be disabled or unauthorized — try labels.
+      }
+    }
+
+    const { stdout } = await runGh(
+      'gh',
+      ['label', 'list', '--limit', '100', '--json', 'name'],
+      { cwd }
+    );
+    const labels = JSON.parse(stdout);
+    const list = Array.isArray(labels) ? labels : [];
+    const statuses = [];
+    const seen = new Set();
+    for (const label of list) {
+      const name = String(label?.name || '').trim();
+      if (!name) continue;
+      const key = name.toLowerCase();
+      if (seen.has(key)) continue;
+      seen.add(key);
+      statuses.push({ name });
+    }
+    if (statuses.length > 0) {
+      return { ok: true, source: 'labels', statuses };
+    }
+    return {
+      ok: false,
+      error: parsed
+        ? 'No GitHub Project Status options or labels found for this repo.'
+        : 'Could not parse origin remote as GitHub owner/repo, and no labels were found.',
+      statuses: [],
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      error: err instanceof Error ? err.message : String(err),
+      statuses: [],
+    };
+  }
+}
+
+/**
+ * Set a GitHub Projects v2 Status field on the issue (add to the first matching
+ * project if needed). Returns ok:false when no Status field matches.
+ * @param {{
+ *   issueNumber: number | string,
+ *   statusName: string,
+ *   cwd: string,
+ *   originUrl?: string | null,
+ *   runGh?: typeof execFileAsync,
+ * }} opts
+ * @returns {Promise<
+ *   | { ok: true, statusName: string, projectTitle?: string }
+ *   | { ok: false, reason: 'no_repo' | 'no_match' | 'error', error: string }
+ * >}
+ */
+export async function setGithubIssueProjectStatus(opts) {
+  const runGh = opts.runGh || execFileAsync;
+  const cwd = opts.cwd;
+  const want = String(opts.statusName || '').trim();
+  const n = Number(opts.issueNumber);
+  if (!want) {
+    return { ok: false, reason: 'no_match', error: 'Status name is required' };
+  }
+  if (!Number.isInteger(n) || n <= 0) {
+    return { ok: false, reason: 'error', error: `Invalid GitHub issue number: ${opts.issueNumber}` };
+  }
+  const parsed = parseGithubRepoFromRemote(opts.originUrl);
+  if (!parsed) {
+    return { ok: false, reason: 'no_repo', error: 'Could not parse GitHub owner/repo from origin remote' };
+  }
+
+  try {
+    const fieldsData = await ghGraphql({
+      query: PROJECT_STATUS_FIELDS_QUERY,
+      variables: { owner: parsed.owner, name: parsed.repo },
+      cwd,
+      runGh,
+    });
+    const options = extractProjectStatusOptions(fieldsData);
+    const match = options.find((s) => s.name.toLowerCase() === want.toLowerCase());
+    if (!match?.projectId || !match.fieldId || !match.id) {
+      return {
+        ok: false,
+        reason: 'no_match',
+        error: `No GitHub Project Status option named "${want}"`,
+      };
+    }
+
+    const issueData = await ghGraphql({
+      query: ISSUE_PROJECT_ITEMS_QUERY,
+      variables: { owner: parsed.owner, name: parsed.repo, number: n },
+      cwd,
+      runGh,
+    });
+    const issue = issueData?.repository?.issue;
+    if (!issue?.id) {
+      return { ok: false, reason: 'error', error: `GitHub issue #${n} not found` };
+    }
+
+    const items = Array.isArray(issue.projectItems?.nodes) ? issue.projectItems.nodes : [];
+    let itemId = '';
+    for (const item of items) {
+      if (item?.project?.id === match.projectId && item.id) {
+        itemId = String(item.id);
+        break;
+      }
+    }
+    if (!itemId) {
+      const added = await ghGraphql({
+        query: ADD_PROJECT_ITEM_MUTATION,
+        variables: { projectId: match.projectId, contentId: String(issue.id) },
+        cwd,
+        runGh,
+      });
+      itemId = String(added?.addProjectV2ItemById?.item?.id || '');
+    }
+    if (!itemId) {
+      return { ok: false, reason: 'error', error: `Could not add issue #${n} to GitHub Project` };
+    }
+
+    await ghGraphql({
+      query: SET_PROJECT_STATUS_MUTATION,
+      variables: {
+        projectId: match.projectId,
+        itemId,
+        fieldId: match.fieldId,
+        optionId: match.id,
+      },
+      cwd,
+      runGh,
+    });
+    return {
+      ok: true,
+      statusName: match.name,
+      projectTitle: match.projectTitle,
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      reason: 'error',
+      error: err instanceof Error ? err.message : String(err),
+    };
+  }
+}
+
 /**
  * Fetch issue title/body/labels via `gh` for branch naming and type detection.
  * @param {string} issueUrl

package/src/jira.js

@@ -316,6 +316,184 @@ export async function fetchJiraIssue(key, creds) {
   };
 }
 
+/**
+ * @param {{
+ *   baseUrl: string,
+ *   email: string,
+ *   apiToken: string,
+ *   fetchFn?: typeof fetch,
+ * }} creds
+ * @param {string} path
+ */
+async function jiraGetJson(creds, path) {
+  const fetchFn = creds.fetchFn || fetch;
+  const base = normalizeJiraBaseUrl(creds.baseUrl);
+  const url = `${base}${path.startsWith('/') ? path : `/${path}`}`;
+  const res = await fetchFn(url, {
+    method: 'GET',
+    headers: {
+      Authorization: jiraAuthHeader({
+        email: creds.email,
+        apiToken: creds.apiToken,
+      }),
+      Accept: 'application/json',
+    },
+  });
+  const text = await res.text().catch(() => '');
+  if (!res.ok) {
+    const detail = text ? `: ${text.slice(0, 200)}` : '';
+    const err = new Error(`Jira GET ${path} failed (${res.status} ${res.statusText})${detail}`);
+    err.status = res.status;
+    throw err;
+  }
+  if (!text) return {};
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new Error(`Jira GET ${path} returned invalid JSON`);
+  }
+}
+
+/**
+ * @param {unknown} raw
+ * @returns {Map<string, string>}
+ */
+export function jiraStatusIdNameMap(raw) {
+  const list = Array.isArray(raw)
+    ? raw
+    : raw && typeof raw === 'object' && Array.isArray(/** @type {{ values?: unknown }} */ (raw).values)
+      ? /** @type {{ values: unknown[] }} */ (raw).values
+      : [];
+  /** @type {Map<string, string>} */
+  const map = new Map();
+  for (const item of list) {
+    if (!item || typeof item !== 'object') continue;
+    const obj = /** @type {{ id?: unknown, name?: unknown }} */ (item);
+    const id = obj.id != null ? String(obj.id) : '';
+    const name = String(obj.name || '').trim();
+    if (id && name) map.set(id, name);
+  }
+  return map;
+}
+
+/**
+ * @param {unknown} columns
+ * @param {Map<string, string>} statusNames
+ * @param {string} [boardName]
+ * @returns {Array<{ name: string, id?: string, column?: string, board?: string }>}
+ */
+export function statusesFromBoardColumns(columns, statusNames, boardName) {
+  const cols = Array.isArray(columns) ? columns : [];
+  /** @type {Array<{ name: string, id?: string, column?: string, board?: string }>} */
+  const out = [];
+  const seen = new Set();
+  for (const col of cols) {
+    if (!col || typeof col !== 'object') continue;
+    const colObj = /** @type {{ name?: unknown, statuses?: unknown }} */ (col);
+    const column = String(colObj.name || '').trim();
+    const sts = Array.isArray(colObj.statuses) ? colObj.statuses : [];
+    for (const st of sts) {
+      if (!st || typeof st !== 'object') continue;
+      const obj = /** @type {{ id?: unknown, name?: unknown }} */ (st);
+      const id = obj.id != null ? String(obj.id) : '';
+      const name = String(obj.name || '').trim() || (id ? statusNames.get(id) || '' : '');
+      if (!name) continue;
+      const key = name.toLowerCase();
+      if (seen.has(key)) continue;
+      seen.add(key);
+      out.push({
+        name,
+        ...(id ? { id } : {}),
+        ...(column ? { column } : {}),
+        ...(boardName ? { board: boardName } : {}),
+      });
+    }
+  }
+  return out;
+}
+
+/**
+ * Live Jira statuses for the Rules dropdown.
+ * Prefers Agile board column statuses (kanban/scrum); falls back to /rest/api/3/status.
+ * @param {{
+ *   baseUrl: string,
+ *   email: string,
+ *   apiToken: string,
+ *   fetchFn?: typeof fetch,
+ * }} creds
+ * @returns {Promise<{
+ *   ok: true,
+ *   source: 'board' | 'status',
+ *   statuses: Array<{ name: string, id?: string, column?: string, board?: string }>,
+ * } | {
+ *   ok: false,
+ *   error: string,
+ *   statuses: [],
+ * }>}
+ */
+export async function listJiraBoardStatuses(creds) {
+  try {
+    let statusMap = new Map();
+    try {
+      statusMap = jiraStatusIdNameMap(await jiraGetJson(creds, '/rest/api/3/status'));
+    } catch {
+      // Board config sometimes includes status names without this lookup.
+    }
+
+    try {
+      const boards = await jiraGetJson(creds, '/rest/agile/1.0/board?maxResults=50');
+      const values = Array.isArray(boards?.values) ? boards.values : [];
+      /** @type {Array<{ name: string, id?: string, column?: string, board?: string }>} */
+      const statuses = [];
+      const seen = new Set();
+      for (const board of values) {
+        if (!board || board.id == null) continue;
+        const boardName = String(board.name || '').trim();
+        try {
+          const cfg = await jiraGetJson(
+            creds,
+            `/rest/agile/1.0/board/${encodeURIComponent(String(board.id))}/configuration`
+          );
+          const fromBoard = statusesFromBoardColumns(
+            cfg?.columnConfig?.columns,
+            statusMap,
+            boardName
+          );
+          for (const st of fromBoard) {
+            const key = st.name.toLowerCase();
+            if (seen.has(key)) continue;
+            seen.add(key);
+            statuses.push(st);
+          }
+        } catch {
+          // Skip boards the token cannot read.
+        }
+      }
+      if (statuses.length > 0) {
+        return { ok: true, source: 'board', statuses };
+      }
+    } catch {
+      // Agile API missing / 403 — use global status catalog.
+    }
+
+    const statuses = [...statusMap.entries()].map(([id, name]) => ({ name, id }));
+    if (statuses.length > 0) {
+      return { ok: true, source: 'status', statuses };
+    }
+    return {
+      ok: false,
+      error: 'No Jira statuses found. Check board access or Jira Software permissions.',
+      statuses: [],
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      error: err instanceof Error ? err.message : String(err),
+      statuses: [],
+    };
+  }
+}
+
 /**
  * Find a transition whose target status name matches (case-insensitive).
  * @param {Array<{ id?: string, name?: string, to?: { name?: string } }>} transitions

package/src/server.js

@@ -3,13 +3,14 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { Store } from './store.js';
-import { parseIssueUrl, createPr, fetchIssueDetails } from './github.js';
+import { parseIssueUrl, createPr, fetchIssueDetails, listGithubIssueStatuses } from './github.js';
 import {
   parseJiraIssueRef,
   resolveJiraCredentials,
   testJiraConnection,
   fetchJiraIssue,
   mapJiraIssueType,
+  listJiraBoardStatuses,
 } from './jira.js';
 import { applyAfterPrOpenedRules } from './afterPrRules.js';
 import {
@@ -43,7 +44,7 @@ import { upsertEnvVars } from './env.js';
 import { listModels } from './models.js';
 import { splitIssueUrls } from './urls.js';
 import { usageFromLogs, withJobUsage, snapshotJobLlm, tagUsageProvider } from './usage.js';
-import { checkGhAuth } from './gh-auth.js';
+import { checkGhAuth, originRemoteInfo } from './gh-auth.js';
 import { checkClaudeAuth } from './claude-auth.js';
 import { checkOpenRouterAuth } from './openrouter-auth.js';
 import { isValidModelId, isNoModel, NO_MODEL, isModelIdForProvider } from './models.js';
@@ -182,6 +183,8 @@ export function normalizeReviewComments(body) {
  *     resolveJiraCredentials?: Function,
  *     checkGhAuth?: typeof checkGhAuth,
  *     checkClaudeAuth?: typeof checkClaudeAuth,
+ *     listJiraBoardStatuses?: typeof listJiraBoardStatuses,
+ *     listGithubIssueStatuses?: typeof listGithubIssueStatuses,
  *   },
  * }} options
  */
@@ -197,6 +200,8 @@ export function createServer({ repoRoot, config, store, useStubAgent = false, de
   const doApplyFileExclusions = deps.applyFileExclusions || applyFileExclusions;
   const doCheckGhAuth = deps.checkGhAuth || checkGhAuth;
   const doCheckClaudeAuth = deps.checkClaudeAuth || checkClaudeAuth;
+  const doListJiraBoardStatuses = deps.listJiraBoardStatuses || listJiraBoardStatuses;
+  const doListGithubIssueStatuses = deps.listGithubIssueStatuses || listGithubIssueStatuses;
 
   function formatAgentJobError(err) {
     return err instanceof Error ? err.message : String(err);
@@ -731,6 +736,54 @@ export function createServer({ repoRoot, config, store, useStubAgent = false, de
     }
   });
 
+  app.get('/api/jira/statuses', async (_req, res) => {
+    try {
+      const creds = resolveJiraCredentials({ configBaseUrl: config.jiraBaseUrl });
+      if ('error' in creds) {
+        return res.status(400).json({ ok: false, error: creds.error, statuses: [] });
+      }
+      const result = await doListJiraBoardStatuses(creds);
+      if (!result.ok) {
+        return res.status(400).json(result);
+      }
+      res.json(result);
+    } catch (err) {
+      res.status(500).json({
+        ok: false,
+        error: err instanceof Error ? err.message : String(err),
+        statuses: [],
+      });
+    }
+  });
+
+  app.get('/api/github/statuses', async (_req, res) => {
+    try {
+      const gh = doCheckGhAuth();
+      if (!gh.ok) {
+        const error =
+          gh.reason === 'not-found'
+            ? 'GitHub CLI (gh) is not installed.'
+            : 'GitHub is not authenticated. Configure a PAT in Settings → Authentication, or run gh auth login.';
+        return res.status(400).json({ ok: false, error, statuses: [] });
+      }
+      const origin = originRemoteInfo(repoRoot);
+      const result = await doListGithubIssueStatuses({
+        cwd: repoRoot,
+        originUrl: origin.url,
+      });
+      if (!result.ok) {
+        return res.status(400).json(result);
+      }
+      res.json(result);
+    } catch (err) {
+      res.status(500).json({
+        ok: false,
+        error: err instanceof Error ? err.message : String(err),
+        statuses: [],
+      });
+    }
+  });
+
   app.post('/api/issues', (req, res) => {
     try {
       const gate = authGate({ needGh: true, needLlm: true });