@deftai/directive 0.55.2 → 0.56.1

package/dist/cli-router/index.js

@@ -3,6 +3,7 @@
  */
 import { dispatch } from "../dispatch.js";
 import { runInit } from "../init-cli/init.js";
+import { runMigrate } from "../init-cli/migrate.js";
 import { runUpdate } from "../init-cli/update.js";
 import { routeArgv } from "./route-argv.js";
 function defaultIo() {
@@ -32,6 +33,9 @@ export async function routeAndDispatch(argv, io) {
     if (first === "update") {
         return runUpdate(rest, io ?? defaultIo());
     }
+    if (first === "migrate") {
+        return runMigrate(rest, io ?? defaultIo());
+    }
     return dispatch(routed.argv, io);
 }
 //# sourceMappingURL=index.js.map

package/dist/cli-router/route-argv.d.ts

@@ -3,7 +3,7 @@
  * Mirrors the `task <namespace>:<verb>` surface one-to-one.
  */
 /** Top-level UX verbs promoted above the namespace layer (#1670). */
-export declare const TOP_LEVEL_UX_VERBS: readonly ["init", "update", "bootstrap", "check", "doctor", "version", "feature"];
+export declare const TOP_LEVEL_UX_VERBS: readonly ["init", "update", "migrate", "bootstrap", "check", "doctor", "version", "feature"];
 /** Stubbed until a later story lands the handler (#1670 / #11). */
 export declare const STUBBED_TOP_LEVEL_VERBS: Set<string>;
 /** Registered but not yet implemented as TS handlers. */

package/dist/cli-router/route-argv.js

@@ -7,6 +7,7 @@ import { resolveCanonicalVerb } from "../dispatch.js";
 export const TOP_LEVEL_UX_VERBS = [
     "init",
     "update",
+    "migrate",
     "bootstrap",
     "check",
     "doctor",
@@ -90,7 +91,7 @@ function routeTopLevel(first, rest) {
     if (first === "check" || first === "doctor") {
         return { kind: "dispatch", argv: [first, ...rest] };
     }
-    if (first === "init" || first === "update") {
+    if (first === "init" || first === "update" || first === "migrate") {
         return { kind: "dispatch", argv: [first, ...rest] };
     }
     if (STUBBED_TOP_LEVEL_VERBS.has(first)) {

package/dist/dispatch.d.ts

@@ -8,7 +8,7 @@ export interface DispatchIo {
     writeErr: (text: string) => void;
 }
 /** CLI modules in packages/cli/src (excluding parity harnesses and bin/index). */
-export declare const CLI_MODULE_VERBS: readonly ["cache", "check", "capacity-backfill", "capacity-show", "codebase-default-extractor", "codebase-map", "codebase-map-fresh", "codebase-projection-registry", "codebase-provider", "doctor", "parity", "policy", "pr-closing-keywords", "pr-merge-readiness", "pr-monitor", "pr-protected-issues", "pr-wait-mergeable", "preflight-cache", "preflight-gh", "probe-session", "release", "release-e2e", "release-publish", "release-rollback", "scope-lifecycle", "slice", "subagent-monitor", "toolchain-check", "triage-actions", "triage-bootstrap", "triage-bulk", "triage-classify", "triage-help", "triage-queue", "triage-reconcile", "triage-refresh", "triage-scope", "triage-scope-drift", "triage-smoketest", "triage-subscribe", "triage-summary", "triage-welcome", "ts-check-lane", "vbrief-activate", "vbrief-build", "vbrief-preflight", "vbrief-reconcile", "vbrief-validate", "vbrief-validation", "verify-branch", "verify-encoding", "verify-hooks-installed", "verify-investigation", "verify-judgment-gates", "verify-no-task-runtime", "validate-links", "validate-strategy-output", "verify-capacity", "verify-content-manifest", "verify-scm-boundary", "verify-session-ritual", "verify-stubs", "rule-ownership-lint", "verify-story-ready", "verify-tools", "verify-wip-cap"];
+export declare const CLI_MODULE_VERBS: readonly ["cache", "check", "capacity-backfill", "capacity-show", "codebase-default-extractor", "codebase-map", "codebase-map-fresh", "codebase-projection-registry", "codebase-provider", "doctor", "parity", "policy", "pr-closing-keywords", "pr-merge-readiness", "pr-monitor", "pr-protected-issues", "pr-wait-mergeable", "preflight-cache", "preflight-gh", "probe-session", "release", "release-e2e", "release-publish", "release-rollback", "scope-lifecycle", "slice", "subagent-monitor", "toolchain-check", "triage-actions", "triage-bootstrap", "triage-bulk", "triage-classify", "triage-help", "triage-queue", "triage-reconcile", "triage-refresh", "triage-scope", "triage-scope-drift", "triage-smoketest", "triage-subscribe", "triage-summary", "triage-welcome", "ts-check-lane", "vbrief-activate", "vbrief-build", "vbrief-preflight", "vbrief-reconcile", "vbrief-validate", "vbrief-validation", "verify-branch", "verify-encoding", "verify-hooks-installed", "verify-investigation", "verify-judgment-gates", "verify-no-task-runtime", "validate-links", "validate-strategy-output", "verify-bridge-drift", "verify-capacity", "verify-content-manifest", "verify-go-freeze", "verify-scm-boundary", "verify-session-ritual", "verify-stubs", "rule-ownership-lint", "verify-story-ready", "verify-tools", "verify-wip-cap"];
 /** Core-only CLI entrypoints without a packages/cli wrapper. */
 export declare const CORE_MODULE_VERBS: readonly ["scm", "github-auth-modes", "github-body", "issue-emit", "issue-ingest", "reconcile-issues", "swarm-launch", "swarm-complete-cohort", "swarm-readiness", "swarm-routing-verify", "swarm-routing-set", "swarm-verify-review-clean", "swarm-worktrees", "framework-commands", "pack-render", "packs-slice", "prd-render", "project-render", "roadmap-render", "spec-render", "spec-validate", "code-structure-validate", "pack-migrate-skills", "pack-migrate-rules", "pack-migrate-strategies", "pack-migrate-patterns", "pack-migrate-swarm-spec", "policy-set", "scope-undo", "scope-demote", "scope-decompose", "changelog-resolve-unreleased", "architecture-preflight-sor"];
 /** Task-style aliases (framework_commands / Taskfile names). */

package/dist/dispatch.js

@@ -74,8 +74,10 @@ export const CLI_MODULE_VERBS = [
     "verify-no-task-runtime",
     "validate-links",
     "validate-strategy-output",
+    "verify-bridge-drift",
     "verify-capacity",
     "verify-content-manifest",
+    "verify-go-freeze",
     "verify-scm-boundary",
     "verify-session-ritual",
     "verify-stubs",
@@ -140,6 +142,8 @@ export const VERB_ALIASES = {
     "verify:rule-ownership": "rule-ownership-lint",
     "rule:ownership-lint": "rule-ownership-lint",
     "verify:content-manifest": "verify-content-manifest",
+    "verify:go-freeze": "verify-go-freeze",
+    "verify:bridge-drift": "verify-bridge-drift",
     "verify:scm-boundary": "verify-scm-boundary",
     "verify:capacity": "verify-capacity",
     "verify:session-ritual": "verify-session-ritual",
@@ -170,6 +174,8 @@ const SUBDIR_CLI_STEMS = {
     "rule-ownership-lint": "verify-source-cli/rule-ownership-lint",
     "verify-content-manifest": "verify-source-cli/verify-content-manifest",
     "verify-scm-boundary": "verify-source-cli/verify-scm-boundary",
+    "verify-go-freeze": "gates-cli/verify-go-freeze",
+    "verify-bridge-drift": "gates-cli/verify-bridge-drift",
     "validate-links": "content-validate-cli/validate-links",
     "verify-capacity": "content-validate-cli/verify-capacity",
     "validate-strategy-output": "content-validate-cli/validate-strategy-output",

package/dist/gates-cli/verify-bridge-drift.d.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+interface ParsedArgs {
+    projectRoot: string | null;
+    error?: string;
+}
+/** Parse verify-bridge-drift CLI args (#1912). */
+export declare function parseArgs(argv: string[]): ParsedArgs;
+/** Run the cross-surface drift gate and return the process exit code (three-state). */
+export declare function run(argv: string[]): number;
+export {};
+//# sourceMappingURL=verify-bridge-drift.d.ts.map

package/dist/gates-cli/verify-bridge-drift.js

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { evaluateBridgeDrift } from "@deftai/directive-core/legacy-bridge";
+/** Parse verify-bridge-drift CLI args (#1912). */
+export function parseArgs(argv) {
+    const parsed = { projectRoot: null };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--project-root") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --project-root: expected one argument" };
+            }
+            parsed.projectRoot = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--project-root=")) {
+            parsed.projectRoot = arg.slice("--project-root=".length);
+        }
+        else {
+            return { ...parsed, error: `unrecognized argument: ${arg}` };
+        }
+    }
+    return parsed;
+}
+/** Run the cross-surface drift gate and return the process exit code (three-state). */
+export function run(argv) {
+    const args = parseArgs(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`verify_bridge_drift: ${args.error}\n`);
+        return 2;
+    }
+    const root = resolve(args.projectRoot ?? ".");
+    const result = evaluateBridgeDrift(root);
+    if (result.stream === "stdout") {
+        process.stdout.write(`${result.message}\n`);
+    }
+    else {
+        process.stderr.write(`${result.message}\n`);
+    }
+    return result.code;
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=verify-bridge-drift.js.map

package/dist/gates-cli/verify-go-freeze.d.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+interface ParsedArgs {
+    projectRoot: string | null;
+    error?: string;
+}
+/** Parse verify-go-freeze CLI args (#1912). */
+export declare function parseArgs(argv: string[]): ParsedArgs;
+/** Run the freeze gate and return the process exit code (three-state). */
+export declare function run(argv: string[]): number;
+export {};
+//# sourceMappingURL=verify-go-freeze.d.ts.map

package/dist/gates-cli/verify-go-freeze.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { evaluateGoFreeze, FREEZE_BYPASS_ENV } from "@deftai/directive-core/legacy-bridge";
+/** Parse verify-go-freeze CLI args (#1912). */
+export function parseArgs(argv) {
+    const parsed = { projectRoot: null };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--project-root") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --project-root: expected one argument" };
+            }
+            parsed.projectRoot = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--project-root=")) {
+            parsed.projectRoot = arg.slice("--project-root=".length);
+        }
+        else {
+            return { ...parsed, error: `unrecognized argument: ${arg}` };
+        }
+    }
+    return parsed;
+}
+/** Run the freeze gate and return the process exit code (three-state). */
+export function run(argv) {
+    const args = parseArgs(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`verify_go_freeze: ${args.error}\n`);
+        return 2;
+    }
+    const root = resolve(args.projectRoot ?? ".");
+    const allowBump = process.env[FREEZE_BYPASS_ENV] === "1";
+    const result = evaluateGoFreeze(root, { allowBump });
+    if (result.stream === "stdout") {
+        process.stdout.write(`${result.message}\n`);
+    }
+    else {
+        process.stderr.write(`${result.message}\n`);
+    }
+    return result.code;
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=verify-go-freeze.js.map

