@deftai/directive 0.104.0 → 0.105.0

package/dist/scm-sync-default.d.ts

@@ -0,0 +1,34 @@
+/**
+ * CLI for `scm:sync-default` (#3391).
+ *
+ * Opens dest-targeted default-branch sync PRs using the shared detector and
+ * syncMaxFiles. Over-limit legs are new branches and new PRs.
+ */
+import { planSyncDefault, type SyncDefaultForge, type SyncDefaultOpenPull } from "@deftai/directive-core/policy";
+export declare const USAGE: string;
+export interface SyncDefaultCliArgs {
+    readonly dryRun?: boolean;
+    readonly json?: boolean;
+    readonly help?: boolean;
+    readonly maxFiles?: number;
+    readonly projectRoot?: string;
+    readonly repo?: string;
+}
+export declare function parseSyncDefaultArgs(argv: readonly string[]): {
+    args: SyncDefaultCliArgs;
+    error: string | null;
+};
+export declare function pullsFromRestJson(payload: unknown): readonly SyncDefaultOpenPull[];
+export declare function createGhSyncDefaultForge(): SyncDefaultForge;
+export declare function resolveRepoFromGit(projectRoot: string): string | null;
+export declare function runSyncDefaultCli(args: SyncDefaultCliArgs, options?: {
+    writeOut?: (s: string) => void;
+    writeErr?: (s: string) => void;
+    forge?: SyncDefaultForge;
+    cwd?: string;
+    runGit?: Parameters<typeof planSyncDefault>[0]["runGit"];
+    resolveRepo?: (projectRoot: string) => string | null;
+}): number;
+export declare function mainEntry(argv?: string[]): number;
+export declare function main(argv?: string[]): number;
+//# sourceMappingURL=scm-sync-default.d.ts.map

package/dist/scm-sync-default.js

