@deftai/directive 0.95.0 → 0.96.0

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

@@ -70,6 +70,12 @@ export const SUBCOMMAND_ROUTES = {
     "cache:fetch-all": ["cache", "fetch-all"],
     "cache:prune": ["cache", "prune"],
     "cache:clear": ["cache", "clear"],
+    "cache:archive-closed": ["cache", "archive-closed"],
+    "cache:archive-list": ["cache", "archive-list"],
+    "cache:restore-from-archive": ["cache", "restore-from-archive"],
+    "triage:cache-archive": ["cache", "archive-closed"],
+    "triage:archive-list": ["cache", "archive-list"],
+    "triage:restore-from-archive": ["cache", "restore-from-archive"],
     "policy:show": ["policy", "show"],
     "policy:disable-directive": ["policy", "disable-directive"],
     "policy:enable-directive": ["policy", "enable-directive"],

package/dist/triage-actions.d.ts

@@ -9,6 +9,10 @@ interface ParsedArgs {
     comment?: string;
     ofN?: number;
     projectRoot: string;
+    /** After accept+ingest, promote to pending (#1136). */
+    autoPromote?: boolean;
+    /** WIP-cap override for auto-promote leg (#1136). */
+    force?: boolean;
     error?: string;
 }
 /** Parse triage-actions CLI argv mirroring ``triage_actions.py`` argparse. */

package/dist/triage-actions.js

@@ -101,6 +101,12 @@ export function parseArgs(argv) {
         else if (arg?.startsWith("--project-root=")) {
             parsed.projectRoot = arg.slice("--project-root=".length);
         }
+        else if (arg === "--auto-promote") {
+            parsed.autoPromote = true;
+        }
+        else if (arg === "--force") {
+            parsed.force = true;
+        }
         else {
             return { ...parsed, error: `unrecognized argument: ${arg}` };
         }
@@ -144,8 +150,14 @@ export function run(argv) {
     const repo = args.repo;
     try {
         if (args.cmd === "accept") {
-            const decisionId = accept(n, repo, deps, { actor: args.actor, projectRoot });
-            process.stdout.write(`accept #${n} (${repo}) -> ${decisionId}\n`);
+            const decisionId = accept(n, repo, deps, {
+                actor: args.actor,
+                projectRoot,
+                autoPromote: args.autoPromote === true,
+                force: args.force === true,
+            });
+            const promoteNote = args.autoPromote === true ? " + auto-promote" : "";
+            process.stdout.write(`accept #${n} (${repo}) -> ${decisionId}${promoteNote}\n`);
         }
         else if (args.cmd === "reject") {
             const decisionId = reject(n, repo, args.reason ?? "", deps, {

package/dist/triage-classify.d.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { type ResolveAuthenticatedLogin } from "@deftai/directive-core/dist/triage/author-filter.js";
 import type { LabelClient } from "@deftai/directive-core/dist/vbrief-reconcile/types.js";
 export interface ParsedArgs {
     projectRoot: string;
@@ -9,13 +10,25 @@ export interface ParsedArgs {
     json: boolean;
     repo: string | null;
     allowCrossRepo: boolean;
+    /** Opt-in: include closed issues (default open-only, #3125). */
+    includeClosed: boolean;
+    /** Raw --author value (LOGIN, @me, comma allow-list); null = no filter (#3129). */
+    author: string | null;
+    /** Apply batch size (rate-limit awareness). */
+    batchSize: number | null;
+    /** Delay ms between apply batches. */
+    delayMs: number | null;
+    /** Max samples in human digest. */
+    sampleLimit: number | null;
     error?: string;
 }
-/** Parse triage-classify CLI args (#1129 + #1423 Wave 1 mirror flags). */
+/** Parse triage-classify CLI args (#1129 + #1423 Wave 1/2 mirror flags). */
 export declare function parseArgs(argv: string[]): ParsedArgs;
 export interface RunOptions {
     /** Injected LabelClient for tests (apply path). */
     readonly labelClient?: LabelClient;
+    /** Override `@me` resolution for hermetic tests (#3129). */
+    readonly resolveAuthenticatedLogin?: ResolveAuthenticatedLogin;
 }
 /** Run the CLI and return the process exit code. */
 export declare function run(argv: string[], options?: RunOptions): number;

package/dist/triage-classify.js

@@ -2,8 +2,29 @@
 import { statSync } from "node:fs";
 import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { resolveAuthorFilter, } from "@deftai/directive-core/dist/triage/author-filter.js";
 import { labelMirrorOutcomeToJson, listProject, mirrorLabels, renderLabelMirrorReport, validateProject, } from "@deftai/directive-core/dist/triage/classify/index.js";
-/** Parse triage-classify CLI args (#1129 + #1423 Wave 1 mirror flags). */
+function parseNonNegInt(raw, flag) {
+    const n = Number.parseInt(raw, 10);
+    if (!Number.isFinite(n) || String(n) !== raw.trim() || n < 0) {
+        return { error: `argument ${flag}: expected a non-negative integer` };
+    }
+    return { value: n };
+}
+/** Batch size must be >= 1 (0 would silently fall back in core). */
+function parseBatchSize(raw) {
+    const parsed = parseNonNegInt(raw, "--batch-size");
+    if (parsed.error !== undefined) {
+        return parsed;
+    }
+    if ((parsed.value ?? 0) < 1) {
+        return {
+            error: "argument --batch-size: expected an integer >= 1 (omit flag for default 10)",
+        };
+    }
+    return parsed;
+}
+/** Parse triage-classify CLI args (#1129 + #1423 Wave 1/2 mirror flags). */
 export function parseArgs(argv) {
     const parsed = {
         projectRoot: ".",
@@ -14,6 +35,11 @@ export function parseArgs(argv) {
         json: false,
         repo: null,
         allowCrossRepo: false,
+        includeClosed: false,
+        author: null,
+        batchSize: null,
+        delayMs: null,
+        sampleLimit: null,
     };
     for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
@@ -35,6 +61,38 @@ export function parseArgs(argv) {
         else if (arg === "--allow-cross-repo") {
             parsed.allowCrossRepo = true;
         }
+        else if (arg === "--include-closed") {
+            parsed.includeClosed = true;
+        }
+        else if (arg === "--author-mine") {
+            parsed.author = "@me";
+        }
+        else if (arg === "--author") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --author: expected one argument" };
+            }
+            // Reject adjacent flags (e.g. `--author --apply`) so they are not
+            // swallowed as logins (#3129 Greptile P1 adjacent-option).
+            if (value.startsWith("-")) {
+                return {
+                    ...parsed,
+                    error: `argument --author: expected a login (or @me), got flag token '${value}'`,
+                };
+            }
+            parsed.author = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--author=")) {
+            const value = arg.slice("--author=".length);
+            if (value.startsWith("-") && value.length > 1) {
+                return {
+                    ...parsed,
+                    error: `argument --author: expected a login (or @me), got flag token '${value}'`,
+                };
+            }
+            parsed.author = value;
+        }
         else if (arg === "--repo") {
             const value = argv[i + 1];
             if (value === undefined) {
@@ -46,6 +104,63 @@ export function parseArgs(argv) {
         else if (arg?.startsWith("--repo=")) {
             parsed.repo = arg.slice("--repo=".length);
         }
+        else if (arg === "--batch-size") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --batch-size: expected one argument" };
+            }
+            const parsedInt = parseBatchSize(value);
+            if (parsedInt.error !== undefined) {
+                return { ...parsed, error: parsedInt.error };
+            }
+            parsed.batchSize = parsedInt.value ?? null;
+            i += 1;
+        }
+        else if (arg?.startsWith("--batch-size=")) {
+            const parsedInt = parseBatchSize(arg.slice("--batch-size=".length));
+            if (parsedInt.error !== undefined) {
+                return { ...parsed, error: parsedInt.error };
+            }
+            parsed.batchSize = parsedInt.value ?? null;
+        }
+        else if (arg === "--delay-ms") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --delay-ms: expected one argument" };
+            }
+            const parsedInt = parseNonNegInt(value, "--delay-ms");
+            if (parsedInt.error !== undefined) {
+                return { ...parsed, error: parsedInt.error };
+            }
+            parsed.delayMs = parsedInt.value ?? null;
+            i += 1;
+        }
+        else if (arg?.startsWith("--delay-ms=")) {
+            const parsedInt = parseNonNegInt(arg.slice("--delay-ms=".length), "--delay-ms");
+            if (parsedInt.error !== undefined) {
+                return { ...parsed, error: parsedInt.error };
+            }
+            parsed.delayMs = parsedInt.value ?? null;
+        }
+        else if (arg === "--sample-limit") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --sample-limit: expected one argument" };
+            }
+            const parsedInt = parseNonNegInt(value, "--sample-limit");
+            if (parsedInt.error !== undefined) {
+                return { ...parsed, error: parsedInt.error };
+            }
+            parsed.sampleLimit = parsedInt.value ?? null;
+            i += 1;
+        }
+        else if (arg?.startsWith("--sample-limit=")) {
+            const parsedInt = parseNonNegInt(arg.slice("--sample-limit=".length), "--sample-limit");
+            if (parsedInt.error !== undefined) {
+                return { ...parsed, error: parsedInt.error };
+            }
+            parsed.sampleLimit = parsedInt.value ?? null;
+        }
         else if (arg === "--project-root") {
             const value = argv[i + 1];
             if (value === undefined) {
@@ -67,7 +182,18 @@ export function parseArgs(argv) {
     if (parsed.apply && !parsed.doMirror) {
         return {
             ...parsed,
-            error: "--apply requires --mirror (Tier-1 label mirror, #1423)",
+            error: "--apply requires --mirror (Tier-1 label mirror / bootstrap mass-triage, #1423)",
+        };
+    }
+    if ((parsed.includeClosed ||
+        parsed.author !== null ||
+        parsed.batchSize !== null ||
+        parsed.delayMs !== null ||
+        parsed.sampleLimit !== null) &&
+        !parsed.doMirror) {
+        return {
+            ...parsed,
+            error: "--include-closed / --author / --batch-size / --delay-ms / --sample-limit require --mirror (#3125 / #3129)",
         };
     }
     return parsed;
@@ -102,10 +228,26 @@ export function run(argv, options = {}) {
         return result.code;
     }
     if (args.doMirror) {
+        let authorFilter = null;
+        // Flag present (including empty `--author=`) must resolve or fail closed —
+        // never silent no-op that would plan/apply the full open cache (#3129 Greptile P1).
+        if (args.author !== null) {
+            const resolved = resolveAuthorFilter(args.author, options.resolveAuthenticatedLogin);
+            if (resolved.error !== undefined || resolved.filter === undefined) {
+                process.stderr.write(`ERR: ${resolved.error ?? "argument --author: expected a non-empty login (or @me)"}\n`);
+                return 2;
+            }
+            authorFilter = resolved.filter;
+        }
         const mirrorOpts = {
             dryRun: !args.apply,
             repo: args.repo,
             allowCrossRepo: args.allowCrossRepo,
+            includeClosed: args.includeClosed,
+            ...(authorFilter !== null && authorFilter !== undefined ? { authorFilter } : {}),
+            ...(args.batchSize !== null ? { batchSize: args.batchSize } : {}),
+            ...(args.delayMs !== null ? { delayMs: args.delayMs } : {}),
+            ...(args.sampleLimit !== null ? { sampleLimit: args.sampleLimit } : {}),
             ...(options.labelClient !== undefined ? { client: options.labelClient } : {}),
         };
         const [code, outcome] = mirrorLabels(projectRoot, mirrorOpts);

package/dist/triage-queue-fixtures.d.ts

@@ -10,6 +10,8 @@ export interface QueueFixtureIssue {
     readonly labels?: readonly string[];
     readonly updatedAt?: string;
     readonly createdAt?: string;
+    /** Cache author.login for --author filter tests (#3129). */
+    readonly author?: string;
 }
 export interface QueueAuditEntry {
     readonly issueNumber: number;

package/dist/triage-queue-fixtures.js

@@ -25,6 +25,7 @@ function writeCachedIssue(root, repo, issue) {
         labels: (issue.labels ?? []).map((label) => ({ name: label })),
         updated_at: issue.updatedAt ?? "2026-05-17T20:00:00Z",
         ...(issue.createdAt !== undefined ? { created_at: issue.createdAt } : {}),
+        ...(issue.author !== undefined ? { author: { login: issue.author } } : {}),
     };
     writeFileSync(join(dir, "raw.json"), `${JSON.stringify(raw)}\n`, { encoding: "utf8" });
 }

package/dist/triage-queue.d.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { type LiveOpenIssuesReader } from "@deftai/directive-core/dist/triage/queue/index.js";
+import { type LiveOpenIssuesReader, type ResolveAuthenticatedLogin } from "@deftai/directive-core/dist/triage/queue/index.js";
 export type ShowFormat = "default" | "operator";
 interface CommonArgs {
     projectRoot: string;
@@ -14,6 +14,8 @@ interface QueueArgs extends CommonArgs {
     includeBlocked: boolean;
     reconcile: boolean;
     slicesLog: string | null;
+    /** Raw --author value (LOGIN, @me, or comma allow-list); null = no filter (#3129). */
+    author: string | null;
 }
 interface ShowArgs extends CommonArgs {
     cmd: "show";
@@ -24,9 +26,11 @@ interface ShowArgs extends CommonArgs {
 export declare function parseArgs(argv: string[]): QueueArgs;
 /** Parse show subcommand args. */
 export declare function parseShowArgs(argv: string[]): ShowArgs;
-/** Optional injection seam for `run` (tests supply a stub live-open reader). */
+/** Optional injection seams for `run` (tests supply stubs). */
 export interface RunOptions {
     readonly liveOpenReader?: LiveOpenIssuesReader;
+    /** Override `@me` resolution for hermetic tests (#3129). */
+    readonly resolveAuthenticatedLogin?: ResolveAuthenticatedLogin;
 }
 /** Run triage:queue or triage:show and return process exit code. */
 export declare function run(argv: string[], options?: RunOptions): number;

package/dist/triage-queue.js

@@ -13,7 +13,7 @@ import { fileURLToPath } from "node:url";
 import { ensureTriageCacheHydrated } from "@deftai/directive-core/dist/cache/empty-populate.js";
 import { findByIssue } from "@deftai/directive-core/dist/triage/actions/candidates-log.js";
 import { resolveTriageCachePath } from "@deftai/directive-core/dist/triage/cache-path.js";
-import { activeReferencedIssueNumbers, buildQueue, collectOrphanIssueNumbers, DEFAULT_QUEUE_LIMIT, loadCachedIssueDetail, loadCachedIssues, loadSliceRecords, readAuditEntries, reconcileLiveOpenState, renderOperatorBrief, renderQueue, renderShow, resolveRankingLabels, resolveRepo, } from "@deftai/directive-core/dist/triage/queue/index.js";
+import { activeReferencedIssueNumbers, buildQueue, collectOrphanIssueNumbers, DEFAULT_QUEUE_LIMIT, formatAuthorFilterLine, loadCachedIssueDetail, loadCachedIssues, loadSliceRecords, partitionByAuthorFilter, readAuditEntries, reconcileLiveOpenState, renderOperatorBrief, renderQueue, renderShow, resolveAuthorFilter, resolveRankingLabels, resolveRepo, } from "@deftai/directive-core/dist/triage/queue/index.js";
 import { resolveScopeIgnores } from "@deftai/directive-core/dist/triage/scope-drift/index.js";
 function baseArgs() {
     return {
@@ -84,6 +84,7 @@ export function parseArgs(argv) {
         includeBlocked: false,
         reconcile: true,
         slicesLog: null,
+        author: null,
     };
     for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
@@ -98,6 +99,39 @@ export function parseArgs(argv) {
             parsed.reconcile = false;
             continue;
         }
+        if (arg === "--author-mine") {
+            // #1318 Layer 1 optional alias for --author @me
+            parsed.author = "@me";
+            continue;
+        }
+        if (arg === "--author") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --author: expected one argument" };
+            }
+            // Reject adjacent flags (e.g. `--author --limit 10`) so they are not
+            // swallowed as logins (#3129 Greptile P1 adjacent-option).
+            if (value.startsWith("-")) {
+                return {
+                    ...parsed,
+                    error: `argument --author: expected a login (or @me), got flag token '${value}'`,
+                };
+            }
+            parsed.author = value;
+            i += 1;
+            continue;
+        }
+        if (arg?.startsWith("--author=")) {
+            const value = arg.slice("--author=".length);
+            if (value.startsWith("-") && value.length > 1) {
+                return {
+                    ...parsed,
+                    error: `argument --author: expected a login (or @me), got flag token '${value}'`,
+                };
+            }
+            parsed.author = value;
+            continue;
+        }
         const commonHit = parseCommonFlag(arg, argv, i, parsed);
         if (commonHit !== null) {
             if (commonHit.error !== undefined) {
@@ -222,11 +256,30 @@ function runQueue(args, options = {}) {
         process.stderr.write("triage:queue: --repo OWNER/NAME (or $DEFT_TRIAGE_REPO) is required.\n");
         return 2;
     }
+    let authorFilterLine = null;
+    let authorAllow;
+    // Flag present (including empty `--author=`) must resolve or fail closed — never
+    // silent no-op that would show the full queue (#3129 Greptile P1).
+    if (args.author !== null) {
+        const resolved = resolveAuthorFilter(args.author, options.resolveAuthenticatedLogin ?? undefined);
+        if (resolved.error !== undefined || resolved.filter === undefined) {
+            process.stderr.write(`triage:queue: ${resolved.error ?? "argument --author: expected a non-empty login (or @me)"}\n`);
+            return 2;
+        }
+        authorAllow = resolved.filter;
+    }
     ensureTriageCacheHydrated(projectRoot, { repo });
     const cachedForQueue = loadCachedIssues(repo, { projectRoot });
-    const issuesForQueue = args.reconcile
+    let issuesForQueue = args.reconcile
         ? reconcileLiveOpenState(cachedForQueue, repo, options.liveOpenReader)
         : cachedForQueue;
+    if (authorAllow !== undefined) {
+        const partition = partitionByAuthorFilter(issuesForQueue, (row) => row.author ?? null, authorAllow);
+        issuesForQueue = [...partition.matched];
+        authorFilterLine = formatAuthorFilterLine(authorAllow, {
+            unknownCount: partition.unknownCount,
+        });
+    }
     const issuesWithClosed = loadCachedIssues(repo, { projectRoot, includeClosed: true });
     const issuesByNumber = new Map(issuesWithClosed.map((row) => [row.number, row]));
     const auditEntries = readAuditEntries(repo, {
@@ -256,6 +309,7 @@ function runQueue(args, options = {}) {
         repo,
         limit,
         rankingLabels,
+        authorFilterLine,
     })}\n`);
     return 0;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deftai/directive",
-  "version": "0.95.0",
+  "version": "0.96.0",
   "description": "Directive CLI — npm install path for the Deft Directive framework.",
   "license": "MIT",
   "homepage": "https://deftai.github.io/directive/",
@@ -34,8 +34,8 @@
     "provenance": true
   },
   "dependencies": {
-    "@deftai/directive-core": "^0.95.0",
-    "@deftai/directive-content": "^0.95.0"
+    "@deftai/directive-core": "^0.96.0",
+    "@deftai/directive-content": "^0.96.0"
   },
   "scripts": {
     "build": "tsc -b"