@deftai/directive-core 0.69.0 → 0.70.0

package/dist/intake/issue-ingest.js

@@ -1,6 +1,7 @@
 import { mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { basename, join, resolve } from "node:path";
 import { cacheGet } from "../cache/operations.js";
+import { scan } from "../cache/scanner.js";
 import { hasArtifactSuffix, resolveLifecycleRoot } from "../layout/resolve.js";
 import { call } from "../scm/call.js";
 import { resolveProjectRoot } from "../scope/project-context.js";
@@ -11,6 +12,27 @@ import { LEGACY_ARTIFACT_SUFFIX, LEGACY_INFO_ROOT_KEY, LEGACY_VBRIEF_VERSION, MI
 import { findAcHeading, parseCheckboxItems, parseListItems, sliceAcSection, stripCodeBlocks, stripFencedCodeBlocks, } from "./markdown-scanners.js";
 import { detectRepo, extractReferencesFromVbrief, fetchOpenIssues, GITHUB_ISSUE_REF_TYPES, LIFECYCLE_FOLDERS, parseIssueNumber, } from "./reconcile-issues.js";
 export const INGEST_STATUSES = ["proposed", "pending", "active"];
+/**
+ * Thrown when the quarantine scanner hard-fails (credential-shaped content) on
+ * an ingested issue body/comment thread (#2306). Ingest MUST fail closed: emit
+ * nothing and propagate a non-zero exit rather than persisting the xBRIEF.
+ */
+export class ScannerHardFailError extends Error {
+    issueNumber;
+    flags;
+    constructor(issueNumber, flags) {
+        const details = flags
+            .filter((f) => f.severity === "hard-fail")
+            .map((f) => f.detail)
+            .join("; ");
+        super(`issue:ingest refused #${issueNumber}: quarantine scanner hard-fail` +
+            (details.length > 0 ? ` (${details})` : "") +
+            " -- nothing written.");
+        this.name = "ScannerHardFailError";
+        this.issueNumber = issueNumber;
+        this.flags = flags;
+    }
+}
 /** Enriched on issues after `fetchIssue` when the comment thread is non-empty (#2143). */
 export const ISSUE_COMMENT_THREAD_KEY = "issueCommentThread";
 const STATUS_MAP = {
@@ -311,7 +333,14 @@ export function buildIssueVbrief(issue, status, repoUrl, options = {}) {
     };
     if (overviewSource.length > 0) {
         warnBodyControlCharacters(number, overviewSource);
-        narratives.Overview = overviewSource;
+        // #2306: quarantine-scan untrusted body + comment-thread content before it
+        // is persisted as agent-facing scope authority. Fail closed on a credential
+        // hard-fail; otherwise persist the fenced/quarantined transform.
+        const scanResult = scan(overviewSource);
+        if (!scanResult.passed) {
+            throw new ScannerHardFailError(number, scanResult.flags);
+        }
+        narratives.Overview = scanResult.transformed_content;
     }
     if (labelNames.length > 0) {
         narratives.Labels = labelNames.join(", ");
@@ -369,6 +398,19 @@ export function fetchFromCache(repo, number, options = {}) {
         if (typeof issue.html_url === "string" && issue.html_url.length > 0) {
             issue.url = issue.html_url;
         }
+        // #2306: consume the cache entry's SCANNED content.md (fenced/quarantined at
+        // cache-put) rather than the raw body, so the cache read path cannot bypass
+        // the quarantine transform. When content.md is absent (e.g. a credential
+        // hard-fail deleted it), the raw body falls through and is re-scanned in
+        // buildIssueVbrief.
+        if (result.contentPath !== null) {
+            try {
+                issue.body = readFileSync(result.contentPath, "utf8");
+            }
+            catch {
+                // fall back to the raw body (re-scanned downstream)
+            }
+        }
         return issue;
     }
     catch {
@@ -514,9 +556,25 @@ export function ingestBulk(issues, options) {
         created: [],
         duplicate: [],
         dryrun: [],
+        failed: [],
     };
     for (const issue of filtered) {
-        const [result, path, _msg] = ingestOne(issue, { ...options, existingRefs: refs });
+        let ingested;
+        try {
+            ingested = ingestOne(issue, { ...options, existingRefs: refs });
+        }
+        catch (exc) {
+            // #2306: a per-issue quarantine hard-fail must not sink the whole batch;
+            // record it, emit nothing for that issue, and surface a non-zero exit
+            // upstream via the `failed` bucket.
+            if (exc instanceof ScannerHardFailError) {
+                summary.failed.push(`#${exc.issueNumber}`);
+                process.stderr.write(`${exc.message}\n`);
+                continue;
+            }
+            throw exc;
+        }
+        const [result, path, _msg] = ingested;
         const rel = path !== null ? path.replace(`${options.vbriefDir}/`, "").replace(/\\/g, "/") : "";
         summary[result].push(rel);
         if (result === "created" && path !== null) {
@@ -581,7 +639,8 @@ export function issueIngestMain(args) {
         const created = summary.created;
         const duplicate = summary.duplicate;
         const dryrun = summary.dryrun;
-        process.stdout.write(`issue:ingest bulk summary: ${created.length} created, ${duplicate.length} duplicate, ${dryrun.length} dry-run (total considered: ${summary.total})\n`);
+        const failed = summary.failed ?? [];
+        process.stdout.write(`issue:ingest bulk summary: ${created.length} created, ${duplicate.length} duplicate, ${dryrun.length} dry-run, ${failed.length} refused (total considered: ${summary.total})\n`);
         for (const entry of created) {
             process.stdout.write(`  CREATED ${entry}\n`);
         }
@@ -591,19 +650,35 @@ export function issueIngestMain(args) {
         for (const entry of duplicate) {
             process.stdout.write(`  SKIP    ${entry} (already has scope vBRIEF)\n`);
         }
-        return 0;
+        for (const entry of failed) {
+            process.stdout.write(`  REFUSED ${entry} (quarantine scanner hard-fail; nothing written)\n`);
+        }
+        // #2306: fail closed on any quarantine hard-fail in the batch.
+        return failed.length > 0 ? 2 : 0;
     }
     const issue = fetchIssue(repo, args.number, { cwd: projectRoot });
     if (issue === null) {
         return 2;
     }
-    const [result, _path, msg] = ingestOne(issue, {
-        vbriefDir,
-        status,
-        repoUrl,
-        dryRun: args.dryRun,
-        cwd: projectRoot,
-    });
+    let result;
+    let msg;
+    try {
+        [result, , msg] = ingestOne(issue, {
+            vbriefDir,
+            status,
+            repoUrl,
+            dryRun: args.dryRun,
+            cwd: projectRoot,
+        });
+    }
+    catch (exc) {
+        // #2306: fail closed -- emit nothing, non-zero exit on a quarantine hard-fail.
+        if (exc instanceof ScannerHardFailError) {
+            process.stderr.write(`${exc.message}\n`);
+            return 2;
+        }
+        throw exc;
+    }
     process.stdout.write(`${msg}\n`);
     return result === "duplicate" ? 1 : 0;
 }

package/dist/policy/plan-extensions.d.ts

@@ -32,4 +32,35 @@ export declare function readPlanCompletedNote(plan: unknown): unknown;
  * bare block alongside the namespaced one.
  */
 export declare function migrateLegacyPolicyKey(plan: Record<string, unknown>): void;
+/** The namespaced/legacy key pairs a bare block can silently shadow (#2301). */
+export declare const SHADOWABLE_PLAN_EXTENSIONS: ReadonlyArray<{
+    readonly namespacedKey: string;
+    readonly legacyKey: string;
+}>;
+/** A plan-extension key whose bare form is silently shadowed by the namespaced form. */
+export interface ShadowedPlanExtension {
+    /** The namespaced key that wins the read (e.g. `x-directive/policy`). */
+    readonly namespacedKey: string;
+    /** The bare legacy key that is silently ignored (e.g. `policy`). */
+    readonly legacyKey: string;
+    /**
+     * Best-effort list of sub-keys present in the shadowed bare object (e.g.
+     * `["triageScope", "wipCap"]`). Empty when the bare value is not an object.
+     */
+    readonly shadowedSubKeys: readonly string[];
+}
+/**
+ * Detect every plan-extension key where a bare (legacy) block coexists with the
+ * namespaced form (#2301). Because `readPlanExtension` is namespace-first, the
+ * bare block is never read once the namespaced key exists -- edits to it take no
+ * effect. Detecting the coexistence lets callers emit a loud diagnostic instead
+ * of the silent no-op that the #2295 onboarding trap exhibited.
+ */
+export declare function detectShadowedPlanExtensions(plan: unknown): ShadowedPlanExtension[];
+/**
+ * Render a human-readable, loud diagnostic for a single shadowed plan-extension
+ * key. The message is surface-agnostic (no leading tag) so each caller can
+ * prefix it (`[policy:show]`, a doctor finding, ...).
+ */
+export declare function describeShadowedPlanExtension(shadow: ShadowedPlanExtension): string;
 //# sourceMappingURL=plan-extensions.d.ts.map

package/dist/policy/plan-extensions.js

@@ -54,4 +54,49 @@ export function migrateLegacyPolicyKey(plan) {
         delete plan[LEGACY_PLAN_POLICY_KEY];
     }
 }
+/** The namespaced/legacy key pairs a bare block can silently shadow (#2301). */
+export const SHADOWABLE_PLAN_EXTENSIONS = [
+    { namespacedKey: PLAN_POLICY_KEY, legacyKey: LEGACY_PLAN_POLICY_KEY },
+    { namespacedKey: PLAN_COMPLETED_NOTE_KEY, legacyKey: LEGACY_PLAN_COMPLETED_NOTE_KEY },
+];
+/**
+ * Detect every plan-extension key where a bare (legacy) block coexists with the
+ * namespaced form (#2301). Because `readPlanExtension` is namespace-first, the
+ * bare block is never read once the namespaced key exists -- edits to it take no
+ * effect. Detecting the coexistence lets callers emit a loud diagnostic instead
+ * of the silent no-op that the #2295 onboarding trap exhibited.
+ */
+export function detectShadowedPlanExtensions(plan) {
+    const planObj = asPlanObject(plan);
+    if (planObj === null) {
+        return [];
+    }
+    const shadows = [];
+    for (const { namespacedKey, legacyKey } of SHADOWABLE_PLAN_EXTENSIONS) {
+        if (planObj[namespacedKey] === undefined || planObj[legacyKey] === undefined) {
+            continue;
+        }
+        const legacyValue = planObj[legacyKey];
+        const shadowedSubKeys = typeof legacyValue === "object" && legacyValue !== null && !Array.isArray(legacyValue)
+            ? Object.keys(legacyValue)
+            : [];
+        shadows.push({ namespacedKey, legacyKey, shadowedSubKeys });
+    }
+    return shadows;
+}
+/**
+ * Render a human-readable, loud diagnostic for a single shadowed plan-extension
+ * key. The message is surface-agnostic (no leading tag) so each caller can
+ * prefix it (`[policy:show]`, a doctor finding, ...).
+ */
+export function describeShadowedPlanExtension(shadow) {
+    const subKeys = shadow.shadowedSubKeys.length > 0
+        ? ` Shadowed field(s): ${shadow.shadowedSubKeys
+            .map((k) => `plan.${shadow.legacyKey}.${k}`)
+            .join(", ")}.`
+        : "";
+    return (`bare \`plan.${shadow.legacyKey}\` coexists with namespaced \`plan.${shadow.namespacedKey}\`; ` +
+        `the bare block is IGNORED (namespaced-first read) so edits to it silently take no effect.${subKeys} ` +
+        `Fold its values into \`plan.${shadow.namespacedKey}\` and delete \`plan.${shadow.legacyKey}\`.`);
+}
 //# sourceMappingURL=plan-extensions.js.map

package/dist/policy/wip.d.ts

@@ -1,5 +1,5 @@
-/** Framework default WIP cap (#1124 / umbrella #1119). */
-export declare const DEFAULT_WIP_CAP = 10;
+/** Framework default WIP cap (#2319; raised from 10 per #1124 / umbrella #1119). */
+export declare const DEFAULT_WIP_CAP = 20;
 /** vBRIEF lifecycle folders that count toward the WIP set. */
 export declare const WIP_LIFECYCLE_DIRS: readonly ["pending", "active"];
 export type WipCapSource = "typed" | "default" | "default-on-error";

package/dist/policy/wip.js

@@ -3,8 +3,8 @@ import { join } from "node:path";
 import { hasArtifactSuffix, resolveLifecycleRoot } from "../layout/resolve.js";
 import { readPlanPolicy } from "./plan-extensions.js";
 import { loadProjectDefinition } from "./resolve.js";
-/** Framework default WIP cap (#1124 / umbrella #1119). */
-export const DEFAULT_WIP_CAP = 10;
+/** Framework default WIP cap (#2319; raised from 10 per #1124 / umbrella #1119). */
+export const DEFAULT_WIP_CAP = 20;
 /** vBRIEF lifecycle folders that count toward the WIP set. */
 export const WIP_LIFECYCLE_DIRS = ["pending", "active"];
 function pythonTypeName(value) {

package/dist/swarm/routing.js

@@ -186,7 +186,9 @@ export function resolveDispatchProvider(environ = process.env) {
  * Keys that would mutate the prototype chain rather than set an own property
  * if used as a computed object key. Rejected for provider/role names so a
  * malicious routing input cannot pollute `Object.prototype` (CodeQL
- * js/prototype-polluting-assignment).
+ * js/prototype-polluting-assignment). This validation guard produces the
+ * caller-facing error; the null-prototype write targets in
+ * `writeModelDecision` are the structural backstop CodeQL recognizes.
  */
 const FORBIDDEN_ROUTING_KEYS = new Set(["__proto__", "constructor", "prototype"]);
 function assertSafeRoutingKey(kind, key) {
@@ -203,9 +205,14 @@ export function writeModelDecision(path, provider, role, decision) {
     assertSafeRoutingKey("provider", provider);
     assertSafeRoutingKey("role", role);
     const { data } = loadRoutingFile(path);
-    const file = data ?? {};
+    // Null-prototype write targets so a computed provider/role key can only ever
+    // set an own property and can never reach `Object.prototype`, even if the
+    // validation guard above regresses. CodeQL's js/prototype-polluting-assignment
+    // barrier does not track the interprocedural `assertSafeRoutingKey` guard, so
+    // this structural sink is what closes alert #52.
+    const file = Object.assign(Object.create(null), data ?? {});
     const existing = providerBlockOf(file, provider);
-    const block = existing ?? {};
+    const block = Object.assign(Object.create(null), existing ?? {});
     block[role] = {
         model: decision.model,
         mode: decision.mode ??

package/dist/triage/bulk/index.d.ts

@@ -88,12 +88,21 @@ export declare function excludeLogged(candidates: Iterable<IssuePayload>, option
 export declare function bulkAction(actionKey: string, repo: string, options?: BulkActionOptions): number;
 export declare function createFilesystemCacheModule(): CacheModule;
 export declare function createFilesystemCandidatesLogModule(logPath?: string): CandidatesLogModule;
+/**
+ * Native TypeScript bulk actions module (#2279).
+ *
+ * The bulk path defaults to this factory instead of {@link createPythonActionsModule}
+ * so `triage:bulk-*` never spawns a project-local `scripts/triage_actions.py`
+ * (an arbitrary-code-execution trust boundary a malicious checkout could plant).
+ * Each verb delegates to the already-native per-issue triage actions
+ * (`@deftai/directive-core/triage/actions`, #1725) bound to `createDefaultDeps(projectRoot)`.
+ */
+export declare function createNativeActionsModule(projectRoot: string): TriageActionsModule;
 export declare function createPythonActionsModule(scriptsDir: string): TriageActionsModule;
 export interface DefaultBulkDepsOptions {
     readonly cacheRoot?: string;
     readonly candidatesLogPath?: string;
-    readonly scriptsDir?: string;
-    readonly deftRoot?: string;
+    readonly projectRoot?: string;
 }
 export declare function bulkActionWithDefaults(actionKey: string, repo: string, options?: BulkActionOptions & DefaultBulkDepsOptions): number;
 //# sourceMappingURL=index.d.ts.map

package/dist/triage/bulk/index.js

@@ -2,6 +2,7 @@ import { spawnSync } from "node:child_process";
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { resolveEvalPath } from "../../layout/resolve.js";
+import { createDefaultDeps, accept as nativeAccept, deferAction as nativeDefer, needsAc as nativeNeedsAc, reject as nativeReject, } from "../actions/index.js";
 export const ACTION_FN_NAMES = {
     accept: "accept",
     reject: "reject",
@@ -402,6 +403,40 @@ export function createFilesystemCandidatesLogModule(logPath = resolveEvalPath(pr
         },
     };
 }
+/**
+ * Native TypeScript bulk actions module (#2279).
+ *
+ * The bulk path defaults to this factory instead of {@link createPythonActionsModule}
+ * so `triage:bulk-*` never spawns a project-local `scripts/triage_actions.py`
+ * (an arbitrary-code-execution trust boundary a malicious checkout could plant).
+ * Each verb delegates to the already-native per-issue triage actions
+ * (`@deftai/directive-core/triage/actions`, #1725) bound to `createDefaultDeps(projectRoot)`.
+ */
+export function createNativeActionsModule(projectRoot) {
+    const deps = createDefaultDeps(projectRoot);
+    return {
+        accept(n, repo) {
+            nativeAccept(n, repo, deps, { projectRoot });
+        },
+        reject(n, repo, ...args) {
+            let reason = "";
+            const first = args[0];
+            if (typeof first === "object" && first !== null && "reason" in first) {
+                reason = String(first.reason);
+            }
+            else if (typeof first === "string") {
+                reason = first;
+            }
+            nativeReject(n, repo, reason, deps, { projectRoot });
+        },
+        defer(n, repo) {
+            nativeDefer(n, repo, "bulk defer", deps, { projectRoot });
+        },
+        needs_ac(n, repo) {
+            nativeNeedsAc(n, repo, deps, { projectRoot });
+        },
+    };
+}
 export function createPythonActionsModule(scriptsDir) {
     const runAction = (cmd, issueNumber, repo, extra = []) => {
         const result = spawnSync("uv", [
@@ -442,14 +477,16 @@ export function createPythonActionsModule(scriptsDir) {
     };
 }
 export function bulkActionWithDefaults(actionKey, repo, options = {}) {
-    const deftRoot = options.deftRoot ?? process.cwd();
-    const scriptsDir = options.scriptsDir ?? join(deftRoot, "scripts");
+    // #2279: the bulk path no longer resolves a `scripts/` dir from DEFT_ROOT /
+    // the project cwd. It defaults to the native TypeScript actions module so a
+    // malicious project-local `scripts/triage_actions.py` can never be executed.
+    const projectRoot = options.projectRoot ?? process.cwd();
     return bulkAction(actionKey, repo, {
         ...options,
-        cacheRoot: options.cacheRoot ?? join(deftRoot, ".deft-cache"),
+        cacheRoot: options.cacheRoot ?? join(projectRoot, ".deft-cache"),
         cacheModule: options.cacheModule ?? createFilesystemCacheModule(),
         candidatesLogModule: options.candidatesLogModule ?? createFilesystemCandidatesLogModule(options.candidatesLogPath),
-        actionsModule: options.actionsModule ?? createPythonActionsModule(scriptsDir),
+        actionsModule: options.actionsModule ?? createNativeActionsModule(projectRoot),
     });
 }
 //# sourceMappingURL=index.js.map

package/dist/triage/help/registry-data.d.ts

@@ -191,11 +191,11 @@ export declare const registryData: {
         readonly "task triage:welcome": {
             readonly name: "task triage:welcome";
             readonly summary: "Single-entry-point upgrade ritual";
-            readonly refs: "(N3 / #1143)";
-            readonly description: "6-phase onboarding ritual: detect prior state, prompt for subscription scope, run triage:bootstrap, prompt for wipCap, offer WIP relief, print triage:summary. Idempotent on re-run; safe entrypoint for fresh consumers.";
-            readonly usage: "task triage:welcome [-- --no-subprocess]";
-            readonly flags: readonly [readonly ["--no-subprocess", "(off)", "Dry-mode: don't shell out to sibling tasks."]];
-            readonly examples: readonly ["task triage:welcome"];
+            readonly refs: "(N3 / #1143, #2295)";
+            readonly description: "6-phase onboarding ritual: detect prior state, prompt for subscription scope, run triage:bootstrap, prompt for wipCap, offer WIP relief, print triage:summary. Idempotent on re-run; safe entrypoint for fresh consumers. Pass --onboard for the non-interactive path that applies a triage-scope preset (and optional --wip-cap) without prompting -- the form agents/CI use.";
+            readonly usage: "task triage:welcome [-- --onboard [--preset small|mid|mega] [--wip-cap N]] [--no-subprocess]";
+            readonly flags: readonly [readonly ["--onboard", "(off)", "Non-interactive onboarding: apply a triage-scope preset (and optional WIP cap) without prompting."], readonly ["--preset small|mid|mega", "small", "Subscription-scope preset applied by --onboard."], readonly ["--wip-cap N", "(policy default)", "Persist an explicit in-flight scope cap during --onboard (positive integer)."], readonly ["--no-subprocess", "(off)", "Dry-mode: don't shell out to sibling tasks."]];
+            readonly examples: readonly ["task triage:welcome", "task triage:welcome -- --onboard --preset small"];
             readonly see_also: readonly ["task triage:bootstrap", "task triage:summary", "#1119 / N3"];
             readonly placeholder: false;
         };

package/dist/triage/help/registry-data.js

@@ -296,11 +296,24 @@ export const registryData = {
         "task triage:welcome": {
             name: "task triage:welcome",
             summary: "Single-entry-point upgrade ritual",
-            refs: "(N3 / #1143)",
-            description: "6-phase onboarding ritual: detect prior state, prompt for subscription scope, run triage:bootstrap, prompt for wipCap, offer WIP relief, print triage:summary. Idempotent on re-run; safe entrypoint for fresh consumers.",
-            usage: "task triage:welcome [-- --no-subprocess]",
-            flags: [["--no-subprocess", "(off)", "Dry-mode: don't shell out to sibling tasks."]],
-            examples: ["task triage:welcome"],
+            refs: "(N3 / #1143, #2295)",
+            description: "6-phase onboarding ritual: detect prior state, prompt for subscription scope, run triage:bootstrap, prompt for wipCap, offer WIP relief, print triage:summary. Idempotent on re-run; safe entrypoint for fresh consumers. Pass --onboard for the non-interactive path that applies a triage-scope preset (and optional --wip-cap) without prompting -- the form agents/CI use.",
+            usage: "task triage:welcome [-- --onboard [--preset small|mid|mega] [--wip-cap N]] [--no-subprocess]",
+            flags: [
+                [
+                    "--onboard",
+                    "(off)",
+                    "Non-interactive onboarding: apply a triage-scope preset (and optional WIP cap) without prompting.",
+                ],
+                ["--preset small|mid|mega", "small", "Subscription-scope preset applied by --onboard."],
+                [
+                    "--wip-cap N",
+                    "(policy default)",
+                    "Persist an explicit in-flight scope cap during --onboard (positive integer).",
+                ],
+                ["--no-subprocess", "(off)", "Dry-mode: don't shell out to sibling tasks."],
+            ],
+            examples: ["task triage:welcome", "task triage:welcome -- --onboard --preset small"],
             see_also: ["task triage:bootstrap", "task triage:summary", "#1119 / N3"],
             placeholder: false,
         },

package/dist/triage/scope/cli.d.ts

@@ -6,13 +6,14 @@ export interface ParsedCliArgs {
     addLabel: string | undefined;
     addMilestone: string | undefined;
     ignoreLabel: string | undefined;
+    setPreset: string | undefined;
     diffFromUpstream: boolean;
     source: string;
     cacheRoot: string | undefined;
     count: number | undefined;
 }
 export declare function parseCliArgs(argv: string[]): ParsedCliArgs;
-export declare const CLI_HELP = "usage: triage_scope.py [-h] [--project-root PROJECT_ROOT] [--list]\n                       [--refresh-denominator] [--repo REPO]\n                       [--add-label ADD_LABEL] [--add-milestone ADD_MILESTONE]\n                       [--ignore-label IGNORE_LABEL] [--diff-from-upstream]\n                       [--source SOURCE] [--cache-root CACHE_ROOT]\n                       [--count COUNT]\n\nInspect, mutate, and diff the typed plan.policy.triageScope[] subscription +\nplan.policy.triageScopeIgnores[] (#1131 / D12, #1133 / D14, #1182 / D14c).\nRead paths never trigger a recompute; use --refresh-denominator to update the\ncoverage cache. Mutation flags --add-label / --add-milestone / --ignore-label\nare idempotent and atomic; every mutation appends a subscription-change audit\nentry to vbrief/.eval/subscription-history.jsonl.\n";
+export declare const CLI_HELP = "usage: triage_scope.py [-h] [--project-root PROJECT_ROOT] [--list]\n                       [--refresh-denominator] [--repo REPO]\n                       [--add-label ADD_LABEL] [--add-milestone ADD_MILESTONE]\n                       [--ignore-label IGNORE_LABEL] [--set-preset PRESET]\n                       [--diff-from-upstream]\n                       [--source SOURCE] [--cache-root CACHE_ROOT]\n                       [--count COUNT]\n\nInspect, mutate, and diff the typed plan.policy.triageScope[] subscription +\nplan.policy.triageScopeIgnores[] (#1131 / D12, #1133 / D14, #1182 / D14c).\nRead paths never trigger a recompute; use --refresh-denominator to update the\ncoverage cache. Mutation flags --add-label / --add-milestone / --ignore-label /\n--set-preset are idempotent and atomic; every mutation appends a\nsubscription-change audit entry to vbrief/.eval/subscription-history.jsonl.\n--set-preset small|mid|mega overwrites plan.policy.triageScope[] with a named\nsubscription preset via the same writer that backs triage:welcome --onboard (#2301).\n";
 /** Run triage:scope CLI; returns exit code and captured output for parity. */
 export declare function runCliCapture(argv: string[]): {
     code: number;

package/dist/triage/scope/cli.js

@@ -2,7 +2,7 @@ import { existsSync } from "node:fs";
 import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { coveragePath, writeCoverageDenominator } from "./coverage.js";
-import { addLabelToIgnores, addLabelToScope, addMilestoneToScope, computeDiffFromUpstream, fetchUpstreamLabelsAndMilestones, renderDiffReport, } from "./mutations.js";
+import { addLabelToIgnores, addLabelToScope, addMilestoneToScope, computeDiffFromUpstream, fetchUpstreamLabelsAndMilestones, renderDiffReport, setScopePreset, } from "./mutations.js";
 import { subscriptionHash } from "./normalize.js";
 import { pyListRepr } from "./python-repr.js";
 import { renderIgnores, renderList } from "./renderers.js";
@@ -17,6 +17,7 @@ export function parseCliArgs(argv) {
         addLabel: undefined,
         addMilestone: undefined,
         ignoreLabel: undefined,
+        setPreset: undefined,
         diffFromUpstream: false,
         source: "github-issue",
         cacheRoot: undefined,
@@ -60,6 +61,12 @@ export function parseCliArgs(argv) {
         }
         else if (arg?.startsWith("--ignore-label="))
             parsed.ignoreLabel = arg.slice("--ignore-label=".length);
+        else if (arg === "--set-preset") {
+            parsed.setPreset = argv[i + 1];
+            i += 1;
+        }
+        else if (arg?.startsWith("--set-preset="))
+            parsed.setPreset = arg.slice("--set-preset=".length);
         else if (arg === "--source") {
             parsed.source = argv[i + 1] ?? "github-issue";
             i += 1;
@@ -86,16 +93,19 @@ export function parseCliArgs(argv) {
 export const CLI_HELP = `usage: triage_scope.py [-h] [--project-root PROJECT_ROOT] [--list]
                        [--refresh-denominator] [--repo REPO]
                        [--add-label ADD_LABEL] [--add-milestone ADD_MILESTONE]
-                       [--ignore-label IGNORE_LABEL] [--diff-from-upstream]
+                       [--ignore-label IGNORE_LABEL] [--set-preset PRESET]
+                       [--diff-from-upstream]
                        [--source SOURCE] [--cache-root CACHE_ROOT]
                        [--count COUNT]
 
 Inspect, mutate, and diff the typed plan.policy.triageScope[] subscription +
 plan.policy.triageScopeIgnores[] (#1131 / D12, #1133 / D14, #1182 / D14c).
 Read paths never trigger a recompute; use --refresh-denominator to update the
-coverage cache. Mutation flags --add-label / --add-milestone / --ignore-label
-are idempotent and atomic; every mutation appends a subscription-change audit
-entry to vbrief/.eval/subscription-history.jsonl.
+coverage cache. Mutation flags --add-label / --add-milestone / --ignore-label /
+--set-preset are idempotent and atomic; every mutation appends a
+subscription-change audit entry to vbrief/.eval/subscription-history.jsonl.
+--set-preset small|mid|mega overwrites plan.policy.triageScope[] with a named
+subscription preset via the same writer that backs triage:welcome --onboard (#2301).
 `;
 function handleMutation(projectRoot, args) {
     const out = { stdout: [], stderr: [] };
@@ -115,6 +125,10 @@ function handleMutation(projectRoot, args) {
             [changed, message] = addLabelToIgnores(projectRoot, args.ignoreLabel);
             verb = "ignore-label";
         }
+        else if (args.setPreset !== undefined) {
+            [changed, message] = setScopePreset(projectRoot, args.setPreset);
+            verb = "set-preset";
+        }
         else {
             throw new Error("internal: mutation flag set but no handler matched");
         }
@@ -148,12 +162,13 @@ export function runCliCapture(argv) {
         args.addLabel !== undefined ? "--add-label" : null,
         args.addMilestone !== undefined ? "--add-milestone" : null,
         args.ignoreLabel !== undefined ? "--ignore-label" : null,
+        args.setPreset !== undefined ? "--set-preset" : null,
     ].filter((f) => f !== null);
     if (mutationFlags.length > 1) {
         return {
             code: 2,
             stdout: "",
-            stderr: "triage:scope: --add-label / --add-milestone / --ignore-label " +
+            stderr: "triage:scope: --add-label / --add-milestone / --ignore-label / --set-preset " +
                 `are mutually exclusive (got ${pyListRepr(mutationFlags)}).\n`,
         };
     }
@@ -171,6 +186,15 @@ export function runCliCapture(argv) {
         if (mutation.code !== 0) {
             return { code: mutation.code, stdout: stdout.join(""), stderr: stderr.join("") };
         }
+        // A preset write comes from the trusted SUBSCRIPTION_PRESETS constant (the
+        // same source the onboard path writes). The `mega` preset intentionally
+        // ships an `explicit-watch` scaffold with an empty `issues` list for the
+        // operator to fill in, which the strict hand-edit validator below flags.
+        // Bypass that re-validation for a preset write so `--set-preset` reports the
+        // successful, persisted mutation instead of a spurious exit 1 (#2301).
+        if (args.setPreset !== undefined) {
+            return { code: 0, stdout: stdout.join(""), stderr: stderr.join("") };
+        }
     }
     const data = loadProjectDefinition(projectRoot);
     const rules = resolveScopeRules(projectRoot, data);

package/dist/triage/scope/mutations.d.ts

@@ -18,4 +18,14 @@ export declare function fetchUpstreamLabelsAndMilestones(repo: string, binary?:
 export declare function addLabelToScope(projectRoot: string, label: string, actor?: string | null): [boolean, string];
 export declare function addMilestoneToScope(projectRoot: string, milestone: string, actor?: string | null): [boolean, string];
 export declare function addLabelToIgnores(projectRoot: string, label: string): [boolean, string];
+/** Valid subscription preset keys for `triage:scope --set-preset` (#2301). */
+export declare function scopePresetKeys(): string[];
+/**
+ * Overwrite plan.policy.triageScope with a named subscription preset (#2301).
+ * Reuses the shared `subscriptionPreset` + `writeTriageScope` helper that backs
+ * `triage:welcome --onboard`, so the write path (namespaced key, legacy-key
+ * migration, audit trail, mutation lock) stays identical across surfaces rather
+ * than being duplicated here.
+ */
+export declare function setScopePreset(projectRoot: string, presetKey: string): [boolean, string];
 //# sourceMappingURL=mutations.d.ts.map

package/dist/triage/scope/mutations.js

@@ -1,5 +1,7 @@
 import { spawnSync } from "node:child_process";
 import { SUBPROCESS_MAX_BUFFER } from "../../subprocess/max-buffer.js";
+import { SUBSCRIPTION_PRESETS } from "../welcome/constants.js";
+import { subscriptionPreset, writeTriageScope } from "../welcome/writers.js";
 import { collectMilestoneSubscribedNames, rulesRequestIsOpen } from "./milestone.js";
 import { addIgnore, subscribe } from "./mutations-core.js";
 import { resolveScopeIgnores, resolveScopeRules } from "./resolve.js";
@@ -200,4 +202,24 @@ export function addLabelToIgnores(projectRoot, label) {
         throw new Error(`label must be a non-empty string; got ${JSON.stringify(label)}`);
     return addIgnore(projectRoot, label);
 }
+/** Valid subscription preset keys for `triage:scope --set-preset` (#2301). */
+export function scopePresetKeys() {
+    return Object.keys(SUBSCRIPTION_PRESETS);
+}
+/**
+ * Overwrite plan.policy.triageScope with a named subscription preset (#2301).
+ * Reuses the shared `subscriptionPreset` + `writeTriageScope` helper that backs
+ * `triage:welcome --onboard`, so the write path (namespaced key, legacy-key
+ * migration, audit trail, mutation lock) stays identical across surfaces rather
+ * than being duplicated here.
+ */
+export function setScopePreset(projectRoot, presetKey) {
+    const key = presetKey.trim();
+    const validKeys = scopePresetKeys();
+    if (!validKeys.includes(key)) {
+        throw new Error(`unknown preset ${JSON.stringify(presetKey)}; valid presets: ${validKeys.join(", ")}`);
+    }
+    const rules = subscriptionPreset(key);
+    return writeTriageScope(projectRoot, rules, { presetLabel: key });
+}
 //# sourceMappingURL=mutations.js.map

package/dist/triage/welcome/constants.d.ts

@@ -1,10 +1,9 @@
-export declare const PROJECT_DEFINITION_REL_PATH = "vbrief/PROJECT-DEFINITION.vbrief.json";
 export declare const CACHE_DIR_NAME = ".deft-cache";
 export declare const CACHE_SOURCE = "github-issue";
 export declare const CANDIDATES_RELPATH: readonly ["vbrief", ".eval", "candidates.jsonl"];
 export declare const WIP_LIFECYCLE_DIRS: readonly ["pending", "active"];
 export declare const AUDIT_LOG_REL_PATH = "meta/policy-changes.log";
-export declare const DEFAULT_WIP_CAP = 10;
+export declare const DEFAULT_WIP_CAP = 20;
 export declare const DEFAULT_RELIEF_AGE_DAYS = 30;
 export declare const TRIAGE_SKILL_PATH = "skills/deft-directive-triage/SKILL.md";
 export declare const WELCOME_AUDIT_TAG = "triage-welcome";

package/dist/triage/welcome/constants.js

@@ -1,10 +1,9 @@
-export const PROJECT_DEFINITION_REL_PATH = "vbrief/PROJECT-DEFINITION.vbrief.json";
 export const CACHE_DIR_NAME = ".deft-cache";
 export const CACHE_SOURCE = "github-issue";
 export const CANDIDATES_RELPATH = ["vbrief", ".eval", "candidates.jsonl"];
 export const WIP_LIFECYCLE_DIRS = ["pending", "active"];
 export const AUDIT_LOG_REL_PATH = "meta/policy-changes.log";
-export const DEFAULT_WIP_CAP = 10;
+export const DEFAULT_WIP_CAP = 20;
 export const DEFAULT_RELIEF_AGE_DAYS = 30;
 export const TRIAGE_SKILL_PATH = "skills/deft-directive-triage/SKILL.md";
 export const WELCOME_AUDIT_TAG = "triage-welcome";

package/dist/triage/welcome/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./constants.js";
 export { type DefaultModeOptions, formatWelcomeCommand, normalizeTaskPrefix, runDefaultMode, type WelcomeOutcome, } from "./default-mode.js";
+export { DEFAULT_ONBOARD_PRESET, type OnboardOptions, type OnboardOutcome, runOnboardMode, } from "./onboard.js";
 export { candidatesLogPath, classifyOnboarding, detectPriorState, type PriorState, pendingDecisionsNudgeLine, } from "./prior-state.js";
 export { computeSummary, emitOneliner, formatOneLiner, formatSummary, type SummaryResult, } from "./summary.js";
 export { appendAuditEntry, previewWipRelief, type ReliefPreview, subscriptionPreset, writeTriageScope, writeWipCap, } from "./writers.js";

package/dist/triage/welcome/index.js

@@ -1,5 +1,6 @@
 export * from "./constants.js";
 export { formatWelcomeCommand, normalizeTaskPrefix, runDefaultMode, } from "./default-mode.js";
+export { DEFAULT_ONBOARD_PRESET, runOnboardMode, } from "./onboard.js";
 export { candidatesLogPath, classifyOnboarding, detectPriorState, pendingDecisionsNudgeLine, } from "./prior-state.js";
 export { computeSummary, emitOneliner, formatOneLiner, formatSummary, } from "./summary.js";
 export { appendAuditEntry, previewWipRelief, subscriptionPreset, writeTriageScope, writeWipCap, } from "./writers.js";