@deftai/directive-runtime 0.126.0-beta.1 → 0.126.0-beta.3

package/vendor/directive-core/dist/value/feedback-file.js

@@ -3,12 +3,14 @@ import { resolve } from "node:path";
 import { isFrameworkRepoRoot } from "../check/orchestrator.js";
 import { policyColonInvocation } from "../policy/policy-invocation.js";
 import { isValueFeedbackPathAllowed, resolveValueFeedback } from "../policy/value-feedback.js";
-import { GhRestError, restCreateIssue, restIssueListPaginated, } from "../scm/gh-rest.js";
+import { GhRestError, REST_MAX_PER_PAGE, REST_PAGINATION_MAX_PAGES, REST_SHARED_ROW_BUDGET, restCreateIssue, restIssueListOpenInventory, restPostComment, runGhApi, splitRepo, } from "../scm/gh-rest.js";
 import { resolveProjectRoot } from "../scope/project-context.js";
 export const DEFAULT_UPSTREAM_REPO = "deftai/directive";
 export const FRAMEWORK_GAP_TITLE_PREFIX = "[framework-gap]";
 /** Sole sanctioned title classification (#3713). Does not write `adoption-blocker`. */
 export const ADOPTION_BLOCKER_TITLE_TOKEN = "BLOCKER";
+/** Retained closed-issue count window for feedback:file dedup (#5099 Prefer-A Recut-2). */
+export const FEEDBACK_CLOSED_DEDUP_WINDOW = Number.parseInt("500", 10);
 const FRAMEWORK_GAP_PREFIX_RE = /^\[framework-gap\]\s*/i;
 const BLOCKER_TITLE_TOKEN_RE = /^BLOCKER\b[:\s-]*/i;
 /** Strip source prefix and the optional BLOCKER token so marked/unmarked titles dedup. */