@@ -0,0 +1,210 @@
+/**
+ * CLI for `scm:sync-default` (#3391).
+ *
+ * Opens dest-targeted default-branch sync PRs using the shared detector and
+ * syncMaxFiles. Over-limit legs are new branches and new PRs.
+ */
+import { writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { applySyncDefault, formatSyncDefaultHuman, parseGithubOwnerRepo, planSyncDefault, SYNC_DEFAULT_VERB, } from "@deftai/directive-core/policy";
+import { runGhApi, splitRepo } from "@deftai/directive-core/scm";
+import { defaultGitRunner } from "@deftai/directive-core/session";
+export const USAGE = `usage: deft ${SYNC_DEFAULT_VERB} [--dry-run] [--json] [--max-files N] [--repo OWNER/REPO]\n` +
+    "  Open dest-targeted sync PRs under syncMaxFiles. Under the limit: one new PR\n" +
+    "  from source tip to dest. Over: merge-commit cuts; each dest-based leg is a\n" +
+    "  new branch and a new PR. After a leg merges, run again. Never retarget or\n" +
+    "  reuse an oversized PR. Each leg must be new when the reviewer first sees it.\n" +
+    "  Required checks stay on except the Wave 1 core-guard sync exemption.\n";
+export function parseSyncDefaultArgs(argv) {
+    const out = {};
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--dry-run") {
+            out.dryRun = true;
+        }
+        else if (arg === "--json") {
+            out.json = true;
+        }
+        else if (arg === "--help" || arg === "-h") {
+            out.help = true;
+        }
+        else if (arg === "--max-files") {
+            const raw = argv[++i];
+            const parsed = raw === undefined ? Number.NaN : Number(raw);
+            if (!Number.isInteger(parsed) || parsed < 0) {
+                return { args: out, error: `--max-files expects a non-negative integer, got ${raw ?? ""}` };
+            }
+            out.maxFiles = parsed;
+        }
+        else if (arg === "--project-root") {
+            const value = argv[++i];
+            if (value === undefined) {
+                return { args: out, error: "--project-root expects a path" };
+            }
+            out.projectRoot = value;
+        }
+        else if (arg === "--repo") {
+            const value = argv[++i];
+            if (value === undefined) {
+                return { args: out, error: "--repo expects OWNER/REPO" };
+            }
+            out.repo = value;
+        }
+        else if (arg.startsWith("-")) {
+            return { args: out, error: `unknown flag ${JSON.stringify(arg)}` };
+        }
+        else {
+            return { args: out, error: `unexpected argument ${JSON.stringify(arg)}` };
+        }
+    }
+    return { args: out, error: null };
+}
+export function pullsFromRestJson(payload) {
+    if (!Array.isArray(payload))
+        return [];
+    const pulls = [];
+    for (const row of payload) {
+        if (typeof row !== "object" || row === null)
+            continue;
+        const rec = row;
+        const head = rec.head;
+        const baseRec = rec.base;
+        if (typeof head !== "object" || head === null)
+            continue;
+        if (typeof baseRec !== "object" || baseRec === null)
+            continue;
+        const headRec = head;
+        const baseObj = baseRec;
+        const number = rec.number;
+        const htmlUrl = rec.html_url;
+        const headRef = headRec.ref;
+        const headSha = headRec.sha;
+        const baseRef = baseObj.ref;
+        if (typeof number !== "number" ||
+            typeof htmlUrl !== "string" ||
+            typeof headRef !== "string" ||
+            typeof headSha !== "string" ||
+            typeof baseRef !== "string") {
+            continue;
+        }
+        pulls.push({ number, htmlUrl, headRef, headSha, baseRef });
+    }
+    return pulls;
+}
+export function createGhSyncDefaultForge() {
+    return {
+        listOpenPulls(repo, base) {
+            const [owner, name] = splitRepo(repo);
+            const endpoint = `repos/${owner}/${name}/pulls`;
+            const result = runGhApi([
+                endpoint,
+                "--method",
+                "GET",
+                "--raw-field",
+                `base=${base}`,
+                "--raw-field",
+                "state=open",
+                "--raw-field",
+                "per_page=100",
+            ]);
+            if (result.returncode !== 0) {
+                throw new Error(result.stderr || `failed to list open pulls for ${repo}`);
+            }
+            return pullsFromRestJson(JSON.parse(result.stdout || "[]"));
+        },
+        createPull(repo, input) {
+            const [owner, name] = splitRepo(repo);
+            const endpoint = `repos/${owner}/${name}/pulls`;
+            const bodyPath = join(tmpdir(), `deft-sync-default-${Date.now()}.json`);
+            writeFileSync(bodyPath, JSON.stringify({
+                title: input.title,
+                head: input.head,
+                base: input.base,
+                body: input.body,
+            }), { encoding: "utf8" });
+            const result = runGhApi(["-X", "POST", endpoint, "--input", bodyPath]);
+            if (result.returncode !== 0) {
+                throw new Error(result.stderr || `failed to create pull for ${repo}`);
+            }
+            const created = JSON.parse(result.stdout);
+            if (typeof created.number !== "number" || typeof created.html_url !== "string") {
+                throw new Error("create pull returned no number/html_url");
+            }
+            return { number: created.number, htmlUrl: created.html_url };
+        },
+    };
+}
+export function resolveRepoFromGit(projectRoot) {
+    const remote = defaultGitRunner(projectRoot, ["remote", "get-url", "origin"]);
+    if (remote.code !== 0)
+        return null;
+    return parseGithubOwnerRepo(remote.stdout);
+}
+export function runSyncDefaultCli(args, options = {}) {
+    const writeOut = options.writeOut ?? ((s) => process.stdout.write(s));
+    const writeErr = options.writeErr ?? ((s) => process.stderr.write(s));
+    if (args.help === true) {
+        writeOut(USAGE);
+        return 0;
+    }
+    const projectRoot = args.projectRoot ?? options.cwd ?? process.cwd();
+    const plan = planSyncDefault({
+        projectRoot,
+        maxFiles: args.maxFiles,
+        runGit: options.runGit,
+    });
+    if (plan.action === "noop") {
+        if (args.json === true) {
+            writeOut(`${JSON.stringify({ ...plan, opened: [], retargeted: false }, null, 2)}\n`);
+        }
+        else {
+            writeOut(`${plan.message}\n`);
+        }
+        return plan.noopReason === "fetch-failed" || plan.noopReason === "diff-failed" ? 2 : 0;
+    }
+    const resolveRepo = options.resolveRepo ?? resolveRepoFromGit;
+    const repo = args.repo ?? resolveRepo(projectRoot);
+    if (repo === null && args.dryRun !== true) {
+        writeErr("scm:sync-default: could not resolve OWNER/REPO from origin; pass --repo\n");
+        return 2;
+    }
+    try {
+        const result = applySyncDefault({
+            projectRoot,
+            repo: repo ?? "owner/repo",
+            plan,
+            dryRun: args.dryRun === true,
+            runGit: options.runGit,
+            forge: args.dryRun === true ? undefined : (options.forge ?? createGhSyncDefaultForge()),
+        });
+        if (args.json === true) {
+            writeOut(`${JSON.stringify(result, null, 2)}\n`);
+        }
+        else {
+            writeOut(formatSyncDefaultHuman(result));
+        }
+        return 0;
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        writeErr(`scm:sync-default: ${message}\n`);
+        return 1;
+    }
+}
+export function mainEntry(argv = process.argv.slice(2)) {
+    const { args, error } = parseSyncDefaultArgs(argv);
+    if (error !== null) {
+        process.stderr.write(`error: ${error}\n${USAGE}`);
+        return 2;
+    }
+    return runSyncDefaultCli(args);
+}
+export function main(argv = process.argv.slice(2)) {
+    return mainEntry(argv);
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(mainEntry());
+}
+//# sourceMappingURL=scm-sync-default.js.map