package/dist/init-cli/constants.d.ts

@@ -2,4 +2,6 @@
 export declare const CANONICAL_INIT_ARGV: readonly ["--yes", "--repo-root", ".", "--json"];
 /** Canonical headless upgrade argv (#1339 / #1409). */
 export declare const CANONICAL_UPDATE_ARGV: readonly ["--yes", "--upgrade", "--repo-root", ".", "--json"];
+/** Canonical migrate argv: defaults to cwd, human-readable unless --json (#1941). */
+export declare const CANONICAL_MIGRATE_ARGV: readonly ["--repo-root", "."];
 //# sourceMappingURL=constants.d.ts.map

package/dist/init-cli/constants.js

@@ -2,4 +2,6 @@
 export const CANONICAL_INIT_ARGV = ["--yes", "--repo-root", ".", "--json"];
 /** Canonical headless upgrade argv (#1339 / #1409). */
 export const CANONICAL_UPDATE_ARGV = ["--yes", "--upgrade", "--repo-root", ".", "--json"];
+/** Canonical migrate argv: defaults to cwd, human-readable unless --json (#1941). */
+export const CANONICAL_MIGRATE_ARGV = ["--repo-root", "."];
 //# sourceMappingURL=constants.js.map

package/dist/init-cli/init.d.ts

