@deftai/directive-core 0.103.0 → 0.105.0

package/dist/vbrief-reconcile/origin-freshness.js

@@ -0,0 +1,221 @@
+import { extractReferencesFromVbrief, GITHUB_ISSUE_REF_TYPES, parseIssueNumber, } from "../intake/reconcile-issues.js";
+import { call } from "../scm/call.js";
+const ISSUE_URL_PATTERN = /https:\/\/github\.com\/([^/\s]+)\/([^/\s]+)\/issues\/(\d+)/g;
+const ISSUE_API_URL_PATTERN = /https:\/\/api\.github\.com\/repos\/([^/\s]+)\/([^/\s]+)\/issues\/(\d+)/g;
+export const ORIGIN_FRESHNESS_REMEDIATION = "Re-read the issue body and comments (#2143), then either refresh the brief or record intentional divergence and bump xBRIEFInfo.updated. Do not auto-write origin text onto the brief (#309 D12).";
+export function briefUpdatedOf(payload) {
+    const info = payload.xBRIEFInfo;
+    if (info !== null && typeof info === "object" && !Array.isArray(info)) {
+        const updated = info.updated;
+        if (typeof updated === "string" && updated.trim().length > 0) {
+            return updated.trim();
+        }
+    }
+    const plan = payload.plan;
+    if (plan !== null && typeof plan === "object" && !Array.isArray(plan)) {
+        const updated = plan.updated;
+        if (typeof updated === "string" && updated.trim().length > 0) {
+            return updated.trim();
+        }
+    }
+    return null;
+}
+export function extractGithubIssueOrigins(payload) {
+    const origins = [];
+    const seen = new Set();
+    const add = (origin) => {
+        const key = `${origin.owner}/${origin.repo}#${origin.number}`;
+        if (seen.has(key)) {
+            return;
+        }
+        seen.add(key);
+        origins.push(origin);
+    };
+    for (const rec of extractReferencesFromVbrief(payload)) {
+        const type = String(rec.type ?? "");
+        if (!GITHUB_ISSUE_REF_TYPES.has(type)) {
+            continue;
+        }
+        const fromUri = originFromUri(rec);
+        let origin = fromUri !== null ? { ...fromUri, type } : null;
+        if (origin === null) {
+            const number = parseIssueNumber(rec);
+            if (number === null) {
+                continue;
+            }
+            origin = {
+                owner: "",
+                repo: "",
+                number,
+                uri: typeof rec.uri === "string" ? rec.uri : "",
+                type,
+            };
+        }
+        add(origin);
+    }
+    for (const text of textualOriginFields(payload)) {
+        for (const fromText of originsFromText(text)) {
+            add({ ...fromText, type: "x-xbrief/github-issue" });
+        }
+    }
+    return origins;
+}
+export function extractGithubIssueOrigin(payload) {
+    return extractGithubIssueOrigins(payload)[0] ?? null;
+}
+function originFromUri(ref) {
+    for (const key of ["uri", "url"]) {
+        const value = ref[key];
+        if (typeof value !== "string" || value.length === 0) {
+            continue;
+        }
+        const parsed = originFromText(value);
+        if (parsed !== null) {
+            return parsed;
+        }
+    }
+    return null;
+}
+function originsFromText(text) {
+    const origins = [];
+    const seen = new Set();
+    for (const pattern of [ISSUE_URL_PATTERN, ISSUE_API_URL_PATTERN]) {
+        for (const match of text.matchAll(pattern)) {
+            if (!match[1] || !match[2] || !match[3]) {
+                continue;
+            }
+            const owner = match[1];
+            const repo = match[2];
+            const number = Number.parseInt(match[3], 10);
+            const key = `${owner}/${repo}#${number}`;
+            if (seen.has(key)) {
+                continue;
+            }
+            seen.add(key);
+            origins.push({
+                owner,
+                repo,
+                number,
+                uri: `https://github.com/${owner}/${repo}/issues/${number}`,
+            });
+        }
+    }
+    return origins;
+}
+function originFromText(text) {
+    return originsFromText(text)[0] ?? null;
+}
+function textualOriginFields(payload) {
+    const texts = [];
+    const plan = payload.plan;
+    if (plan !== null && typeof plan === "object" && !Array.isArray(plan)) {
+        const narratives = plan.narratives;
+        if (narratives !== null && typeof narratives === "object" && !Array.isArray(narratives)) {
+            const origin = narratives.Origin;
+            if (typeof origin === "string" && origin.length > 0) {
+                texts.push(origin);
+            }
+        }
+    }
+    for (const key of ["xBRIEFInfo", "vBRIEFInfo"]) {
+        const info = payload[key];
+        if (info !== null && typeof info === "object" && !Array.isArray(info)) {
+            const description = info.description;
+            if (typeof description === "string" && description.length > 0) {
+                texts.push(description);
+            }
+        }
+    }
+    return texts;
+}
+export function compareOriginFreshness(briefUpdated, originUpdatedAt) {
+    if (originUpdatedAt === null || originUpdatedAt.trim().length === 0) {
+        return "uncomparable";
+    }
+    if (briefUpdated === null || briefUpdated.trim().length === 0) {
+        return "stale";
+    }
+    const briefMs = Date.parse(briefUpdated);
+    const originMs = Date.parse(originUpdatedAt);
+    if (Number.isNaN(briefMs) || Number.isNaN(originMs)) {
+        return "uncomparable";
+    }
+    return originMs > briefMs ? "stale" : "current";
+}
+export function formatOriginStaleMessage(origin, originUpdatedAt, briefUpdated) {
+    const slug = origin.owner.length > 0 ? `${origin.owner}/${origin.repo}` : "origin";
+    const briefStamp = briefUpdated ?? "(missing)";
+    return (`Origin GitHub issue #${origin.number} (${slug}) is newer than this xBRIEF ` +
+        `(origin updated_at=${originUpdatedAt}, brief updated=${briefStamp}). ` +
+        ORIGIN_FRESHNESS_REMEDIATION);
+}
+export function fetchGithubIssueUpdatedAt(origin, options = {}) {
+    if (origin.owner.length === 0 || origin.repo.length === 0) {
+        return { error: "origin reference is missing owner/repo in the GitHub issue URI" };
+    }
+    const scmCall = options.scmCall ?? call;
+    let result;
+    try {
+        result = scmCall("github-issue", "api", [`repos/${origin.owner}/${origin.repo}/issues/${origin.number}`], { timeout: 30, cwd: options.cwd });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { error: `gh CLI not available (${message})` };
+    }
+    if (result.returncode !== 0) {
+        const stderr = result.stderr.trim();
+        return { error: stderr.length > 0 ? stderr : `gh api exited ${result.returncode}` };
+    }
+    try {
+        const payload = JSON.parse(result.stdout);
+        const updatedAt = payload.updated_at;
+        if (typeof updatedAt !== "string" || updatedAt.trim().length === 0) {
+            return { error: "origin issue payload lacks updated_at" };
+        }
+        return { updatedAt: updatedAt.trim() };
+    }
+    catch {
+        return { error: "origin issue payload is not valid JSON" };
+    }
+}
+export function evaluateOriginFreshness(payload, options = {}) {
+    if (options.skip === true) {
+        return { ok: true, kind: "no-origin" };
+    }
+    const origins = extractGithubIssueOrigins(payload);
+    if (origins.length === 0) {
+        return { ok: true, kind: "no-origin" };
+    }
+    const fetch = options.fetchOriginUpdatedAt ??
+        ((next) => fetchGithubIssueUpdatedAt(next, { cwd: options.cwd }));
+    const briefUpdated = briefUpdatedOf(payload);
+    for (const origin of origins) {
+        const fetched = fetch(origin);
+        if ("error" in fetched) {
+            return {
+                ok: false,
+                kind: "uncomparable",
+                message: `Could not fetch origin GitHub issue #${origin.number} for freshness check: ${fetched.error}. ` +
+                    ORIGIN_FRESHNESS_REMEDIATION,
+            };
+        }
+        const kind = compareOriginFreshness(briefUpdated, fetched.updatedAt);
+        if (kind === "stale") {
+            return {
+                ok: false,
+                kind,
+                message: formatOriginStaleMessage(origin, fetched.updatedAt, briefUpdated),
+            };
+        }
+        if (kind === "uncomparable") {
+            return {
+                ok: false,
+                kind,
+                message: `Could not compare origin GitHub issue #${origin.number} updated_at=${fetched.updatedAt} ` +
+                    `to brief updated=${briefUpdated ?? "(missing)"}. ${ORIGIN_FRESHNESS_REMEDIATION}`,
+            };
+        }
+    }
+    return { ok: true, kind: "current" };
+}
+//# sourceMappingURL=origin-freshness.js.map