package/dist/scope-record-approved-scope.d.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { type HumanPresenceMintSeams } from "./human-presence-mint.js";
 /** True when `candidate` is the same as or a descendant of `root` after realpath. */
 export declare function isPathInsideRoot(root: string, candidate: string): boolean;
 export interface ParsedArgs {
@@ -9,6 +10,10 @@ export interface ParsedArgs {
     /** Optional override for recorded xbriefRelPath (defaults: pending→active map). */
     xbriefRelPath: string;
     quiet: boolean;
+    /** Explicit operator confirm for the #3110 human-presence mint (#3384). */
+    confirm: boolean;
+    /** Optional owner/name seed for preimage approvedRepos (#3385 R5). */
+    repo: string;
     error?: string;
 }
 /**
@@ -18,5 +23,5 @@ export interface ParsedArgs {
  */
 export declare function resolveApprovalXbriefRelPath(sourceRelOrAbs: string, projectRoot: string, override?: string): string | null;
 export declare function parseArgs(argv: string[]): ParsedArgs;
-export declare function run(argv: string[]): number;
+export declare function run(argv: string[], seams?: HumanPresenceMintSeams): number;
 //# sourceMappingURL=scope-record-approved-scope.d.ts.map

package/dist/scope-record-approved-scope.js

@@ -9,8 +9,9 @@
  */
 import { existsSync, lstatSync, readFileSync, realpathSync } from "node:fs";
 import { basename, join, relative, resolve, sep } from "node:path";
-import { scopeProvenance } from "@deftai/directive-core";
+import { scopeProvenance, slice } from "@deftai/directive-core";
 import { isDirectEntrypoint } from "./entrypoint.js";
+import { refuseMintWhileUatActive, refuseNonInteractiveMint, resolveHumanPresenceMintSeams, } from "./human-presence-mint.js";
 /** True when `candidate` is the same as or a descendant of `root` after realpath. */
 export function isPathInsideRoot(root, candidate) {
     let rootReal;
@@ -37,13 +38,13 @@ export function isPathInsideRoot(root, candidate) {
         return false;
     return !rel.startsWith("..");
 }
-const { buildApprovedScopeRecord, isHumanApprovalStamp, writeApprovedScopeRecord } = scopeProvenance;
+const { isHumanApprovalStamp, mintApprovedScopeArtifacts } = scopeProvenance;
 function usage() {
-    return ("usage: scope:record-approved-scope -- <xbrief-path> --actor <name> " +
-        "[--kind operator] [--project-root <dir>] [--xbrief-rel-path <posix>] [--quiet]\n" +
-        "  Writes .deft/approved-scope/<plan-id>.json with a humanApproval stamp (#3205).\n" +
-        "  Agent-shaped stamps are refused. Path-binds to xbrief/active/ by default when " +
-        "the source is under pending/ or active/.");
+    return ("usage: scope:record-approved-scope -- <xbrief-path> --actor <name> --confirm " +
+        "[--kind operator] [--project-root <dir>] [--xbrief-rel-path <posix>] [--repo owner/name] [--quiet]\n" +
+        "  Writes .deft/approved-scope/<plan-id>.json and <plan-id>.intent.json (#3205 / #3384 / #3385).\n" +
+        "  --actor is display only and never authorizes mint. Mint requires a real TTY, " +
+        "controlling terminal, --confirm, and typed phrase mint (#3110). Agent/CI shells refuse.");
 }
 /**
  * Map pending/ → active/ for path-bound approval records.
@@ -96,6 +97,8 @@ export function parseArgs(argv) {
         kind: "operator",
         xbriefRelPath: "",
         quiet: false,
+        confirm: false,
+        repo: "",
     };
     const positionals = [];
     for (let i = 0; i < argv.length; i += 1) {
@@ -106,6 +109,9 @@ export function parseArgs(argv) {
         if (arg === "--quiet") {
             parsed.quiet = true;
         }
+        else if (arg === "--confirm") {
+            parsed.confirm = true;
+        }
         else if (arg === "--project-root") {
             const value = argv[i + 1];
             if (value === undefined) {
@@ -150,6 +156,17 @@ export function parseArgs(argv) {
         else if (arg?.startsWith("--xbrief-rel-path=")) {
             parsed.xbriefRelPath = arg.slice("--xbrief-rel-path=".length);
         }
+        else if (arg === "--repo") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --repo: expected one argument" };
+            }
+            parsed.repo = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--repo=")) {
+            parsed.repo = arg.slice("--repo=".length);
+        }
         else if (arg?.startsWith("-")) {
             return { ...parsed, error: `unrecognized argument: ${arg}` };
         }
@@ -172,7 +189,7 @@ export function parseArgs(argv) {
     }
     return parsed;
 }
-export function run(argv) {
+export function run(argv, seams = {}) {
     const args = parseArgs(argv);
     if (args.error !== undefined) {
         process.stderr.write(`scope_record_approved_scope: ${args.error}\n`);
@@ -202,14 +219,27 @@ export function run(argv) {
         process.stderr.write(`scope_record_approved_scope: failed to read xBRIEF: ${String(err)}\n`);
         return 2;
     }
-    let payload;
-    try {
-        payload = JSON.parse(raw);
-    }
-    catch {
-        process.stderr.write("scope_record_approved_scope: xBRIEF is not valid JSON\n");
+    const parsed = scopeProvenance.parseJsonRejectingDuplicateKeys(raw);
+    if (!parsed.ok) {
+        process.stderr.write(`scope_record_approved_scope: ${parsed.error}\n`);
         return 2;
     }
+    const payload = parsed.value;
+    const verb = "scope:record-approved-scope";
+    const uatBlocked = refuseMintWhileUatActive(verb, projectRoot);
+    if (uatBlocked !== null)
+        return uatBlocked;
+    const resolved = resolveHumanPresenceMintSeams(seams);
+    const mintBlocked = refuseNonInteractiveMint({
+        verb,
+        confirm: args.confirm,
+        isTty: resolved.isTty,
+        environ: resolved.environ,
+        hasControllingTerminal: resolved.hasControllingTerminal,
+        readInteractiveConfirm: resolved.readInteractiveConfirm,
+    });
+    if (mintBlocked !== null)
+        return mintBlocked;
     const stamp = {
         kind: args.kind.trim(),
         actor: args.actor.trim(),
@@ -228,22 +258,40 @@ export function run(argv) {
             "(repo-relative path required for approval binding) (#3205).\n");
         return 2;
     }
-    const record = buildApprovedScopeRecord({
-        xbriefRelPath,
-        payload,
-        humanApproval: stamp,
-        xbriefRawText: raw,
-    });
-    const outPath = writeApprovedScopeRecord(projectRoot, record);
+    const repoSeed = slice.resolveProjectRepo(args.repo.trim().length > 0 ? args.repo.trim() : undefined, projectRoot);
+    // Mint writes record + preimage as one fail-closed pair. A dest-write
+    // failure restores the prior pair or leaves neither dest (#3385 residual).
+    let minted;
+    try {
+        minted = mintApprovedScopeArtifacts({
+            xbriefRelPath,
+            payload,
+            rawText: raw,
+            projectRoot,
+            humanApproval: stamp,
+            extract: {
+                projectRoot,
+                approvedReposSeed: repoSeed !== null ? [repoSeed] : [],
+            },
+        });
+    }
+    catch (err) {
+        process.stderr.write(`scope_record_approved_scope: ${String(err)}\n`);
+        return 1;
+    }
+    const { record, recordPath, intentPath } = minted;
     if (!args.quiet) {
-        process.stdout.write(`scope_record_approved_scope: wrote ${outPath}\n` +
+        process.stdout.write(`scope_record_approved_scope: wrote ${recordPath}\n` +
+            `  preimage: ${intentPath}\n` +
             `  planId: ${record.planId}\n` +
             `  xbriefRelPath: ${record.xbriefRelPath}\n` +
             `  fileScopeDigest: ${record.fileScopeDigest}\n` +
+            `  intentDigest: ${record.intentDigest ?? ""}\n` +
             `  paths: ${record.fileScope.length}\n` +
             `  humanApproval: ${stamp.kind}/${stamp.actor}\n` +
-            "  Next: commit this file on the merge base (or a prior PR) before " +
-            "activation/expansion in the implementation change set (#3205).\n");
+            "  Read the preimage before you commit. That file is the approved intent (#3385).\n" +
+            "  Next: commit record + preimage on the merge base (or a prior PR) before " +
+            "activation/expansion in the implementation change set (#3205 / #3385).\n");
     }
     return 0;
 }

package/dist/session-start.d.ts

@@ -32,6 +32,10 @@ export interface ParsedSessionStartArgs {
      * the default; also settable via DEFT_SESSION_COMPACT=1.
      */
     compact: boolean;
+    /** #3433: steal the worktree occupancy lease. */
+    steal: boolean;
+    confirm: boolean;
+    occupant: string | null;
     error?: string;
 }
 /** Parse session:start CLI args, mirroring scripts/session_start.py. */

package/dist/session-start.js

@@ -31,6 +31,9 @@ export function parseArgs(argv) {
         ceremonyDepthOverride: null,
         effortBudgetHost: {},
         compact: false,
+        steal: false,
+        confirm: false,
+        occupant: null,
     };
     const dialInputs = {};
     for (let i = 0; i < argv.length; i += 1) {
@@ -273,6 +276,23 @@ export function parseArgs(argv) {
             // #3286: terse machine orientation output (opt-in; verbose remains default)
             parsed.compact = true;
         }
+        else if (arg === "--steal") {
+            parsed.steal = true;
+        }
+        else if (arg === "--confirm") {
+            parsed.confirm = true;
+        }
+        else if (arg === "--occupant") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --occupant: expected one argument" };
+            }
+            parsed.occupant = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--occupant=")) {
+            parsed.occupant = arg.slice("--occupant=".length);
+        }
         else {
             return { ...parsed, error: `unrecognized argument: ${arg}` };
         }
