@gr8ful/spf 0.1.5 → 0.1.7

package/dist/core/issues/jira_provider.js

@@ -0,0 +1,163 @@
+const STATES = ["ready", "working", "review", "done", "blocked"];
+const MARKER_RE = /\[spf-watch-marker\]\s*(\{.*?\})/s;
+function toAdf(text) {
+    return {
+        type: "doc",
+        version: 1,
+        content: [{ type: "paragraph", content: [{ type: "text", text }] }],
+    };
+}
+/** Walks an ADF document's `text` nodes and joins them — the minimal inverse of `toAdf`, not a full ADF renderer. */
+function adfToText(adf) {
+    if (!adf || typeof adf !== "object")
+        return "";
+    const node = adf;
+    if (node.type === "text" && typeof node.text === "string")
+        return node.text;
+    if (Array.isArray(node.content))
+        return node.content.map(adfToText).join("");
+    return "";
+}
+export class JiraProvider {
+    baseUrl;
+    projectKey;
+    labelPrefix;
+    email;
+    apiToken;
+    constructor(baseUrl, // e.g. "https://your-domain.atlassian.net", no trailing slash
+    projectKey, labelPrefix, email, apiToken) {
+        this.baseUrl = baseUrl;
+        this.projectKey = projectKey;
+        this.labelPrefix = labelPrefix;
+        this.email = email;
+        this.apiToken = apiToken;
+    }
+    authHeader() {
+        return `Basic ${Buffer.from(`${this.email}:${this.apiToken}`).toString("base64")}`;
+    }
+    async jira(path, init) {
+        const debug = Boolean(process.env["SPF_JIRA_DEBUG"]);
+        if (debug)
+            console.error(`[jira debug] ${init?.method ?? "GET"} ${this.baseUrl}${path} body=${init?.body ?? "(none)"}`);
+        const response = await fetch(`${this.baseUrl}${path}`, {
+            ...init,
+            headers: {
+                Authorization: this.authHeader(),
+                Accept: "application/json",
+                ...(init?.body ? { "Content-Type": "application/json" } : {}),
+                ...init?.headers,
+            },
+        });
+        if (!response.ok) {
+            const detail = await response.text().catch(() => "");
+            throw new Error(`Jira ${init?.method ?? "GET"} ${path} -> ${response.status}: ${detail.slice(0, 500)}`);
+        }
+        if (response.status === 204)
+            return undefined;
+        const text = await response.text();
+        if (debug)
+            console.error(`[jira debug] -> ${response.status} ${text.slice(0, 2000)}`);
+        return text ? JSON.parse(text) : undefined;
+    }
+    label(state) {
+        return `${this.labelPrefix}:${state}`;
+    }
+    /** Jira labels are freeform strings, not a seedable registry — report what's used, create nothing. */
+    async ensureLabels() {
+        return { created: [], updated: [], unchanged: STATES.map((s) => this.label(s)) };
+    }
+    toIssue(raw) {
+        return {
+            id: raw.key,
+            title: raw.fields.summary,
+            body: raw.fields.description ? adfToText(raw.fields.description) : "",
+            labels: raw.fields.labels,
+        };
+    }
+    /**
+     * POST with the JQL in the JSON body, NOT a GET with `jql` as a query
+     * param: this endpoint's own real-world behavior (confirmed by multiple
+     * independent bug reports against it, not just this project's own
+     * testing) is to silently ignore query-string parameters and return an
+     * empty `issues` array with a 200 OK — no error, nothing to catch. A
+     * `spf watch` that builds this as a GET query string would run cleanly
+     * forever without ever claiming a single issue.
+     */
+    async searchByLabel(label) {
+        const jql = `project = ${JSON.stringify(this.projectKey)} AND labels = ${JSON.stringify(label)}`;
+        const result = await this.jira("/rest/api/3/search/jql", {
+            method: "POST",
+            body: JSON.stringify({ jql, maxResults: 100, fields: ["summary", "description", "labels"] }),
+        });
+        return result.issues.map((i) => this.toIssue(i));
+    }
+    async listEligible() {
+        return this.searchByLabel(this.label("ready"));
+    }
+    /**
+     * `opts.includeAll` is ignored: nothing but this provider's own
+     * `transition()` ever changes an issue's labels or resolution here, so
+     * there's no side channel (like GitHub's `Closes #n` auto-close) that
+     * could make a `review`-labeled issue vanish from an unfiltered query.
+     */
+    async listInState(state) {
+        return this.searchByLabel(this.label(state));
+    }
+    async claim(issue) {
+        const next = issue.labels.filter((l) => l !== this.label("ready"));
+        next.push(this.label("working"));
+        await this.jira(`/rest/api/3/issue/${issue.id}`, { method: "PUT", body: JSON.stringify({ fields: { labels: next } }) });
+        const fresh = await this.jira(`/rest/api/3/issue/${issue.id}?fields=summary,description,labels`);
+        const labels = fresh.fields.labels;
+        const claimed = labels.includes(this.label("working")) && !labels.includes(this.label("ready"));
+        if (!claimed) {
+            const revert = labels.filter((l) => l !== this.label("working"));
+            revert.push(this.label("ready"));
+            await this.jira(`/rest/api/3/issue/${issue.id}`, { method: "PUT", body: JSON.stringify({ fields: { labels: revert } }) }).catch(() => undefined);
+        }
+        return claimed;
+    }
+    async transition(issue, to, detail) {
+        const next = issue.labels.filter((l) => !STATES.some((s) => this.label(s) === l));
+        next.push(this.label(to));
+        await this.jira(`/rest/api/3/issue/${issue.id}`, { method: "PUT", body: JSON.stringify({ fields: { labels: next } }) });
+        if (detail)
+            await this.comment(issue, detail);
+    }
+    async comment(issue, body) {
+        await this.jira(`/rest/api/3/issue/${issue.id}/comment`, { method: "POST", body: JSON.stringify({ body: toAdf(body) }) });
+    }
+    async findMarkerComment(issueId) {
+        const result = await this.jira(`/rest/api/3/issue/${issueId}/comment?maxResults=100`);
+        let found = null;
+        for (const c of result.comments) {
+            const match = MARKER_RE.exec(adfToText(c.body));
+            if (!match)
+                continue;
+            try {
+                found = { id: c.id, marker: JSON.parse(match[1]) };
+            }
+            catch {
+                // malformed marker JSON — tolerate it and keep looking, like github_provider.ts does
+            }
+        }
+        return found;
+    }
+    async readMarker(issue) {
+        const found = await this.findMarkerComment(issue.id);
+        return found?.marker ?? null;
+    }
+    async writeMarker(issue, marker) {
+        // Unlike GitHub's HTML-comment trick, Jira's ADF has no way to actually
+        // hide this from a viewer — it's a plainly visible comment, just one
+        // that starts with a recognizable, regex-matchable tag.
+        const body = toAdf(`[spf-watch-marker] ${JSON.stringify(marker)}`);
+        const existing = await this.findMarkerComment(issue.id);
+        if (existing) {
+            await this.jira(`/rest/api/3/issue/${issue.id}/comment/${existing.id}`, { method: "PUT", body: JSON.stringify({ body }) });
+        }
+        else {
+            await this.jira(`/rest/api/3/issue/${issue.id}/comment`, { method: "POST", body: JSON.stringify({ body }) });
+        }
+    }
+}