package/dist/vbrief-reconcile/types.d.ts

@@ -54,6 +54,11 @@ export interface Candidate {
 }
 export interface ReconcileGraphOutcome {
     promoted: string[];
+    /** Successful promote messages, including refused-stamp remediation (#3398). */
+    promotedNotices?: Array<{
+        story_id: string;
+        message: string;
+    }>;
     deferredWip: string[];
     waiting: Array<{
         story_id: string;
@@ -110,6 +115,12 @@ export interface UmbrellaChange {
      * `unchanged` when already correct, `skipped` when body APIs unavailable.
      */
     readonly checklist_action?: "edited" | "unchanged" | "skipped";
+    /**
+     * slices.jsonl expected_close_signal close (#3428): `closed` when the
+     * umbrella was closed this run, `unchanged` when already closed under
+     * all-children-merged, `skipped` when the signal is not a close.
+     */
+    readonly close_action?: "closed" | "unchanged" | "skipped";
 }
 export interface ReconcileUmbrellasOutcome {
     changed: UmbrellaChange[];
@@ -138,5 +149,7 @@ export interface UmbrellaClient {
     fetchIssueBody?(repo: string, issueNumber: number): string;
     /** Optional: write reconciled checklist body (#1649). */
     editIssueBody?(repo: string, issueNumber: number, body: string): void;
+    /** Optional: close an umbrella via REST (#3428). */
+    closeIssue?(repo: string, issueNumber: number): void;
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/vbrief-reconcile/umbrellas.d.ts

@@ -63,8 +63,22 @@ export declare class ScmUmbrellaClient implements UmbrellaClient {
     fetchIssueStates(repo: string, issueNumbers: readonly number[]): ReadonlyMap<number, ForgeIssueState>;
     fetchIssueBody(repo: string, issueNumber: number): string;
     editIssueBody(repo: string, issueNumber: number, body: string): void;
+    closeIssue(repo: string, issueNumber: number): void;
 }
 export declare function nowIso(date?: Date): string;
+/** Children listed on a slices.jsonl row (#3428). Last write of a duplicate `n` wins. */
+export declare function childrenFromSliceRecord(record: Record<string, unknown>): Child[];
+/**
+ * Close only when the slice signal is all-children-merged, the umbrella is
+ * still open, and every child has forge state closed (#3428).
+ */
+export declare function shouldCloseOnAllChildrenMerged(options: {
+    readonly signal: unknown;
+    readonly children: readonly Child[];
+    readonly forgeStates: ReadonlyMap<number, ForgeIssueState> | null | undefined;
+    readonly umbrellaState: ForgeIssueState | null | undefined;
+}): boolean;
+export declare function formatCloseComment(signal: string, children: readonly Child[]): string;
 export interface ReconcileUmbrellasOptions {
     readonly repo?: string | null;
     readonly dryRun?: boolean;

package/dist/vbrief-reconcile/umbrellas.js

@@ -5,6 +5,8 @@ import { createIssueComment, editIssueBody, editIssueCommentBody, fetchIssueBody
 import { fetchIssueStates, IssueState } from "../intake/reconcile-issues.js";
 import { hasArtifactSuffix, resolveLifecycleRoot, stripArtifactSuffix } from "../layout/resolve.js";
 import { call } from "../scm/call.js";
+import { restCloseIssue } from "../scm/gh-rest.js";
+import { readAll } from "../slice/record.js";
 import { extractIssueRef, parseGithubIssueUri } from "../triage/reconcile/parse-uri.js";
 import { isRepoMutationAllowed } from "./repo-guard.js";
 export const OPEN_FOLDERS = ["proposed", "pending", "active"];
@@ -307,33 +309,43 @@ export function classifyPassType(prevTotal, total) {
 function hasCurrentShape(body) {
     return HEADER_RE.test(body);
 }
+function parseCommentPage(data) {
+    if (!Array.isArray(data))
+        return [];
+    const comments = [];
+    for (const entry of data) {
+        if (typeof entry === "object" &&
+            entry !== null &&
+            !Array.isArray(entry) &&
+            typeof entry.id === "number" &&
+            typeof entry.body === "string") {
+            const rec = entry;
+            comments.push({ id: rec.id, body: rec.body });
+        }
+    }
+    return comments;
+}
 export class ScmUmbrellaClient {
     fetchComments(repo, issueNumber) {
-        const proc = call(SCM_SOURCE, "api", [
-            `repos/${repo}/issues/${issueNumber}/comments?per_page=100`,
-        ]);
-        if (proc.returncode !== 0) {
-            throw new UmbrellaScmError(`list comments #${issueNumber} (${repo}) failed: ${(proc.stderr || "").trim()}`);
-        }
-        let data;
-        try {
-            data = JSON.parse(proc.stdout || "[]");
-        }
-        catch (exc) {
-            throw new UmbrellaScmError(`list comments #${issueNumber} (${repo}) returned non-JSON: ${String(exc)}`);
-        }
-        if (!Array.isArray(data))
-            return [];
         const comments = [];
-        for (const entry of data) {
-            if (typeof entry === "object" &&
-                entry !== null &&
-                !Array.isArray(entry) &&
-                typeof entry.id === "number" &&
-                typeof entry.body === "string") {
-                const rec = entry;
-                comments.push({ id: rec.id, body: rec.body });
+        for (let page = 1; page <= 50; page += 1) {
+            const proc = call(SCM_SOURCE, "api", [
+                `repos/${repo}/issues/${issueNumber}/comments?per_page=100&page=${page}`,
+            ]);
+            if (proc.returncode !== 0) {
+                throw new UmbrellaScmError(`list comments #${issueNumber} (${repo}) failed: ${(proc.stderr || "").trim()}`);
+            }
+            let data;
+            try {
+                data = JSON.parse(proc.stdout || "[]");
+            }
+            catch (exc) {
+                throw new UmbrellaScmError(`list comments #${issueNumber} (${repo}) returned non-JSON: ${String(exc)}`);
             }
+            const batch = parseCommentPage(data);
+            comments.push(...batch);
+            if (batch.length < 100)
+                break;
         }
         return comments;
     }
@@ -394,6 +406,15 @@ export class ScmUmbrellaClient {
             throw new UmbrellaScmError(`edit issue body #${issueNumber} (${repo}) failed: ${message}`);
         }
     }
+    closeIssue(repo, issueNumber) {
+        try {
+            restCloseIssue(repo, issueNumber, "completed");
+        }
+        catch (exc) {
+            const message = exc instanceof Error ? exc.message : String(exc);
+            throw new UmbrellaScmError(`close issue #${issueNumber} (${repo}) failed: ${message}`);
+        }
+    }
 }
 function planShape(epicData, index, options = {}) {
     const children = computeChildren(epicData, index, {
@@ -545,6 +566,147 @@ function reconcileOneEpic(epicData, index, options) {
 export function nowIso(date = new Date()) {
     return date.toISOString().replace(/\.\d{3}Z$/, "Z");
 }
+const ALL_CHILDREN_MERGED = "all-children-merged";
+/** Children listed on a slices.jsonl row (#3428). Last write of a duplicate `n` wins. */
+export function childrenFromSliceRecord(record) {
+    const raw = record.children;
+    if (!Array.isArray(raw))
+        return [];
+    const byNumber = new Map();
+    for (const entry of raw) {
+        if (typeof entry !== "object" || entry === null || Array.isArray(entry))
+            continue;
+        const rec = entry;
+        const n = rec.n;
+        if (typeof n !== "number" || !Number.isInteger(n) || n < 1)
+            continue;
+        byNumber.set(n, {
+            story_id: `#${n}`,
+            title: `#${n}`,
+            kind: "story",
+            folder: UNKNOWN_FOLDER,
+            depends_on: [],
+            issue_number: n,
+        });
+    }
+    return [...byNumber.values()];
+}
+/**
+ * Close only when the slice signal is all-children-merged, the umbrella is
+ * still open, and every child has forge state closed (#3428).
+ */
+export function shouldCloseOnAllChildrenMerged(options) {
+    if (options.signal !== ALL_CHILDREN_MERGED)
+        return false;
+    if (options.umbrellaState !== "open")
+        return false;
+    if (options.children.length === 0)
+        return false;
+    if (options.forgeStates == null)
+        return false;
+    return options.children.every((c) => typeof c.issue_number === "number" && options.forgeStates?.get(c.issue_number) === "closed");
+}
+export function formatCloseComment(signal, children) {
+    const nums = children
+        .map((c) => c.issue_number)
+        .filter((n) => typeof n === "number")
+        .sort((a, b) => a - b)
+        .map((n) => `#${n}`);
+    return `expected_close_signal=${signal}; children: ${nums.join(", ")}`;
+}
+function loadLatestSliceRecords(vbriefDir) {
+    const logPath = join(vbriefDir, ".triage-cache", "slices.jsonl");
+    if (!existsSync(logPath))
+        return [];
+    const latest = new Map();
+    for (const rec of readAll({ path: logPath })) {
+        const n = rec.umbrella;
+        if (typeof n !== "number" || !Number.isInteger(n) || n < 1)
+            continue;
+        const [urlRepo] = parseGithubIssueUri(rec.umbrella_url);
+        latest.set(`${urlRepo ?? ""}:${n}`, rec);
+    }
+    return [...latest.values()];
+}
+function epicDataFromSlice(repo, number, children) {
+    const refs = [
+        { type: "x-xbrief/github-issue", uri: `https://github.com/${repo}/issues/${number}` },
+        ...children.map((c) => ({
+            type: "x-xbrief/github-issue",
+            uri: `https://github.com/${repo}/issues/${c.issue_number}`,
+            title: c.title,
+        })),
+    ];
+    return {
+        plan: {
+            id: `slice-umbrella-${number}`,
+            metadata: { kind: "epic" },
+            references: refs,
+        },
+    };
+}
+function maybeCloseSliceUmbrella(options) {
+    if (typeof options.client.closeIssue !== "function")
+        return "skipped";
+    if (typeof options.client.fetchIssueStates !== "function")
+        return "skipped";
+    const mutateGate = isRepoMutationAllowed(options.repo, options.projectRoot, {
+        allowCrossRepo: options.allowCrossRepo,
+        allowlist: options.repoAllowlist,
+        explicitRepo: options.explicitRepo ?? null,
+    });
+    if (!mutateGate.allowed) {
+        throw new Error(mutateGate.reason ?? `refusing cross-repo mutation on ${options.repo}`);
+    }
+    const childNumbers = options.children
+        .map((c) => c.issue_number)
+        .filter((n) => typeof n === "number");
+    const states = options.client.fetchIssueStates(options.repo, [...childNumbers, options.number]);
+    const umbrellaState = states.get(options.number) ?? null;
+    if (!shouldCloseOnAllChildrenMerged({
+        signal: options.signal,
+        children: options.children,
+        forgeStates: states,
+        umbrellaState,
+    })) {
+        return options.signal === ALL_CHILDREN_MERGED && umbrellaState === "closed"
+            ? "unchanged"
+            : "skipped";
+    }
+    const closeBody = formatCloseComment(ALL_CHILDREN_MERGED, options.children);
+    if (!options.dryRun) {
+        const alreadyCommented = options.client
+            .fetchComments(options.repo, options.number)
+            .some((c) => c.body.trim() === closeBody);
+        if (!alreadyCommented) {
+            options.client.createComment(options.repo, options.number, closeBody);
+        }
+        options.client.closeIssue(options.repo, options.number);
+    }
+    return "closed";
+}
+function pushUmbrellaChange(outcome, change) {
+    if (change.action === "unchanged" && change.close_action !== "closed") {
+        outcome.unchanged.push(change);
+    }
+    else {
+        outcome.changed.push(change);
+    }
+}
+function replaceCloseAction(outcome, repo, issueNumber, closeAction) {
+    const match = (c) => c.repo === repo && c.issue_number === issueNumber;
+    for (const list of [outcome.changed, outcome.unchanged]) {
+        const idx = list.findIndex(match);
+        if (idx < 0)
+            continue;
+        const prev = list[idx];
+        if (prev === undefined)
+            return;
+        list.splice(idx, 1);
+        pushUmbrellaChange(outcome, { ...prev, close_action: closeAction });
+        return;
+    }
+}
 export function reconcileUmbrellas(projectRoot, options = {}) {
     const root = resolve(projectRoot);
     let vbriefDir;
@@ -616,7 +778,6 @@ export function reconcileUmbrellas(projectRoot, options = {}) {
             const key = `${effectiveRepo}:${number}`;
             if (seenIssues.has(key))
                 continue;
-            seenIssues.add(key);
             try {
                 const change = reconcileOneEpic(data, index, {
                     storyId,
@@ -630,6 +791,7 @@ export function reconcileUmbrellas(projectRoot, options = {}) {
                     repoAllowlist: options.repoAllowlist,
                     explicitRepo: options.repo ?? null,
                 });
+                seenIssues.add(key);
                 if (change.action === "unchanged")
                     outcome.unchanged.push(change);
                 else
@@ -643,6 +805,71 @@ export function reconcileUmbrellas(projectRoot, options = {}) {
             }
         }
     }
+    // slices.jsonl umbrellas have no epic xBRIEF (#3428). Last row per umbrella wins.
+    for (const record of loadLatestSliceRecords(vbriefDir)) {
+        const number = record.umbrella;
+        if (typeof number !== "number")
+            continue;
+        const [urlRepo] = parseGithubIssueUri(record.umbrella_url);
+        const effectiveRepo = urlRepo ?? options.repo ?? null;
+        if (effectiveRepo === null) {
+            outcome.skipped_no_ref.push(`slice-umbrella-${number}`);
+            continue;
+        }
+        const key = `${effectiveRepo}:${number}`;
+        const children = childrenFromSliceRecord(record);
+        const storyId = `slice-umbrella-${number}`;
+        try {
+            if (seenIssues.has(key)) {
+                const closeAction = maybeCloseSliceUmbrella({
+                    signal: record.expected_close_signal,
+                    children,
+                    repo: effectiveRepo,
+                    number,
+                    client,
+                    dryRun: options.dryRun ?? false,
+                    projectRoot: root,
+                    allowCrossRepo: options.allowCrossRepo ?? false,
+                    repoAllowlist: options.repoAllowlist,
+                    explicitRepo: options.repo ?? null,
+                });
+                replaceCloseAction(outcome, effectiveRepo, number, closeAction);
+                continue;
+            }
+            const change = reconcileOneEpic(epicDataFromSlice(effectiveRepo, number, children), index, {
+                storyId,
+                repo: effectiveRepo,
+                number,
+                client,
+                dryRun: options.dryRun ?? false,
+                now,
+                projectRoot: root,
+                allowCrossRepo: options.allowCrossRepo ?? false,
+                repoAllowlist: options.repoAllowlist,
+                explicitRepo: options.repo ?? null,
+            });
+            seenIssues.add(key);
+            const closeAction = maybeCloseSliceUmbrella({
+                signal: record.expected_close_signal,
+                children,
+                repo: effectiveRepo,
+                number,
+                client,
+                dryRun: options.dryRun ?? false,
+                projectRoot: root,
+                allowCrossRepo: options.allowCrossRepo ?? false,
+                repoAllowlist: options.repoAllowlist,
+                explicitRepo: options.repo ?? null,
+            });
+            pushUmbrellaChange(outcome, { ...change, close_action: closeAction });
+        }
+        catch (exc) {
+            outcome.errors.push({
+                story_id: storyId,
+                message: exc instanceof Error ? exc.message : String(exc),
+            });
+        }
+    }
     return [outcome.errors.length > 0 ? 1 : 0, outcome];
 }
 function formatChecklistSuffix(action) {
@@ -650,6 +877,11 @@ function formatChecklistSuffix(action) {
         return "";
     return `; checklist=${action}`;
 }
+function formatCloseSuffix(action) {
+    if (action === undefined || action === "skipped")
+        return "";
+    return `; close=${action}`;
+}
 export function renderUmbrellasReport(outcome) {
     const lines = ["vBRIEF reconcile umbrellas", ""];
     const suffix = outcome.dry_run ? " (dry-run)" : "";
@@ -657,7 +889,8 @@ export function renderUmbrellasReport(outcome) {
     if (outcome.changed.length > 0) {
         for (const c of outcome.changed) {
             lines.push(`- #${c.issue_number} (${c.repo}) [${c.story_id}]: ${c.action} -> pass-${c.pass_n}` +
-                formatChecklistSuffix(c.checklist_action));
+                formatChecklistSuffix(c.checklist_action) +
+                formatCloseSuffix(c.close_action));
         }
     }
     else {
@@ -668,7 +901,8 @@ export function renderUmbrellasReport(outcome) {
     if (outcome.unchanged.length > 0) {
         for (const c of outcome.unchanged) {
             lines.push(`- #${c.issue_number} (${c.repo}) [${c.story_id}]: pass-${c.pass_n}` +
-                formatChecklistSuffix(c.checklist_action));
+                formatChecklistSuffix(c.checklist_action) +
+                formatCloseSuffix(c.close_action));
         }
     }
     else {
@@ -696,6 +930,7 @@ export function umbrellasOutcomeToJson(outcome) {
         action: c.action,
         pass_n: c.pass_n,
         checklist_action: c.checklist_action ?? "skipped",
+        close_action: c.close_action ?? "skipped",
     });
     return {
         changed: outcome.changed.map(toChange),

package/dist/vbrief-validate/index.d.ts

@@ -6,7 +6,7 @@ export { validateFolderStatus } from "./folder-status.js";
 export type { ConformanceCliOptions, ValidateCliOptions } from "./main.js";
 export { cmdVbriefValidate, runConformance, runValidate } from "./main.js";
 export { validateOriginProvenance } from "./origin.js";
-export { validateSessionRitualStalenessHoursOnPlan, validateTriageRankingLabelsOnPlan, validateWipCapOnPlan, } from "./plan-hooks.js";
+export { validateForgeOutageRetryMinutesOnPlan, validateProjectInvariantsOnPlan, validateSessionRitualStalenessHoursOnPlan, validateTriageRankingLabelsOnPlan, validateWipCapOnPlan, } from "./plan-hooks.js";
 export { validateProjectDefinition } from "./project-definition.js";
 export type { ExtensionEntry, ExtensionRoundtripEvaluateResult, ExtensionRoundtripFinding, } from "./roundtrip.js";
 export { collectExtensionEntries, EXTENSION_CONFORMANCE_FIXTURES_DIR, evaluateExtensionRoundtrip, findExtensionPreservationViolations, reEmitVbriefArtifact, renderExtensionRoundtripFinding, VbriefSchemaValidationError, } from "./roundtrip.js";

package/dist/vbrief-validate/index.js

@@ -4,7 +4,7 @@ export { matchesFilenameConvention, validateFilename } from "./filename.js";
 export { validateFolderStatus } from "./folder-status.js";
 export { cmdVbriefValidate, runConformance, runValidate } from "./main.js";
 export { validateOriginProvenance } from "./origin.js";
-export { validateSessionRitualStalenessHoursOnPlan, validateTriageRankingLabelsOnPlan, validateWipCapOnPlan, } from "./plan-hooks.js";
+export { validateForgeOutageRetryMinutesOnPlan, validateProjectInvariantsOnPlan, validateSessionRitualStalenessHoursOnPlan, validateTriageRankingLabelsOnPlan, validateWipCapOnPlan, } from "./plan-hooks.js";
 export { validateProjectDefinition } from "./project-definition.js";
 export { collectExtensionEntries, EXTENSION_CONFORMANCE_FIXTURES_DIR, evaluateExtensionRoundtrip, findExtensionPreservationViolations, reEmitVbriefArtifact, renderExtensionRoundtripFinding, VbriefSchemaValidationError, } from "./roundtrip.js";
 export { normalizeNarrativeKey, validateVbriefSchema } from "./schema.js";

package/dist/vbrief-validate/plan-hooks.d.ts

@@ -2,6 +2,10 @@
 export declare function validateWipCapOnPlan(plan: unknown, filepath: string): string[];
 /** vbrief_validate hook for ``sessionRitualStalenessHours`` (#1348). */
 export declare function validateSessionRitualStalenessHoursOnPlan(plan: unknown, filepath: string): string[];
+/** vbrief_validate hook for ``projectInvariants`` (#3425). */
+export declare function validateProjectInvariantsOnPlan(plan: unknown, filepath: string): string[];
+/** vbrief_validate hook for ``forgeOutageRetryMinutes`` (#3422). */
+export declare function validateForgeOutageRetryMinutesOnPlan(plan: unknown, filepath: string): string[];
 /** vbrief_validate hook: validate ``plan.policy.triageRankingLabels`` (#1128). */
 export declare function validateTriageRankingLabelsOnPlan(plan: unknown, filepath: string): string[];
 /** vbrief_validate hook: validate ``plan.policy.runtimeAuthority`` (#1394). */