@@ -1,3 +1,3 @@
 import type { DispatchIo } from "../dispatch.js";
-export declare function runInit(argv: readonly string[], io: DispatchIo): number;
+export declare function runInit(argv: readonly string[], io: DispatchIo): Promise<number>;
 //# sourceMappingURL=init.d.ts.map

package/dist/init-cli/init.js

@@ -1,11 +1,11 @@
+import { parseInitArgv, runInitDepositCli } from "@deftai/directive-core/init-deposit";
 import { CANONICAL_INIT_ARGV } from "./constants.js";
-import { runDeftInstall } from "./run-deft-install.js";
 export function runInit(argv, io) {
-    return runDeftInstall({
-        verb: "init",
-        canonicalArgv: CANONICAL_INIT_ARGV,
-        userArgv: argv,
-        io,
+    const args = parseInitArgv(CANONICAL_INIT_ARGV, argv);
+    return runInitDepositCli({
+        ...args,
+        writeOut: io.writeOut,
+        writeErr: io.writeErr,
     });
 }
 //# sourceMappingURL=init.js.map

package/dist/init-cli/migrate.d.ts

@@ -0,0 +1,3 @@
+import type { DispatchIo } from "../dispatch.js";
+export declare function runMigrate(argv: readonly string[], io: DispatchIo): number;
+//# sourceMappingURL=migrate.d.ts.map

package/dist/init-cli/migrate.js

@@ -0,0 +1,29 @@
+import { parseInitArgv, runMigrateCli } from "@deftai/directive-core/init-deposit";
+import { CANONICAL_MIGRATE_ARGV } from "./constants.js";
+/**
+ * `directive migrate` (alias `deft migrate`) -- stage-2 provenance verb (#1941):
+ * stamp a canonical-vendored `.deft/core` deposit as npm-managed. Thin wrapper
+ * over the core orchestrator; maps the three-state result to a 0/1/2 exit code.
+ */
+const NO_EFFECT_CONFIRMATION_FLAGS = new Set([
+    "--yes",
+    "--non-interactive",
+    "/yes",
+    "/non-interactive",
+]);
+export function runMigrate(argv, io) {
+    const args = parseInitArgv(CANONICAL_MIGRATE_ARGV, argv);
+    // `migrate` reuses `parseInitArgv`, which understands the init/update headless
+    // confirmation flags. migrate has no interactive prompts, so acknowledge the
+    // flag rather than silently swallowing it (a natural reflex from init/update).
+    if (argv.some((arg) => NO_EFFECT_CONFIRMATION_FLAGS.has(arg))) {
+        io.writeErr("directive migrate: --yes/--non-interactive has no effect (migrate runs non-interactively and never prompts).\n");
+    }
+    return runMigrateCli({
+        projectDir: args.projectDir,
+        jsonOut: args.jsonOut,
+        writeOut: io.writeOut,
+        writeErr: io.writeErr,
+    });
+}
+//# sourceMappingURL=migrate.js.map

package/dist/init-cli/update.d.ts

@@ -1,3 +1,3 @@
 import type { DispatchIo } from "../dispatch.js";
-export declare function runUpdate(argv: readonly string[], io: DispatchIo): number;
+export declare function runUpdate(argv: readonly string[], io: DispatchIo): Promise<number>;
 //# sourceMappingURL=update.d.ts.map

package/dist/init-cli/update.js

@@ -1,11 +1,11 @@
+import { parseUpdateArgv, runRefreshDepositCli } from "@deftai/directive-core/init-deposit";
 import { CANONICAL_UPDATE_ARGV } from "./constants.js";
-import { runDeftInstall } from "./run-deft-install.js";
 export function runUpdate(argv, io) {
-    return runDeftInstall({
-        verb: "update",
-        canonicalArgv: CANONICAL_UPDATE_ARGV,
-        userArgv: argv,
-        io,
+    const args = parseUpdateArgv(CANONICAL_UPDATE_ARGV, argv);
+    return runRefreshDepositCli({
+        ...args,
+        writeOut: io.writeOut,
+        writeErr: io.writeErr,
     });
 }
 //# sourceMappingURL=update.js.map

package/dist/triage-actions-parity.d.ts

@@ -7,6 +7,7 @@ export interface CommandCapture {
 export interface ParityCase {
     readonly name: string;
     readonly argv: readonly string[];
+    readonly seed?: string;
 }
 export interface ParityDiff {
     readonly caseName: string;
@@ -22,6 +23,8 @@ export interface ParityResult {
 }
 /** Strip volatile UUIDs and timestamps before compare. */
 export declare function normalizeOutput(text: string): string;
+/** Keep only operator-facing triage stderr; drop uv/tooling noise from Python spawns. */
+export declare function normalizeStderr(text: string): string;
 /** Build a throwaway project root with an empty audit-log parent directory. */
 export declare function buildFixtureRepo(): string;
 /** Diff one parity case between Python oracle and TS CLI. */

package/dist/triage-actions-parity.js

@@ -11,6 +11,7 @@ import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { cachePut } from "../../core/dist/cache/operations.js";
 /** Strip volatile UUIDs and timestamps before compare. */
 export function normalizeOutput(text) {
     return text
@@ -18,10 +19,26 @@ export function normalizeOutput(text) {
         .replace(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z/g, "<TS>")
         .replace(/Using CPython[^\n]*\n/g, "")
         .replace(/Creating virtual environment[^\n]*\n/g, "")
-        .replace(/Installed \d+ packages[^\n]*\n/g, "");
+        .replace(/Installed \d+ packages[^\n]*\n/g, "")
+        .replace(/Downloading[^\n]*\n/g, "")
+        .replace(/Built[^\n]*\n/g, "")
+        .replace(/triage_actions: needs-ac comment not posted[^\n]*/g, "triage_actions: needs-ac comment not posted <GH-FAIL>");
+}
+/** Keep only operator-facing triage stderr; drop uv/tooling noise from Python spawns. */
+export function normalizeStderr(text) {
+    return normalizeOutput(text)
+        .split("\n")
+        .filter((line) => line.length === 0 || line.startsWith("triage_actions:"))
+        .join("\n");
 }
 function runCapture(cmd, args, cwd, env = {}) {
-    const merged = { ...process.env, ...env };
+    const merged = {
+        ...process.env,
+        ...env,
+        GITHUB_TOKEN: "",
+        GH_TOKEN: "",
+        GH_ENTERPRISE_TOKEN: "",
+    };
     for (const key of Object.keys(merged)) {
         if (merged[key] === undefined)
             delete merged[key];
@@ -59,13 +76,19 @@ function pythonWrapperScript(deftRoot, fixtureRoot) {
         "sys.path.insert(0, str(deft_root / 'scripts'))",
         "import candidates_log as cl",
         "cl.DEFAULT_LOG_PATH = fixture / 'vbrief/.eval/candidates.jsonl'",
+        "import cache as cache_mod",
+        "cache_mod.DEFAULT_CACHE_ROOT = fixture / '.deft-cache'",
         "import triage_actions",
         "triage_actions.candidates_log = cl",
+        "triage_actions.cache = cache_mod",
+        "def _parity_gh(args):",
+        "    raise triage_actions.UpstreamCloseError('gh disabled for parity')",
+        "triage_actions._run_gh = _parity_gh",
         "raise SystemExit(triage_actions.main(sys.argv[1:]))",
     ].join("\n");
 }
 function runPythonTriageAction(deftRoot, fixtureRoot, argv) {
-    const cap = runCapture("uv", ["run", "python", "-c", pythonWrapperScript(deftRoot, fixtureRoot), ...argv], deftRoot, { TRIAGE_PARITY_FIXTURE: fixtureRoot });
+    const cap = runCapture("uv", ["run", "python", "-c", pythonWrapperScript(deftRoot, fixtureRoot), ...argv], deftRoot, { TRIAGE_PARITY_FIXTURE: fixtureRoot, DEFT_TRIAGE_ACTIONS_PARITY: "1" });
     return { exitCode: cap.status, stdout: cap.stdout, stderr: cap.stderr };
 }
 function runTsTriageAction(deftRoot, fixtureRoot, argv) {
@@ -74,15 +97,15 @@ function runTsTriageAction(deftRoot, fixtureRoot, argv) {
         ...argv,
         "--project-root",
         fixtureRoot,
-    ], deftRoot);
+    ], deftRoot, { DEFT_TRIAGE_ACTIONS_PARITY: "1" });
     return { exitCode: cap.status, stdout: cap.stdout, stderr: cap.stderr };
 }
 /** Diff one parity case between Python oracle and TS CLI. */
 export function diffCase(python, ts, caseName) {
     const pyOut = normalizeOutput(python.stdout);
     const tsOut = normalizeOutput(ts.stdout);
-    const pyErr = normalizeOutput(python.stderr);
-    const tsErr = normalizeOutput(ts.stderr);
+    const pyErr = normalizeStderr(python.stderr);
+    const tsErr = normalizeStderr(ts.stderr);
     return {
         caseName,
         exitMismatch: python.exitCode !== ts.exitCode,
@@ -129,6 +152,71 @@ export const PARITY_CASES = [
         name: "accept-idempotent",
         argv: ["accept", "--issue", "9", "--repo", "deftai/directive", "--actor", "agent:test"],
     },
+    {
+        name: "needs-ac-default",
+        argv: ["needs-ac", "--issue", "10", "--repo", "deftai/directive", "--actor", "agent:test"],
+    },
+    {
+        name: "status-empty",
+        argv: ["status", "--issue", "11", "--repo", "deftai/directive"],
+    },
+    {
+        name: "status-with-defer",
+        argv: ["status", "--issue", "12", "--repo", "deftai/directive"],
+        seed: "defer-status",
+    },
+    {
+        name: "reset-no-prior",
+        argv: ["reset", "--issue", "13", "--repo", "deftai/directive"],
+    },
+    {
+        name: "reset-success",
+        argv: ["reset", "--issue", "14", "--repo", "deftai/directive", "--actor", "agent:test"],
+        seed: "defer-reset",
+    },
+    {
+        name: "reset-idempotent",
+        argv: ["reset", "--issue", "15", "--repo", "deftai/directive"],
+        seed: "reset-idempotent",
+    },
+    {
+        name: "history-empty",
+        argv: ["history", "--issue", "16", "--repo", "deftai/directive"],
+    },
+    {
+        name: "history-multi",
+        argv: ["history", "--issue", "17", "--repo", "deftai/directive"],
+        seed: "history-multi",
+    },
+    {
+        name: "mark-duplicate-missing-cache",
+        argv: ["mark-duplicate", "--issue", "18", "--repo", "deftai/directive", "--of", "99"],
+    },
+    {
+        name: "mark-duplicate-success",
+        argv: [
+            "mark-duplicate",
+            "--issue",
+            "19",
+            "--repo",
+            "deftai/directive",
+            "--of",
+            "20",
+            "--actor",
+            "agent:test",
+        ],
+        seed: "mark-duplicate-cache",
+    },
+    {
+        name: "mark-duplicate-idempotent",
+        argv: ["mark-duplicate", "--issue", "21", "--repo", "deftai/directive", "--of", "22"],
+        seed: "mark-duplicate-idempotent",
+    },
+    {
+        name: "mark-duplicate-self",
+        argv: ["mark-duplicate", "--issue", "23", "--repo", "deftai/directive", "--of", "23"],
+        seed: "mark-duplicate-cache-self",
+    },
 ];
 function seedAcceptFixture(fixtureRoot) {
     const entry = {
@@ -141,6 +229,69 @@ function seedAcceptFixture(fixtureRoot) {
     };
     writeFileSync(join(fixtureRoot, "vbrief/.eval/candidates.jsonl"), `${JSON.stringify(entry, Object.keys(entry).sort())}\n`, "utf8");
 }
+function seedAuditEntry(fixtureRoot, issueNumber, decision, extras = {}) {
+    const entry = {
+        actor: "agent:test",
+        decision,
+        decision_id: "11111111-1111-1111-1111-111111111111",
+        issue_number: issueNumber,
+        repo: "deftai/directive",
+        timestamp: "2026-06-18T12:00:00Z",
+        ...extras,
+    };
+    const path = join(fixtureRoot, "vbrief/.eval/candidates.jsonl");
+    const line = `${JSON.stringify(entry, Object.keys(entry).sort())}\n`;
+    writeFileSync(path, line, { encoding: "utf8", flag: "a" });
+}
+function seedCacheIssue(fixtureRoot, issueNumber) {
+    const cacheRoot = join(fixtureRoot, ".deft-cache");
+    cachePut("github-issue", `deftai/directive/${issueNumber}`, { number: issueNumber, title: "parity fixture", body: "fixture body" }, { cacheRoot });
+}
+function seedFixture(fixtureRoot, seed) {
+    if (seed === undefined)
+        return;
+    switch (seed) {
+        case "defer-status":
+            seedAuditEntry(fixtureRoot, 12, "defer", { reason: "later" });
+            break;
+        case "defer-reset":
+            seedAuditEntry(fixtureRoot, 14, "defer", { reason: "later" });
+            break;
+        case "reset-idempotent":
+            seedAuditEntry(fixtureRoot, 15, "reset", {
+                decision_id: "22222222-2222-2222-2222-222222222222",
+                prior_decision_id: "11111111-1111-1111-1111-111111111111",
+            });
+            break;
+        case "history-multi":
+            seedAuditEntry(fixtureRoot, 17, "defer", {
+                decision_id: "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa",
+                reason: "first",
+                timestamp: "2026-06-18T10:00:00Z",
+            });
+            seedAuditEntry(fixtureRoot, 17, "needs-ac", {
+                decision_id: "bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb",
+                reason: "needs criteria",
+                timestamp: "2026-06-18T11:00:00Z",
+            });
+            break;
+        case "mark-duplicate-cache":
+            seedCacheIssue(fixtureRoot, 20);
+            break;
+        case "mark-duplicate-idempotent":
+            seedCacheIssue(fixtureRoot, 22);
+            seedAuditEntry(fixtureRoot, 21, "mark-duplicate", {
+                decision_id: "cccccccc-cccc-cccc-cccc-cccccccccccc",
+                linked_to: 22,
+            });
+            break;
+        case "mark-duplicate-cache-self":
+            seedCacheIssue(fixtureRoot, 23);
+            break;
+        default:
+            break;
+    }
+}
 /** Run all parity cases; returns aggregate result. */
 export function runParity() {
     const deftRoot = resolveDeftRoot();
@@ -152,6 +303,10 @@ export function runParity() {
             seedAcceptFixture(pyFixture);
             seedAcceptFixture(tsFixture);
         }
+        else {
+            seedFixture(pyFixture, testCase.seed);
+            seedFixture(tsFixture, testCase.seed);
+        }
         try {
             const python = runPythonTriageAction(deftRoot, pyFixture, testCase.argv);
             const ts = runTsTriageAction(deftRoot, tsFixture, testCase.argv);

package/dist/triage-actions.d.ts

@@ -6,6 +6,8 @@ interface ParsedArgs {
     reason?: string;
     resumeOn?: string;
     actor?: string;
+    comment?: string;
+    ofN?: number;
     projectRoot: string;
     error?: string;
 }

package/dist/triage-actions.js

@@ -1,7 +1,17 @@
 #!/usr/bin/env node
 import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { accept, createDefaultDeps, deferAction, reject, TriageError, UpstreamCloseError, } from "../../core/dist/triage/actions/index.js";
+import { accept, createDefaultDeps, deferAction, formatDecision, history, markDuplicate, needsAc, reject, reset, status, TriageError, UpstreamCloseError, } from "../../core/dist/triage/actions/index.js";
+const VALID_CMDS = new Set([
+    "accept",
+    "reject",
+    "defer",
+    "needs-ac",
+    "mark-duplicate",
+    "status",
+    "reset",
+    "history",
+]);
 /** Parse triage-actions CLI argv mirroring ``triage_actions.py`` argparse. */
 export function parseArgs(argv) {
     const parsed = { projectRoot: process.cwd() };
@@ -61,6 +71,26 @@ export function parseArgs(argv) {
         else if (arg?.startsWith("--actor=")) {
             parsed.actor = arg.slice("--actor=".length);
         }
+        else if (arg === "--comment") {
+            const value = argv[i + 1];
+            if (value === undefined)
+                return { ...parsed, error: "argument --comment: expected one argument" };
+            parsed.comment = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--comment=")) {
+            parsed.comment = arg.slice("--comment=".length);
+        }
+        else if (arg === "--of") {
+            const value = argv[i + 1];
+            if (value === undefined)
+                return { ...parsed, error: "argument --of: expected one argument" };
+            parsed.ofN = Number.parseInt(value, 10);
+            i += 1;
+        }
+        else if (arg?.startsWith("--of=")) {
+            parsed.ofN = Number.parseInt(arg.slice("--of=".length), 10);
+        }
         else if (arg === "--project-root") {
             const value = argv[i + 1];
             if (value === undefined)
@@ -84,7 +114,7 @@ export function run(argv) {
         process.stderr.write(`triage_actions: ${args.error}\n`);
         return 2;
     }
-    if (args.cmd !== "accept" && args.cmd !== "reject" && args.cmd !== "defer") {
+    if (!VALID_CMDS.has(args.cmd ?? "")) {
         process.stderr.write(`triage_actions: unknown subcommand ${args.cmd ?? ""}\n`);
         return 2;
     }
@@ -104,6 +134,10 @@ export function run(argv) {
         process.stderr.write("triage_actions: argument --reason: expected one argument\n");
         return 2;
     }
+    if (args.cmd === "mark-duplicate" && (args.ofN === undefined || Number.isNaN(args.ofN))) {
+        process.stderr.write("triage_actions: argument --of: expected one argument\n");
+        return 2;
+    }
     const projectRoot = resolve(args.projectRoot);
     const deps = createDefaultDeps(projectRoot);
     const n = args.issue;
@@ -120,7 +154,7 @@ export function run(argv) {
             });
             process.stdout.write(`reject #${n} (${repo}) -> ${decisionId}\n`);
         }
-        else {
+        else if (args.cmd === "defer") {
             const decisionId = deferAction(n, repo, args.reason, deps, {
                 actor: args.actor,
                 resumeOn: args.resumeOn,
@@ -128,6 +162,40 @@ export function run(argv) {
             });
             process.stdout.write(`defer #${n} (${repo}) -> ${decisionId}\n`);
         }
+        else if (args.cmd === "needs-ac") {
+            const decisionId = needsAc(n, repo, deps, {
+                actor: args.actor,
+                comment: args.comment,
+                projectRoot,
+            });
+            process.stdout.write(`needs-ac #${n} (${repo}) -> ${decisionId}\n`);
+        }
+        else if (args.cmd === "mark-duplicate") {
+            const ofN = args.ofN;
+            const decisionId = markDuplicate(n, repo, ofN, deps, {
+                actor: args.actor,
+                projectRoot,
+            });
+            process.stdout.write(`mark-duplicate #${n} -> #${ofN} (${repo}) -> ${decisionId}\n`);
+        }
+        else if (args.cmd === "status") {
+            process.stdout.write(`${formatDecision(status(n, repo, deps, { projectRoot }))}\n`);
+        }
+        else if (args.cmd === "reset") {
+            const decisionId = reset(n, repo, deps, { actor: args.actor, projectRoot });
+            process.stdout.write(`reset #${n} (${repo}) -> ${decisionId}\n`);
+        }
+        else {
+            const entries = history(n, repo, deps, { projectRoot });
+            if (entries.length === 0) {
+                process.stdout.write(`${formatDecision(null)}\n`);
+            }
+            else {
+                for (const entry of entries) {
+                    process.stdout.write(`${formatDecision(entry)}\n`);
+                }
+            }
+        }
     }
     catch (err) {
         if (err instanceof TriageError || err instanceof UpstreamCloseError) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deftai/directive",
-  "version": "0.55.2",
+  "version": "0.56.1",
   "description": "Directive CLI — npm install path for the Deft Directive framework.",
   "type": "module",
   "main": "./dist/index.js",
@@ -42,7 +42,8 @@
     "provenance": true
   },
   "dependencies": {
-    "@deftai/directive-core": "^0.55.2"
+    "@deftai/directive-core": "^0.56.1",
+    "@deftai/directive-content": "^0.56.1"
   },
   "scripts": {
     "build": "tsc -b"