@@ -335,6 +355,9 @@ export function run(argv) {
             effortBudgetSeams: { hostDescriptor, environ: process.env },
             // #3286: --compact flag; DEFT_SESSION_COMPACT still resolved inside core.
             compact: args.compact ? true : undefined,
+            steal: args.steal ? true : undefined,
+            confirm: args.confirm ? true : undefined,
+            occupant: args.occupant ?? undefined,
             ...(args.ceremonyDepthOverride !== null
                 ? {
                     ceremonyDial: selectCeremonyDepth({

package/dist/verify-ac.d.ts

@@ -20,6 +20,8 @@ export type FindActiveXbriefResult = {
     readonly paths: readonly string[];
     readonly dir: string;
 };
+/** Three-state exit: pass=0, fail=1, config=2. A printed pass must not leak 201. */
+export declare function clampVerifyAcExit(ok: boolean, code: number): number;
 /** Run the gate and return the process exit code. */
 export declare function run(argv: string[]): number;
 export {};

package/dist/verify-ac.js

@@ -11,7 +11,7 @@ import { join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { resolveSessionCompletedVerifyAcTarget } from "@deftai/directive-core/check";
 import { formatRejectedLedger, resolveLiteralAcceptanceDetailed, } from "@deftai/directive-core/literal-acceptance";
-import { emitVerifyAcTerminalOutcome, evaluateVerifyAcFromPath, readPlanAcceptance, } from "@deftai/directive-core/product-first-done-gate";
+import { emitVerifyAcTerminalOutcome, evaluateVerifyAcFromPath, readPlanAcceptance, resolveAcceptanceGateProfile, } from "@deftai/directive-core/product-first-done-gate";
 /** Parse verify:ac CLI args. */
 export function parseArgs(argv) {
     const parsed = {
@@ -103,9 +103,20 @@ function listActiveXbriefs(projectRoot) {
         dir: dirs.join(" + "),
     };
 }
+/** Three-state exit: pass=0, fail=1, config=2. A printed pass must not leak 201. */
+export function clampVerifyAcExit(ok, code) {
+    if (ok)
+        return 0;
+    if (code === 2)
+        return 2;
+    return 1;
+}
 /** Evaluate one or many xBRIEF paths; return worst non-zero code (fail closed). */
 function evaluatePaths(paths, options) {
     let worst = 0;
+    // One shared option profile per reader (#3497) — scope:complete resolves its own
+    // profile from the same table, so the two readers cannot drift apart again.
+    const profile = resolveAcceptanceGateProfile(options.softMissingXbrief ? "check" : "standalone");
     for (const path of paths) {
         if (!options.quiet && paths.length > 1) {
             process.stdout.write(`verify:ac — evaluating ${path}\n`);
@@ -114,7 +125,9 @@ function evaluatePaths(paths, options) {
             projectRoot: options.projectRoot,
             quiet: options.quiet,
             softMissingXbrief: options.softMissingXbrief,
-            checkIntegrated: options.softMissingXbrief,
+            checkIntegrated: profile.checkIntegrated,
+            captureFromNarratives: profile.captureFromNarratives,
+            reuseMode: profile.reuseMode,
             env: process.env,
         });
         if (result.message.length > 0) {
@@ -125,9 +138,10 @@ function evaluatePaths(paths, options) {
                 process.stderr.write(`${result.message}\n`);
             }
         }
-        if (result.code !== 0 && (worst === 0 || result.code > worst)) {
+        const code = clampVerifyAcExit(result.ok, result.code);
+        if (code !== 0 && (worst === 0 || code > worst)) {
             // Prefer code 1 (fail) over 2 when both present — still non-zero.
-            worst = result.code;
+            worst = code;
         }
     }
     return worst;
@@ -242,14 +256,24 @@ export function run(argv) {
                 }
                 const acceptance = readPlanAcceptance(plan);
                 const resolved = resolveLiteralAcceptanceDetailed(plan, { captureFromNarratives: true });
+                // Executor reads plan.acceptance.commands when the #3267 ledger is empty (#3449).
+                const executorCommands = resolved.commands.length > 0
+                    ? resolved.commands
+                    : acceptance.commands.map((c) => ({
+                        command: c.command,
+                        source: "explicit",
+                        sourceSpan: "plan.acceptance.commands",
+                        cwd: c.cwd ?? null,
+                        expectedExitCode: c.expectedExitCode ?? 0,
+                    }));
                 reports.push({
                     xbrief: xbriefPath,
                     source_rung: acceptance.source_rung,
                     none_stated: acceptance.none_stated,
                     acceptance_commands: acceptance.commands,
-                    count: resolved.commands.length,
+                    count: executorCommands.length,
                     rejected_count: resolved.rejected.length,
-                    commands: resolved.commands.map((c) => ({
+                    commands: executorCommands.map((c) => ({
                         command: c.command,
                         source: c.source,
                         sourceSpan: c.sourceSpan ?? null,

package/dist/verify-completed-tracked.d.ts

@@ -3,11 +3,12 @@ interface ParsedArgs {
     projectRoot: string;
     repo: string | null;
     tip: string | null;
+    issue: number | null;
     quiet: boolean;
     skipGh: boolean;
     error?: string;
 }
-/** Parse verify-completed-tracked CLI args (#3264). */
+/** Parse verify-completed-tracked CLI args (#3264 / #3476). */
 export declare function parseArgs(argv: string[]): ParsedArgs;
 /** Run the gate and return the process exit code. */
 export declare function run(argv: string[]): number;

package/dist/verify-completed-tracked.js

@@ -2,12 +2,21 @@
 import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { evaluateCompletedTracked } from "@deftai/directive-core/lifecycle";
-/** Parse verify-completed-tracked CLI args (#3264). */
+function parseIssueNumber(raw) {
+    const trimmed = raw.startsWith("#") ? raw.slice(1) : raw;
+    if (!/^\d+$/.test(trimmed)) {
+        return null;
+    }
+    const value = Number(trimmed);
+    return Number.isInteger(value) && value > 0 ? value : null;
+}
+/** Parse verify-completed-tracked CLI args (#3264 / #3476). */
 export function parseArgs(argv) {
     const parsed = {
         projectRoot: ".",
         repo: null,
         tip: null,
+        issue: null,
         quiet: false,
         skipGh: false,
     };
@@ -52,6 +61,26 @@ export function parseArgs(argv) {
         else if (arg?.startsWith("--tip=")) {
             parsed.tip = arg.slice("--tip=".length);
         }
+        else if (arg === "--issue") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --issue: expected one argument" };
+            }
+            const issue = parseIssueNumber(value);
+            if (issue === null) {
+                return { ...parsed, error: `argument --issue: expected a positive integer, got ${value}` };
+            }
+            parsed.issue = issue;
+            i += 1;
+        }
+        else if (arg?.startsWith("--issue=")) {
+            const value = arg.slice("--issue=".length);
+            const issue = parseIssueNumber(value);
+            if (issue === null) {
+                return { ...parsed, error: `argument --issue: expected a positive integer, got ${value}` };
+            }
+            parsed.issue = issue;
+        }
         else {
             return { ...parsed, error: `unrecognized argument: ${arg}` };
         }
@@ -70,6 +99,7 @@ export function run(argv) {
         quiet: args.quiet,
         repo: args.repo,
         tip: args.tip,
+        issue: args.issue,
         skipGh: args.skipGh,
     });
     if (result.message.length > 0) {

package/dist/verify-literal-ac.js

@@ -128,6 +128,13 @@ export function run(argv) {
                     reason: r.reason,
                     sourceSpan: r.sourceSpan ?? null,
                 })),
+                // Prose-derived captures demoted by structured acceptance commands (#3484).
+                advisory_rejected_count: resolved.advisoryRejected.length,
+                advisory_rejected: resolved.advisoryRejected.map((r) => ({
+                    command: r.command,
+                    reason: r.reason,
+                    sourceSpan: r.sourceSpan ?? null,
+                })),
             };
             process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
             if (resolved.rejected.length > 0) {

package/dist/verify-orphan-active.d.ts

@@ -2,6 +2,7 @@
 interface ParsedArgs {
     projectRoot: string;
     repo: string | null;
+    issue: number | null;
     quiet: boolean;
     skipGh: boolean;
     error?: string;