@@ -25,9 +27,27 @@ export function stripTitleClassificationTokens(title) {
 function sanitizeOneLine(value) {
     return value.replace(/\r?\n/g, " ").trim();
 }
+/**
+ * Fence free-text so line-leading `#` / `---` cannot break issue markdown (#4375).
+ * Indent those lines before insertion into structured sections.
+ */
+export function fenceFreeTextSection(value) {
+    return value
+        .split(/\r?\n/)
+        .map((line) => {
+        if (/^#{1,6}(\s|$)/.test(line) || /^---\s*$/.test(line)) {
+            return `    ${line}`;
+        }
+        return line;
+    })
+        .join("\n");
+}
 function sectionOrPlaceholder(value, placeholder) {
     const trimmed = value?.trim() ?? "";
-    return trimmed.length > 0 ? trimmed : placeholder;
+    if (trimmed.length === 0) {
+        return placeholder;
+    }
+    return fenceFreeTextSection(trimmed);
 }
 /** True when the resolved project root is the directive maintainer source checkout. */
 export function isMaintainerFrameworkRepo(projectRoot) {
@@ -81,9 +101,18 @@ function buildAdoptionImpactSection(input) {
         "",
     ];
 }
-/** Build the structured framework-gap issue body. */
-export function buildFrameworkGapBody(input) {
+/** Build the structured framework-gap issue or evidence-comment body. */
+export function buildFrameworkGapBody(input, options) {
     const summary = sanitizeOneLine(input.summary);
+    const mode = options?.mode ?? "issue";
+    const footer = mode === "comment"
+        ? "_Evidence appended via `deft feedback:file` from a directive consumer project (Refs #1709 value-feedback gap escalation)._"
+        : "_Filed via `deft feedback:file` from a directive consumer project (Refs #1709 value-feedback gap escalation)._";
+    const related = typeof options?.relatedClosedNumber === "number" &&
+        Number.isFinite(options.relatedClosedNumber) &&
+        options.relatedClosedNumber > 0
+        ? [`Related: closed #${options.relatedClosedNumber}`, ""]
+        : [];
     const lines = [
         "## Summary",
         "",
@@ -106,29 +135,213 @@ export function buildFrameworkGapBody(input) {
         sectionOrPlaceholder(input.sessionNotes, "_(not provided)_"),
         "",
         ...buildAdoptionImpactSection(input),
+        ...related,
         "---",
-        "_Filed via `task feedback:file` from a directive consumer project (Refs #1709 value-feedback gap escalation)._",
+        footer,
         "",
     ];
     return lines.join("\n");
 }
-/** Search open upstream issues for a normalized title match. */
+function matchTitleRow(row, needle) {
+    const issueTitle = typeof row.title === "string" ? row.title : "";
+    if (normalizeForDedup(issueTitle) !== needle) {
+        return null;
+    }
+    const url = typeof row.html_url === "string" ? row.html_url : "";
+    const state = typeof row.state === "string" ? row.state : "";
+    const number = row.number;
+    if (typeof number !== "number" ||
+        !Number.isFinite(number) ||
+        number <= 0 ||
+        !Number.isInteger(number) ||
+        url.length === 0 ||
+        state.length === 0) {
+        return "malformed";
+    }
+    return { number, state, url, title: issueTitle };
+}
+function fetchClosedIssuePage(repo, page, perPage, seams) {
+    const [owner, name] = splitRepo(repo);
+    const endpoint = `repos/${owner}/${name}/issues`;
+    const runner = seams.runGhApiFn ?? runGhApi;
+    const args = [
+        endpoint,
+        "--method",
+        "GET",
+        "--raw-field",
+        "state=closed",
+        "--raw-field",
+        "sort=updated",
+        "--raw-field",
+        "direction=desc",
+        "--raw-field",
+        `per_page=${perPage}`,
+        "--raw-field",
+        `page=${page}`,
+    ];
+    const result = runner(args, { whichFn: seams.whichFn });
+    if (result.returncode !== 0) {
+        const detail = result.stderr.trim();
+        return {
+            ok: false,
+            message: detail.length > 0
+                ? detail
+                : `closed-issue walk gh exit ${String(result.returncode)} (${endpoint})`,
+        };
+    }
+    const stdout = result.stdout.trim();
+    if (stdout.length === 0) {
+        return { ok: true, rows: [] };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(stdout);
+    }
+    catch (exc) {
+        const message = exc instanceof Error ? exc.message : String(exc);
+        return { ok: false, message: `non-JSON closed-issue page: ${message}` };
+    }
+    if (!Array.isArray(parsed)) {
+        return {
+            ok: false,
+            message: `unexpected top-level type ${typeof parsed}`,
+        };
+    }
+    return { ok: true, rows: parsed };
+}
+/**
+ * Closed-issue sibling of `restWalkClosedPullsUpdatedDesc` for feedback:file dedup (#5099).
+ * Retained-count window; pull rows consume raw budget but are excluded from match/count.
+ */
+export function walkClosedIssuesForFeedbackDedup(repo, title, options = {}, seams = {}) {
+    const needle = normalizeForDedup(title);
+    if (needle.length === 0) {
+        return {
+            outcome: "list-exhausted",
+            inspectedIssueCount: 0,
+            rawRows: 0,
+            match: null,
+            malformedMatch: false,
+        };
+    }
+    const window = Math.max(1, options.window ?? FEEDBACK_CLOSED_DEDUP_WINDOW);
+    const cappedPerPage = Math.min(Math.max(1, options.perPage ?? REST_MAX_PER_PAGE), REST_MAX_PER_PAGE);
+    const budget = Math.max(0, options.remainingBudget ?? REST_SHARED_ROW_BUDGET);
+    let rawRows = 0;
+    let inspectedIssueCount = 0;
+    for (let page = 1; page <= REST_PAGINATION_MAX_PAGES; page += 1) {
+        if (rawRows >= budget) {
+            return {
+                outcome: "cap",
+                inspectedIssueCount,
+                rawRows,
+                match: null,
+                malformedMatch: false,
+            };
+        }
+        const pageResult = fetchClosedIssuePage(repo, page, cappedPerPage, seams);
+        if (!pageResult.ok) {
+            return {
+                outcome: "error",
+                inspectedIssueCount,
+                rawRows,
+                match: null,
+                malformedMatch: false,
+                errorMessage: pageResult.message,
+            };
+        }
+        const pagePayload = pageResult.rows;
+        if (pagePayload.length === 0) {
+            return {
+                outcome: "list-exhausted",
+                inspectedIssueCount,
+                rawRows,
+                match: null,
+                malformedMatch: false,
+            };
+        }
+        for (const item of pagePayload) {
+            if (rawRows >= budget) {
+                return {
+                    outcome: "cap",
+                    inspectedIssueCount,
+                    rawRows,
+                    match: null,
+                    malformedMatch: false,
+                };
+            }
+            rawRows += 1;
+            if ("pull_request" in item) {
+                continue;
+            }
+            inspectedIssueCount += 1;
+            const matched = matchTitleRow(item, needle);
+            if (matched === "malformed") {
+                return {
+                    outcome: "error",
+                    inspectedIssueCount,
+                    rawRows,
+                    match: null,
+                    malformedMatch: true,
+                    errorMessage: "closed-issue title match lacks usable numeric number/state/url",
+                };
+            }
+            if (matched !== null) {
+                return {
+                    outcome: "list-exhausted",
+                    inspectedIssueCount,
+                    rawRows,
+                    match: matched,
+                    malformedMatch: false,
+                };
+            }
+            if (inspectedIssueCount >= window) {
+                return {
+                    outcome: "window-exhausted",
+                    inspectedIssueCount,
+                    rawRows,
+                    match: null,
+                    malformedMatch: false,
+                };
+            }
+        }
+        if (pagePayload.length < cappedPerPage) {
+            return {
+                outcome: "list-exhausted",
+                inspectedIssueCount,
+                rawRows,
+                match: null,
+                malformedMatch: false,
+            };
+        }
+    }
+    return {
+        outcome: "cap",
+        inspectedIssueCount,
+        rawRows,
+        match: null,
+        malformedMatch: false,
+    };
+}
 export function findDuplicateIssue(repo, title, seams = {}) {
     const needle = normalizeForDedup(title);
     if (needle.length === 0) {
-        return null;
+        return { ok: true, match: null };
     }
-    const issues = restIssueListPaginated(repo, { state: "open", limit: 100, excludePulls: true }, seams);
+    const issues = restIssueListOpenInventory(repo, seams);
     for (const issue of issues) {
-        const issueTitle = typeof issue.title === "string" ? issue.title : "";
-        if (normalizeForDedup(issueTitle) === needle) {
-            const url = typeof issue.html_url === "string" ? issue.html_url : "";
-            if (url.length > 0) {
-                return { url, title: issueTitle };
-            }
+        const matched = matchTitleRow(issue, needle);
+        if (matched === "malformed") {
+            return {
+                ok: false,
+                error: "open-issue title match lacks usable numeric number/state/url",
+            };
+        }
+        if (matched !== null) {
+            return { ok: true, match: matched };
         }
     }
-    return null;
+    return { ok: true, match: null };
 }
 function resolveRepo(options) {
     const explicit = options.repo?.trim();
@@ -147,7 +360,40 @@ function buildConfirmationPrompt(title, body) {
         `${body}\n` +
         "Re-run with --confirm to file this issue upstream after reviewing the draft.\n");
 }
-/** Core feedback:file workflow (#1709 gap escalation). */
+function buildOpenMatchPreview(match, commentBody) {
+    return (`[deft feedback] Open duplicate: ${match.url} ("${match.title}").\n` +
+        "Proposed evidence comment (not posted):\n\n" +
+        `${commentBody}\n` +
+        "Re-run with --confirm to append this evidence as a comment (never creates a new issue).\n");
+}
+function buildClosedMatchBlock(match) {
+    return (`[deft feedback] Closed duplicate: ${match.url} ("${match.title}").\n` +
+        "Re-run with an explicit disposition before any write:\n" +
+        "  --on-closed=comment        append evidence on the closed issue (no reopen)\n" +
+        "  --on-closed=create-anyway  create a new issue with Related: closed #<n>\n");
+}
+function incompleteClosedSearchNote(stopReason, inspectedIssueCount, boundary) {
+    if (stopReason === "window-exhausted") {
+        return (`[deft feedback] Note: closed-issue search incomplete ` +
+            `(stopReason=window-exhausted, inspectedIssueCount=${inspectedIssueCount}, window=${boundary}).\n`);
+    }
+    return (`[deft feedback] Note: closed-issue search incomplete ` +
+        `(stopReason=cap, inspectedIssueCount=${inspectedIssueCount}, budget=${boundary}).\n`);
+}
+function extractCommentUrl(repo, issueNumber, created) {
+    if (typeof created.html_url === "string" && created.html_url.length > 0) {
+        return created.html_url;
+    }
+    const id = created.id;
+    if (typeof id === "number" && Number.isFinite(id)) {
+        return `https://github.com/${repo}/issues/${issueNumber}#issuecomment-${id}`;
+    }
+    return null;
+}
+function mutationsAllowed(options, offline, dryRun) {
+    return options.confirm === true && !dryRun && !offline;
+}
+/** Core feedback:file workflow (#1709 / #5099 Prefer-A Recut-2). */
 export function runFeedbackFile(options) {
     const summary = sanitizeOneLine(options.summary);
     if (summary.length === 0) {
@@ -174,60 +420,218 @@ export function runFeedbackFile(options) {
     const projectRoot = resolve(projectRootRaw);
     const repo = resolveRepo(options);
     const title = buildFrameworkGapTitle(summary, { adoptionBlocker: options.adoptionBlocker });
-    const body = buildFrameworkGapBody(options);
+    const issueBody = buildFrameworkGapBody(options);
+    const commentBody = buildFrameworkGapBody(options, { mode: "comment" });
     if (isMaintainerFrameworkRepo(projectRoot)) {
         return {
             outcome: "skipped-maintainer",
             exitCode: 0,
             title,
-            body,
+            body: issueBody,
             repo,
             message: "[deft feedback] Skipped: maintainer framework repo detected; gap escalation targets consumer projects only.\n",
         };
     }
     const policy = resolveValueFeedback(projectRoot);
     if (!isValueFeedbackPathAllowed("upstreamPrompt", policy)) {
+        const readout = options.dryRun === true || options.json === true
+            ? `${buildConfirmationPrompt(title, issueBody)}\n`
+            : "";
         return {
             outcome: "blocked-policy",
             exitCode: 1,
             title,
-            body,
+            body: issueBody,
             repo,
             message: "[deft feedback] Blocked: plan.policy.valueFeedback upstreamPrompt is OFF. " +
-                `Enable with \`${policyColonInvocation("enable-value-feedback", " -- --confirm")}\` and set upstreamPrompt, ` +
-                `or inspect via \`${policyColonInvocation("show", " --field=valueFeedback")}\`.\n`,
+                `Enable with \`${policyColonInvocation("enable-value-feedback", " -- --confirm --upstream-prompt")}\`, ` +
+                `or inspect via \`${policyColonInvocation("show", " --field=valueFeedback")}\`.\n` +
+                readout,
         };
     }
     const offline = isOffline();
     const dryRun = options.dryRun ?? false;
     const seams = options.seams ?? {};
     let dedupSkippedNote = "";
+    let incompleteNote = "";
+    let createBody = issueBody;
     if (!offline) {
         try {
-            const duplicate = findDuplicateIssue(repo, title, seams);
-            if (duplicate !== null) {
+            const openSearch = findDuplicateIssue(repo, title, seams);
+            if (!openSearch.ok) {
                 return {
-                    outcome: "blocked-duplicate",
-                    exitCode: 1,
+                    outcome: "error-network",
+                    exitCode: 2,
                     title,
-                    body,
+                    body: issueBody,
                     repo,
-                    duplicateUrl: duplicate.url,
-                    message: `[deft feedback] Duplicate detected: open issue ${duplicate.url} ` +
-                        `("${duplicate.title}") matches this report.\n`,
+                    message: networkErrorMessage("Open-issue inventory / duplicate search failed", openSearch.error),
                 };
             }
+            const openMatch = openSearch.match;
+            if (openMatch !== null) {
+                if (!options.confirm) {
+                    return {
+                        outcome: "draft",
+                        exitCode: 1,
+                        title,
+                        body: commentBody,
+                        repo,
+                        duplicateUrl: openMatch.url,
+                        issueUrl: openMatch.url,
+                        message: buildOpenMatchPreview(openMatch, commentBody),
+                    };
+                }
+                if (!mutationsAllowed(options, offline, dryRun)) {
+                    return {
+                        outcome: "draft",
+                        exitCode: 0,
+                        title,
+                        body: commentBody,
+                        repo,
+                        duplicateUrl: openMatch.url,
+                        issueUrl: openMatch.url,
+                        message: `[deft feedback] Dry run: would comment on open duplicate ${openMatch.url}.\n` +
+                            `${buildOpenMatchPreview(openMatch, commentBody)}`,
+                    };
+                }
+                try {
+                    const created = restPostComment(repo, openMatch.number, commentBody, seams);
+                    const commentUrl = extractCommentUrl(repo, openMatch.number, created);
+                    return {
+                        outcome: "commented-open-duplicate",
+                        exitCode: 0,
+                        title,
+                        body: commentBody,
+                        repo,
+                        issueUrl: openMatch.url,
+                        duplicateUrl: openMatch.url,
+                        commentUrl,
+                        message: commentUrl !== null
+                            ? `[deft feedback] Commented on open duplicate ${openMatch.url}\nComment: ${commentUrl}\n`
+                            : `[deft feedback] Commented on open duplicate ${openMatch.url}\n`,
+                    };
+                }
+                catch (err) {
+                    return {
+                        outcome: "error-network",
+                        exitCode: 2,
+                        title,
+                        body: commentBody,
+                        repo,
+                        duplicateUrl: openMatch.url,
+                        message: networkErrorMessage("Open-duplicate comment failed", err),
+                    };
+                }
+            }
         }
         catch (err) {
             return {
                 outcome: "error-network",
                 exitCode: 2,
                 title,
-                body,
+                body: issueBody,
                 repo,
-                message: networkErrorMessage("Duplicate search failed", err),
+                message: networkErrorMessage("Open-issue inventory / duplicate search failed", err),
             };
         }
+        const closedWalk = walkClosedIssuesForFeedbackDedup(repo, title, {
+            window: options.closedWindow,
+            remainingBudget: options.closedRowBudget,
+        }, seams);
+        if (closedWalk.malformedMatch || closedWalk.outcome === "error") {
+            return {
+                outcome: "error-network",
+                exitCode: 2,
+                title,
+                body: issueBody,
+                repo,
+                message: networkErrorMessage("Closed-issue search failed", closedWalk.errorMessage ?? "closed walk error"),
+            };
+        }
+        if (closedWalk.match !== null) {
+            const closedMatch = closedWalk.match;
+            if (options.onClosed === undefined) {
+                return {
+                    outcome: "blocked-closed-duplicate",
+                    exitCode: 1,
+                    title,
+                    body: issueBody,
+                    repo,
+                    duplicateUrl: closedMatch.url,
+                    issueUrl: closedMatch.url,
+                    message: buildClosedMatchBlock(closedMatch),
+                };
+            }
+            if (options.onClosed === "comment") {
+                if (!options.confirm) {
+                    return {
+                        outcome: "draft",
+                        exitCode: 1,
+                        title,
+                        body: commentBody,
+                        repo,
+                        duplicateUrl: closedMatch.url,
+                        issueUrl: closedMatch.url,
+                        message: buildClosedMatchBlock(closedMatch) +
+                            "\nProposed evidence comment (not posted):\n\n" +
+                            `${commentBody}\n` +
+                            "Re-run with --confirm --on-closed=comment to append evidence (no reopen).\n",
+                    };
+                }
+                if (!mutationsAllowed(options, offline, dryRun)) {
+                    return {
+                        outcome: "draft",
+                        exitCode: 0,
+                        title,
+                        body: commentBody,
+                        repo,
+                        duplicateUrl: closedMatch.url,
+                        issueUrl: closedMatch.url,
+                        message: `[deft feedback] Dry run: would comment on closed duplicate ${closedMatch.url} (no reopen).\n` +
+                            `${commentBody}\n`,
+                    };
+                }
+                try {
+                    const created = restPostComment(repo, closedMatch.number, commentBody, seams);
+                    const commentUrl = extractCommentUrl(repo, closedMatch.number, created);
+                    return {
+                        outcome: "commented-open-duplicate",
+                        exitCode: 0,
+                        title,
+                        body: commentBody,
+                        repo,
+                        issueUrl: closedMatch.url,
+                        duplicateUrl: closedMatch.url,
+                        commentUrl,
+                        message: commentUrl !== null
+                            ? `[deft feedback] Commented on closed duplicate ${closedMatch.url} (no reopen)\nComment: ${commentUrl}\n`
+                            : `[deft feedback] Commented on closed duplicate ${closedMatch.url} (no reopen)\n`,
+                    };
+                }
+                catch (err) {
+                    return {
+                        outcome: "error-network",
+                        exitCode: 2,
+                        title,
+                        body: commentBody,
+                        repo,
+                        duplicateUrl: closedMatch.url,
+                        message: networkErrorMessage("Closed-duplicate comment failed", err),
+                    };
+                }
+            }
+            createBody = buildFrameworkGapBody(options, {
+                mode: "issue",
+                relatedClosedNumber: closedMatch.number,
+            });
+        }
+        else if (closedWalk.outcome === "window-exhausted") {
+            incompleteNote = incompleteClosedSearchNote("window-exhausted", closedWalk.inspectedIssueCount, options.closedWindow ?? FEEDBACK_CLOSED_DEDUP_WINDOW);
+        }
+        else if (closedWalk.outcome === "cap") {
+            incompleteNote = incompleteClosedSearchNote("cap", closedWalk.inspectedIssueCount, options.closedRowBudget ?? REST_SHARED_ROW_BUDGET);
+        }
     }
     else {
         dedupSkippedNote = "[deft feedback] Note: duplicate detection skipped (DEFT_NO_NETWORK=1).\n\n";
@@ -237,24 +641,24 @@ export function runFeedbackFile(options) {
             outcome: "draft",
             exitCode: 1,
             title,
-            body,
+            body: createBody,
             repo,
-            message: `${dedupSkippedNote}${buildConfirmationPrompt(title, body)}`,
+            message: `${dedupSkippedNote}${incompleteNote}${buildConfirmationPrompt(title, createBody)}`,
         };
     }
-    if (dryRun || offline) {
+    if (!mutationsAllowed(options, offline, dryRun)) {
         return {
             outcome: "draft",
             exitCode: 0,
             title,
-            body,
+            body: createBody,
             repo,
-            message: `${dedupSkippedNote}[deft feedback] Dry run: would file upstream issue in ${repo}.\n` +
-                `${buildConfirmationPrompt(title, body)}`,
+            message: `${dedupSkippedNote}${incompleteNote}[deft feedback] Dry run: would file upstream issue in ${repo}.\n` +
+                `${buildConfirmationPrompt(title, createBody)}`,
         };
     }
     try {
-        const created = restCreateIssue(repo, title, body, [], seams);
+        const created = restCreateIssue(repo, title, createBody, [], seams);
         const issueUrl = typeof created.html_url === "string" && created.html_url.length > 0 ? created.html_url : null;
         const number = created.number;
         const urlLine = issueUrl ??
@@ -263,12 +667,13 @@ export function runFeedbackFile(options) {
             outcome: "filed",
             exitCode: 0,
             title,
-            body,
+            body: createBody,
             repo,
             issueUrl: urlLine,
-            message: urlLine !== null
-                ? `[deft feedback] Filed upstream issue: ${urlLine}\n`
-                : "[deft feedback] Issue filed upstream (URL unavailable in API response).\n",
+            message: `${incompleteNote}` +
+                (urlLine !== null
+                    ? `[deft feedback] Filed upstream issue: ${urlLine}\n`
+                    : "[deft feedback] Issue filed upstream (URL unavailable in API response).\n"),
         };
     }
     catch (err) {
@@ -276,7 +681,7 @@ export function runFeedbackFile(options) {
             outcome: "error-network",
             exitCode: 2,
             title,
-            body,
+            body: createBody,
             repo,
             message: networkErrorMessage("Upstream filing failed", err),
         };
@@ -288,6 +693,12 @@ function appendContextValue(collected, value) {
     if (typeof value === "string")
         collected.push(value);
 }
+function parseOnClosedValue(value) {
+    if (value === "comment" || value === "create-anyway") {
+        return value;
+    }
+    return "bad";
+}
 /** Parse argv for feedback:file. */
 export function parseFeedbackFileArgs(argv) {
     const out = {};
@@ -357,6 +768,20 @@ export function parseFeedbackFileArgs(argv) {
         else if (arg?.startsWith("--recovery-cost=")) {
             out.recoveryCost = arg.slice("--recovery-cost=".length);
         }
+        else if (arg === "--on-closed") {
+            const parsed = parseOnClosedValue(argv[++i]);
+            if (parsed === "bad") {
+                return { ...out, error: "invalid --on-closed value (expected comment|create-anyway)" };
+            }
+            out.onClosed = parsed;
+        }
+        else if (arg?.startsWith("--on-closed=")) {
+            const parsed = parseOnClosedValue(arg.slice("--on-closed=".length));
+            if (parsed === "bad") {
+                return { ...out, error: "invalid --on-closed value (expected comment|create-anyway)" };
+            }
+            out.onClosed = parsed;
+        }
         else if (arg === "--repo") {
             out.repo = argv[++i];
         }
@@ -404,6 +829,7 @@ export function feedbackFileMain(argv) {
         confirm: args.confirm,
         dryRun: args.dryRun,
         json: args.json,
+        onClosed: args.onClosed,
         repo: args.repo,
         projectRoot: args.projectRoot,
     });
@@ -415,6 +841,7 @@ export function feedbackFileMain(argv) {
             body: result.body,
             repo: result.repo,
             issue_url: result.issueUrl ?? null,
+            comment_url: result.commentUrl ?? null,
             duplicate_url: result.duplicateUrl ?? null,
             message: result.message.trim(),
         }, null, 2)}\n`);