package/dist/core/issues/provider.d.ts

@@ -1,10 +1,18 @@
 /**
- * The issue-tracker seam `spf watch` drives — the abstraction the user's own
+ * The two seams `spf watch` drives — the abstraction the user's own
  * reference implementation (a GitHub-issues SDLC poller) never had: its
  * GitHub client is a concrete class referenced by type everywhere, so
- * adding a second tracker would mean reworking the poll loop itself. Here,
- * nothing outside `github_provider.ts` (or a future `jira_provider.ts`)
- * knows it's talking to GitHub.
+ * adding a second tracker would mean reworking the poll loop itself.
+ *
+ * `IssueProvider` (tracker: list/claim/transition/comment/markers) and
+ * `CodeHostProvider` (PR lifecycle: open/status) are deliberately separate
+ * interfaces, not one bundled seam — a tracker and a code host are
+ * independent choices in practice (Jira issues against a Bitbucket repo is
+ * a real setup, not a hypothetical one). `github_provider.ts`'s single
+ * class implements both, since GitHub natively is both; `jira_provider.ts`
+ * implements only `IssueProvider`, `bitbucket_provider.ts` only
+ * `CodeHostProvider` — any tracker x host combination is just config
+ * (`watch.issue_provider` x `watch.code_host`), never a poll-loop change.
  *
  * The label-as-state-machine design is deliberate, copied from that same
  * reference: `transition()` is the ONE mutator, so every state change is
@@ -13,7 +21,8 @@
  */
 export type WatchState = "ready" | "working" | "review" | "done" | "blocked";
 export interface Issue {
-    number: number;
+    /** Opaque tracker identifier: a GitHub issue number stringified ("42"), a Jira key ("PROJ-123"). */
+    id: string;
     title: string;
     body: string;
     labels: string[];
@@ -51,8 +60,8 @@ export interface IssueProvider {
      * Idempotently seed whatever this tracker needs for the state machine to
      * work at all — GitHub: the five `<prefix>:*` labels, with a color and
      * description, created if missing and corrected if drifted. A tracker
-     * with no such concept (a future one might model state entirely as a
-     * workflow field) can make this a no-op — `spf watch init` just reports
+     * with no such concept (Jira labels are freeform strings, not seedable
+     * objects) can make this a no-op — `spf watch init` just reports
      * whatever comes back, empty results included.
      */
     ensureLabels(): Promise<EnsureLabelsResult>;
@@ -60,10 +69,13 @@ export interface IssueProvider {
     listEligible(): Promise<Issue[]>;
     /**
      * Issues currently in `state`. `includeAll` queries closed issues too —
-     * required for `review`, since GitHub (or any tracker with a `Closes #n`
-     * convention) can auto-close an issue the instant its PR merges, often
-     * before the next poll tick runs; an open-only query would let it vanish
-     * from tracking forever.
+     * required for `review` on a tracker where closing an issue is a side
+     * effect the tracker itself performs (GitHub auto-closes on a merged
+     * `Closes #n` PR, often before the next poll tick runs); an open-only
+     * query would let it vanish from tracking forever. A tracker where
+     * nothing but `transition()` ever changes an issue's resolution (Jira,
+     * under this design) can ignore the flag — there's no side channel to
+     * miss.
      */
     listInState(state: WatchState, opts?: {
         includeAll?: boolean;
@@ -78,13 +90,24 @@ export interface IssueProvider {
     /** The one state-mutating call. `detail`, if given, is also posted as a comment. */
     transition(issue: Issue, to: WatchState, detail?: string): Promise<void>;
     comment(issue: Issue, body: string): Promise<void>;
-    openPr(issue: Issue, opts: {
+    readMarker(issue: Issue): Promise<WatchMarker | null>;
+    writeMarker(issue: Issue, marker: WatchMarker): Promise<void>;
+}
+/**
+ * The PR-lifecycle seam, independent of `IssueProvider` — see the module
+ * comment above. `openPr` takes no issue reference: cross-linking a PR to
+ * its issue is the caller's job (put the issue's `id`/title in `title`/
+ * `body`), not this seam's, since a code host paired with a different
+ * tracker has no native "closes" convention to hook into anyway. `spf
+ * watch`'s own polling (`finishReviews`), not the host's auto-close
+ * behavior, is what drives `done`/`blocked` — see `watch.ts`.
+ */
+export interface CodeHostProvider {
+    openPr(opts: {
         branch: string;
         title: string;
         body: string;
         base: string;
     }): Promise<PrRef>;
     prStatus(pr: PrRef): Promise<PrStatus>;
-    readMarker(issue: Issue): Promise<WatchMarker | null>;
-    writeMarker(issue: Issue, marker: WatchMarker): Promise<void>;
 }

package/dist/core/issues/provider.js

@@ -1,10 +1,18 @@
 /**
- * The issue-tracker seam `spf watch` drives — the abstraction the user's own
+ * The two seams `spf watch` drives — the abstraction the user's own
  * reference implementation (a GitHub-issues SDLC poller) never had: its
  * GitHub client is a concrete class referenced by type everywhere, so
- * adding a second tracker would mean reworking the poll loop itself. Here,
- * nothing outside `github_provider.ts` (or a future `jira_provider.ts`)
- * knows it's talking to GitHub.
+ * adding a second tracker would mean reworking the poll loop itself.
+ *
+ * `IssueProvider` (tracker: list/claim/transition/comment/markers) and
+ * `CodeHostProvider` (PR lifecycle: open/status) are deliberately separate
+ * interfaces, not one bundled seam — a tracker and a code host are
+ * independent choices in practice (Jira issues against a Bitbucket repo is
+ * a real setup, not a hypothetical one). `github_provider.ts`'s single
+ * class implements both, since GitHub natively is both; `jira_provider.ts`
+ * implements only `IssueProvider`, `bitbucket_provider.ts` only
+ * `CodeHostProvider` — any tracker x host combination is just config
+ * (`watch.issue_provider` x `watch.code_host`), never a poll-loop change.
  *
  * The label-as-state-machine design is deliberate, copied from that same
  * reference: `transition()` is the ONE mutator, so every state change is

package/dist/core/paths.d.ts

@@ -22,6 +22,8 @@ export declare const ASSETS_DIR: string;
 export declare const WEB_DIR: string;
 export declare const BUILTIN_CONFIG_PATH: string;
 export declare const BUILTIN_PROMPTS_DIR: string;
+/** `spf init --template <name>` reads `<name>.spf.config.yaml` from here. */
+export declare const TEMPLATES_DIR: string;
 export interface RepoAnchor {
     /** The invocation cwd this anchor was resolved from (already absolute). */
     cwd: string;

package/dist/core/paths.js

@@ -25,6 +25,8 @@ export const ASSETS_DIR = path.join(PACKAGE_ROOT, "assets");
 export const WEB_DIR = path.join(PACKAGE_ROOT, "web");
 export const BUILTIN_CONFIG_PATH = path.join(ASSETS_DIR, "defaults", "spf.config.yaml");
 export const BUILTIN_PROMPTS_DIR = path.join(ASSETS_DIR, "prompts");
+/** `spf init --template <name>` reads `<name>.spf.config.yaml` from here. */
+export const TEMPLATES_DIR = path.join(ASSETS_DIR, "templates");
 /** Walk up from `cwd` to (and including) `repoRoot` looking for a `.spf/` directory. */
 function findSfDir(cwd, repoRoot) {
     let dir = cwd;

package/dist/core/watch.d.ts

@@ -1,5 +1,5 @@
 import type { GitHandle } from "./git_helper.ts";
-import type { Issue, IssueProvider } from "./issues/provider.ts";
+import type { CodeHostProvider, Issue, IssueProvider } from "./issues/provider.ts";
 export interface ChainRunResult {
     accepted: boolean;
     adwId: string;
@@ -8,6 +8,7 @@ export interface ChainRunResult {
 }
 export interface WatchDeps {
     provider: IssueProvider;
+    codeHost: CodeHostProvider;
     git: GitHandle;
     /** Bound to a specific worktree path (diffFiles/push run there) — inject `git_helper.makeGit` for real use, a fake for tests. */
     worktreeGit: (worktreePath: string) => GitHandle;
@@ -16,6 +17,18 @@ export interface WatchDeps {
     baseBranch: string;
     concurrency: number;
     worktreesDir: string;
+    /**
+     * Symlink (or otherwise wire up) `<worktreePath>/.spf/data` to the MAIN
+     * repo's own persistent data_dir, called once per worktree right after
+     * it's created. Without this, a chain run's session/trace data resolves
+     * relative to `cwd` (the worktree — see ChainContext's doc comment) and
+     * lands in a fresh, throwaway `.spf/data` that `cleanupWorktree` deletes
+     * along with the rest of the worktree once the issue finishes: no trace
+     * in `spf ui`, and no trace anywhere at all after cleanup. Injected (not
+     * called directly) so watch.ts's own tests never touch the real
+     * filesystem for it.
+     */
+    linkDataDir: (worktreePath: string) => void;
     dryRun: boolean;
     runChain: (opts: {
         prompt: string;
@@ -25,7 +38,7 @@ export interface WatchDeps {
     log: (message: string) => void;
 }
 export interface WatchRunState {
-    inflight: Set<number>;
+    inflight: Set<string>;
 }
 export declare function createWatchState(): WatchRunState;
 export declare function branchNameFor(issue: Issue): string;

package/dist/core/watch.js

@@ -40,10 +40,13 @@ export function branchNameFor(issue) {
         .slice(0, 5)
         .join("-")
         .replace(/[^a-z0-9-]/g, "");
-    return `spf-watch/${issue.number}-${slug || "issue"}`.slice(0, 200);
+    // The issue's own id in the branch name isn't just labeling: Jira's
+    // Bitbucket integration auto-links a PR to the issue when its key
+    // appears anywhere in the branch name, no explicit API call needed.
+    return `spf-watch/${issue.id}-${slug || "issue"}`.slice(0, 200);
 }
 function worktreePathFor(deps, issue) {
-    return path.join(deps.worktreesDir, `issue-${issue.number}`);
+    return path.join(deps.worktreesDir, `issue-${issue.id}`);
 }
 function cleanupWorktree(deps, marker) {
     if (!marker)
@@ -67,13 +70,13 @@ function cleanupWorktree(deps, marker) {
 export async function reconcileOrphans(deps, state) {
     const working = await deps.provider.listInState("working");
     for (const issue of working) {
-        if (state.inflight.has(issue.number))
+        if (state.inflight.has(issue.id))
             continue;
         const marker = await deps.provider.readMarker(issue);
         if (marker?.pr) {
-            const status = await deps.provider.prStatus({ number: marker.pr, branch: marker.branch ?? "", url: "" });
+            const status = await deps.codeHost.prStatus({ number: marker.pr, branch: marker.branch ?? "", url: "" });
             if (status.state === "open" || status.merged) {
-                deps.log(`watch: #${issue.number} orphaned with an open/merged PR #${marker.pr} — resuming as review`);
+                deps.log(`watch: ${issue.id} orphaned with an open/merged PR #${marker.pr} — resuming as review`);
                 if (!deps.dryRun)
                     await deps.provider.transition(issue, "review");
                 continue;
@@ -81,14 +84,14 @@ export async function reconcileOrphans(deps, state) {
         }
         const attempt = (marker?.attempt ?? 0) + 1;
         if (attempt <= MAX_ORPHAN_ATTEMPTS) {
-            deps.log(`watch: #${issue.number} orphaned, retry ${attempt}/${MAX_ORPHAN_ATTEMPTS} — back to ready`);
+            deps.log(`watch: ${issue.id} orphaned, retry ${attempt}/${MAX_ORPHAN_ATTEMPTS} — back to ready`);
             if (!deps.dryRun) {
                 await deps.provider.writeMarker(issue, { ...marker, attempt });
                 await deps.provider.transition(issue, "ready");
             }
         }
         else {
-            deps.log(`watch: #${issue.number} orphaned past ${MAX_ORPHAN_ATTEMPTS} attempts — blocked`);
+            deps.log(`watch: ${issue.id} orphaned past ${MAX_ORPHAN_ATTEMPTS} attempts — blocked`);
             if (!deps.dryRun) {
                 await deps.provider.transition(issue, "blocked", `Gave up after ${MAX_ORPHAN_ATTEMPTS} orphaned attempts.`);
                 cleanupWorktree(deps, marker);
@@ -103,16 +106,16 @@ export async function finishReviews(deps) {
         const marker = await deps.provider.readMarker(issue);
         if (!marker?.pr)
             continue;
-        const status = await deps.provider.prStatus({ number: marker.pr, branch: marker.branch ?? "", url: "" });
+        const status = await deps.codeHost.prStatus({ number: marker.pr, branch: marker.branch ?? "", url: "" });
         if (status.merged) {
-            deps.log(`watch: #${issue.number}'s PR #${marker.pr} merged — done`);
+            deps.log(`watch: ${issue.id}'s PR #${marker.pr} merged — done`);
             if (!deps.dryRun) {
                 await deps.provider.transition(issue, "done");
                 cleanupWorktree(deps, marker);
             }
         }
         else if (status.state === "closed") {
-            deps.log(`watch: #${issue.number}'s PR #${marker.pr} closed without merging — blocked`);
+            deps.log(`watch: ${issue.id}'s PR #${marker.pr} closed without merging — blocked`);
             if (!deps.dryRun) {
                 await deps.provider.transition(issue, "blocked", `PR #${marker.pr} was closed without merging.`);
                 cleanupWorktree(deps, marker);
@@ -124,40 +127,56 @@ export async function finishReviews(deps) {
 async function runIssue(deps, issue) {
     const branch = branchNameFor(issue);
     const worktreePath = worktreePathFor(deps, issue);
-    const adwId = `issue-${issue.number}`;
+    const adwId = `issue-${issue.id}`;
     try {
+        // Both worktreePath and branch are fully deterministic from issue.id —
+        // the only way either could already exist is a previous spf watch
+        // attempt for THIS issue that never reached its own cleanup (killed
+        // mid-run, crashed, machine restart). `git worktree add -b` refuses
+        // outright if the branch already exists ("fatal: a branch named '...'
+        // already exists"), which without this would permanently block the
+        // issue from ever being claimed again — it'd fail this same way on
+        // every single retry. Safe to clear unconditionally: worktreeRemove/
+        // deleteLocalBranch are both no-ops if there's nothing to remove.
+        cleanupWorktree(deps, { worktree: worktreePath, branch });
         deps.git.fetch("origin", deps.baseBranch);
         deps.git.worktreeAdd(worktreePath, branch, `origin/${deps.baseBranch}`);
+        deps.linkDataDir(worktreePath);
         await deps.provider.writeMarker(issue, { worktree: worktreePath, branch, attempt: 0 });
         const prompt = `${issue.title}\n\n${issue.body}`.trim();
         const result = await deps.runChain({ prompt, cwd: worktreePath, adwId });
         if (!result.accepted) {
-            deps.log(`watch: #${issue.number}: chain "${deps.chain}" did not succeed — blocked`);
+            deps.log(`watch: ${issue.id}: chain "${deps.chain}" did not succeed — blocked`);
             await deps.provider.transition(issue, "blocked", result.detail || `Chain "${deps.chain}" (adw_id ${adwId}) did not complete successfully. Run \`spf phases ${adwId}\` for detail.`);
             cleanupWorktree(deps, { worktree: worktreePath, branch });
             return;
         }
         const wtGit = deps.worktreeGit(worktreePath);
         if (wtGit.diffFiles(`origin/${deps.baseBranch}`).length === 0) {
-            deps.log(`watch: #${issue.number}: chain succeeded but committed nothing — blocked`);
+            deps.log(`watch: ${issue.id}: chain succeeded but committed nothing — blocked`);
             await deps.provider.transition(issue, "blocked", `Chain "${deps.chain}" (adw_id ${adwId}) completed but left no committed changes.`);
             cleanupWorktree(deps, { worktree: worktreePath, branch });
             return;
         }
         wtGit.push("origin", branch);
-        const pr = await deps.provider.openPr(issue, {
+        // No cross-linking magic keyword here on purpose (a code host paired
+        // with a different tracker has no "Closes #n" convention to hook into
+        // — see provider.ts) — the issue id in the title/body is plain text
+        // for humans, and, on a Jira+Bitbucket pairing, exactly what Jira's own
+        // Bitbucket integration scans for to link the PR automatically.
+        const pr = await deps.codeHost.openPr({
             branch,
-            title: `${issue.title} (#${issue.number})`,
-            body: `Automated by \`spf watch\` — chain \`${deps.chain}\`, adw_id \`${adwId}\`.`,
+            title: `${issue.title} (${issue.id})`,
+            body: `Automated by \`spf watch\` — chain \`${deps.chain}\`, adw_id \`${adwId}\`, issue ${issue.id}.`,
             base: deps.baseBranch,
         });
         await deps.provider.writeMarker(issue, { worktree: worktreePath, branch, pr: pr.number, attempt: 0 });
         await deps.provider.transition(issue, "review");
-        deps.log(`watch: #${issue.number}: opened PR #${pr.number} — review`);
+        deps.log(`watch: ${issue.id}: opened PR #${pr.number} — review`);
     }
     catch (error) {
         const message = error.message;
-        deps.log(`watch: #${issue.number}: error: ${message}`);
+        deps.log(`watch: ${issue.id}: error: ${message}`);
         await deps.provider.transition(issue, "blocked", `spf watch error: ${message}`).catch(() => undefined);
         cleanupWorktree(deps, { worktree: worktreePath, branch });
     }
@@ -170,20 +189,20 @@ export async function claimNewWork(deps, state) {
     for (const issue of eligible) {
         if (state.inflight.size >= deps.concurrency)
             break;
-        if (state.inflight.has(issue.number))
+        if (state.inflight.has(issue.id))
             continue;
         if (deps.dryRun) {
-            deps.log(`watch: [dry-run] would claim #${issue.number} (${issue.title}) and run chain "${deps.chain}"`);
+            deps.log(`watch: [dry-run] would claim ${issue.id} (${issue.title}) and run chain "${deps.chain}"`);
             continue;
         }
         const claimed = await deps.provider.claim(issue);
         if (!claimed) {
-            deps.log(`watch: #${issue.number} lost the claim race this tick — skipping`);
+            deps.log(`watch: ${issue.id} lost the claim race this tick — skipping`);
             continue;
         }
-        deps.log(`watch: claimed #${issue.number}: ${issue.title}`);
-        state.inflight.add(issue.number);
-        runIssue(deps, issue).finally(() => state.inflight.delete(issue.number));
+        deps.log(`watch: claimed ${issue.id}: ${issue.title}`);
+        state.inflight.add(issue.id);
+        runIssue(deps, issue).finally(() => state.inflight.delete(issue.id));
     }
 }
 /** One poll tick: reconcile, finish, claim — each independently caught, so one phase's error never blocks the rest. */