@deftai/directive-core 0.105.0 → 0.106.0

package/dist/session/verify-session-ritual.js

@@ -1,5 +1,8 @@
-import { existsSync } from "node:fs";
+import { existsSync, readdirSync } from "node:fs";
+import { join } from "node:path";
 import { readCorePackageVersion } from "../engine-version.js";
+import { hasArtifactSuffix } from "../layout/resolve.js";
+import { readPlanSequence } from "../plan-sequence/store.js";
 import { formatFrameworkCommand } from "../render/framework-commands.js";
 import { checkActiveCliAgainstTarget, } from "./active-cli.js";
 import { defaultGitRunner, gitHead, gitIsAncestor, worktreePath } from "./git.js";
@@ -17,6 +20,64 @@ export const GATED_ENTRYPOINT_COMMANDS = {
     doctor: ["doctor"],
     cache_fresh: ["verify:cache-fresh"],
 };
+/** Explicit skip flag threaded through the gated `cache_fresh` argv (#3507). */
+export const SKIP_DRIFT_PROBE_FLAG = "--skip-drift-probe";
+/** Explicit work-selection flag threaded through the gated `cache_fresh` argv (#3507). */
+export const WORK_SELECTION_FLAG = "--work-selection";
+/** Distinct ritual-state field — never `deferred_reason` (#3507). */
+export const DRIFT_PROBE_SKIPPED_NO_WORK_SELECTION = "skipped-no-work-selection";
+function hasActiveStoryArtifact(projectRoot) {
+    for (const dirName of ["xbrief", "vbrief"]) {
+        const activeDir = join(projectRoot, dirName, "active");
+        try {
+            for (const entry of readdirSync(activeDir, { withFileTypes: true })) {
+                if (entry.isFile() && hasArtifactSuffix(entry.name))
+                    return true;
+            }
+        }
+        catch {
+            /* missing or unreadable active folder is not work selection */
+        }
+    }
+    return false;
+}
+function hasUnexhaustedPlanSequence(projectRoot) {
+    try {
+        const sequence = readPlanSequence(projectRoot);
+        if (sequence === null || sequence.exhausted === true)
+            return null;
+        return sequence.sequence_kind === "triage" ? "triage-queue" : "ordered-plan";
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Default work-selection detector for the gated `cache_fresh` seam (#3507).
+ * Active story xBRIEF (scope:activate residue), unexhausted ordered-plan /
+ * triage sequence. `--for-issue` is a positive evaluate override, not this
+ * detector — the gated argv never carries it.
+ */
+export function detectWorkSelection(projectRoot) {
+    if (hasActiveStoryArtifact(projectRoot)) {
+        return { inPlay: true, kind: "active-story" };
+    }
+    const planKind = hasUnexhaustedPlanSequence(projectRoot);
+    if (planKind !== null) {
+        return { inPlay: true, kind: planKind };
+    }
+    return { inPlay: false, kind: "none" };
+}
+export function resolveGatedEntrypointCommand(stepName, projectRoot, detect = detectWorkSelection) {
+    const base = [...GATED_ENTRYPOINT_COMMANDS[stepName]];
+    if (stepName !== "cache_fresh")
+        return base;
+    const selection = detect(projectRoot);
+    if (selection.inPlay) {
+        return [...base, WORK_SELECTION_FLAG];
+    }
+    return [...base, SKIP_DRIFT_PROBE_FLAG];
+}
 function truthy(raw) {
     return new Set(["1", "true", "yes", "on"]).has((raw ?? "").trim().toLowerCase());
 }
@@ -25,6 +86,7 @@ function stepPasses(step) {
         return false;
     if (step.deferred_reason)
         return true;
+    // `drift_probe` is a distinct diagnostic; it must never satisfy a step (#3507).
     return step.ok === true;
 }
 function failedStepMessage(tierName, stepName, step) {
@@ -52,14 +114,29 @@ export function formatRitualRecoveryInstruction(tier = "cold") {
 }
 /**
  * Sanctioned audited defer copy for gated `cache_fresh` failure (#3506 / #3507).
- * The gated argv is always `["verify:cache-fresh"]`, so this is unconditional.
+ * Independent of the #3507 work-selection argv seam — defer is still the
+ * operator-audited escape, not the drift-probe skip.
  */
 export function formatCacheFreshDeferSoftPath() {
     const cmd = formatFrameworkCommand(["session:start", "--", "--defer", "cache_fresh=<reason>"]);
     return `Soft path (audited): \`${cmd}\`.`;
 }
-function runGatedStep(projectRoot, payload, stepName, runner, now) {
-    const command = [...GATED_ENTRYPOINT_COMMANDS[stepName]];
+function applyCacheFreshDriftProbeField(payload, command) {
+    if (command.includes(SKIP_DRIFT_PROBE_FLAG)) {
+        payload.drift_probe = DRIFT_PROBE_SKIPPED_NO_WORK_SELECTION;
+        return;
+    }
+    if (payload.drift_probe === DRIFT_PROBE_SKIPPED_NO_WORK_SELECTION) {
+        delete payload.drift_probe;
+    }
+}
+function shouldRearmDriftProbe(payload, projectRoot, detect) {
+    if (payload.drift_probe !== DRIFT_PROBE_SKIPPED_NO_WORK_SELECTION)
+        return false;
+    return detect(projectRoot).inPlay;
+}
+function runGatedStep(projectRoot, payload, stepName, runner, now, detect = detectWorkSelection) {
+    const command = resolveGatedEntrypointCommand(stepName, projectRoot, detect);
     const { code, stdout, stderr } = runner(command, projectRoot);
     const message = stdout.trim() || stderr.trim() || `${command[0]} exited ${code}`;
     const gated = payload.gated_steps ?? {};
@@ -71,6 +148,9 @@ function runGatedStep(projectRoot, payload, stepName, runner, now) {
         command,
     });
     payload.gated_steps = gated;
+    if (stepName === "cache_fresh") {
+        applyCacheFreshDriftProbeField(payload, command);
+    }
     try {
         writeRitualState(projectRoot, payload);
     }
@@ -361,6 +441,7 @@ export function verifySessionRitual(projectRoot, options = {}) {
         payload.gated_steps = gated;
         const runCmd = options.runner ?? defaultRitualRunner;
         const forced = new Set(options.forceGatedSteps ?? []);
+        const detect = options.detectWorkSelection ?? detectWorkSelection;
         for (const stepName of GATED_STEPS) {
             const step = gated[stepName];
             if (step?.deferred_reason && stepName !== "agent_hooks")
@@ -368,9 +449,11 @@ export function verifySessionRitual(projectRoot, options = {}) {
             // Hook readiness is a live mutation prerequisite, not a cacheable doctor
             // result. Re-run it at every gated boundary so registration/shim drift
             // cannot remain hidden behind an earlier green ritual record.
-            if (stepName !== "agent_hooks" && stepPasses(step) && !forced.has(stepName))
+            const rearmDrift = stepName === "cache_fresh" && shouldRearmDriftProbe(payload, projectRoot, detect);
+            if (stepName !== "agent_hooks" && stepPasses(step) && !forced.has(stepName) && !rearmDrift) {
                 continue;
-            const writeError = runGatedStep(projectRoot, payload, stepName, runCmd, instant);
+            }
+            const writeError = runGatedStep(projectRoot, payload, stepName, runCmd, instant, detect);
             if (writeError !== null) {
                 return {
                     code: 2,

package/dist/swarm/finalize-cohort-cli.d.ts

@@ -1,5 +1,10 @@
 #!/usr/bin/env node
-import { finalizeCohort } from "./finalize-cohort.js";
-export declare function parseFinalizeCohortArgv(argv: readonly string[]): Parameters<typeof finalizeCohort>[0];
+import { type FinalizeCohortArgs } from "./finalize-cohort.js";
+export interface ParsedFinalizeCohortArgv extends FinalizeCohortArgs {
+    readonly help: boolean;
+    readonly error: string | null;
+}
+export declare const FINALIZE_COHORT_USAGE = "Usage: task swarm:finalize-cohort -- [--pr <n>[,<n>...]] [--stories <ids|paths>] [options]\n\nAfter cohort PRs merge, sweep story briefs active/ -> completed/ and open the lifecycle PR.\n\nOptions:\n  --pr <n>[,<n>...]            Merged PR numbers (closing issues map to active stories)\n  --stories <ids|paths>        Explicit story tokens (repeatable)\n  --repo OWNER/REPO            GitHub repo (or $GH_REPO)\n  --project-root <path>        Project root (default: cwd)\n  --base-branch <name>         Sweep/PR base (default: resolved delivery branch)\n  --delivery-branch <name>     Delivery-branch override when policy is untyped\n  --label <name>               Feature-branch label\n  --dry-run                    Print plan; no git mutation\n  --no-commit                  Sweep without committing / opening a PR\n  --no-open-pr                 Commit without opening a PR\n  --json                       Machine-readable result\n  -h, --help                   Show this help\n";
+export declare function parseFinalizeCohortArgv(argv: readonly string[]): ParsedFinalizeCohortArgv;
 export declare function finalizeCohortMain(argv?: string[]): number;
 //# sourceMappingURL=finalize-cohort-cli.d.ts.map

package/dist/swarm/finalize-cohort-cli.js

@@ -1,67 +1,181 @@
 #!/usr/bin/env node
 import { fileURLToPath } from "node:url";
+import { EXIT_CONFIG_ERROR, EXIT_OK } from "./constants.js";
 import { finalizeCohort } from "./finalize-cohort.js";
+export const FINALIZE_COHORT_USAGE = `Usage: task swarm:finalize-cohort -- [--pr <n>[,<n>...]] [--stories <ids|paths>] [options]
+
+After cohort PRs merge, sweep story briefs active/ -> completed/ and open the lifecycle PR.
+
+Options:
+  --pr <n>[,<n>...]            Merged PR numbers (closing issues map to active stories)
+  --stories <ids|paths>        Explicit story tokens (repeatable)
+  --repo OWNER/REPO            GitHub repo (or $GH_REPO)
+  --project-root <path>        Project root (default: cwd)
+  --base-branch <name>         Sweep/PR base (default: resolved delivery branch)
+  --delivery-branch <name>     Delivery-branch override when policy is untyped
+  --label <name>               Feature-branch label
+  --dry-run                    Print plan; no git mutation
+  --no-commit                  Sweep without committing / opening a PR
+  --no-open-pr                 Commit without opening a PR
+  --json                       Machine-readable result
+  -h, --help                   Show this help
+`;
+function equalsValue(arg, flag) {
+    return arg.slice(flag.length + 1);
+}
+function parsePrList(raw, flag, prNumbers, reject) {
+    if (raw.trim().length === 0) {
+        reject(flag);
+        return;
+    }
+    for (const piece of raw.split(",")) {
+        const trimmed = piece.trim();
+        if (trimmed.length === 0) {
+            reject(flag);
+            return;
+        }
+        if (!/^\d+$/.test(trimmed)) {
+            reject(flag);
+            return;
+        }
+        prNumbers.push(Number.parseInt(trimmed, 10));
+    }
+}
 export function parseFinalizeCohortArgv(argv) {
     const prNumbers = [];
     const storyTokens = [];
     let repo = null;
     let projectRoot = ".";
-    let baseBranch = "master";
+    let baseBranch;
     let deliveryBranch = null;
     let label = null;
     let dryRun = false;
     let noCommit = false;
     let noOpenPr = false;
     let emitJson = false;
+    let help = false;
+    let error = null;
+    const reject = (arg) => {
+        error ??= `unrecognized argument: ${arg}`;
+    };
+    const takeValue = (flag, nextValue) => {
+        if (nextValue === undefined || nextValue.startsWith("-")) {
+            reject(flag);
+            return null;
+        }
+        return nextValue;
+    };
     for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
         const next = argv[i + 1];
-        if (arg === "--pr" && next !== undefined) {
-            for (const piece of next.split(",")) {
-                const trimmed = piece.trim();
-                if (/^\d+$/.test(trimmed)) {
-                    prNumbers.push(Number.parseInt(trimmed, 10));
-                }
+        if (arg === "--help" || arg === "-h") {
+            help = true;
+        }
+        else if (arg === "--pr") {
+            const value = takeValue(arg, next);
+            if (value !== null) {
+                parsePrList(value, arg, prNumbers, reject);
+                i += 1;
             }
-            i += 1;
         }
         else if (arg?.startsWith("--pr=")) {
-            for (const piece of arg.slice("--pr=".length).split(",")) {
-                const trimmed = piece.trim();
-                if (/^\d+$/.test(trimmed)) {
-                    prNumbers.push(Number.parseInt(trimmed, 10));
-                }
+            parsePrList(equalsValue(arg, "--pr"), arg, prNumbers, reject);
+        }
+        else if (arg === "--stories") {
+            const value = takeValue(arg, next);
+            if (value !== null) {
+                storyTokens.push(value);
+                i += 1;
             }
         }
-        else if (arg === "--stories" && next !== undefined) {
-            storyTokens.push(next);
-            i += 1;
+        else if (arg?.startsWith("--stories=")) {
+            const value = equalsValue(arg, "--stories");
+            if (value.length === 0) {
+                reject(arg);
+            }
+            else {
+                storyTokens.push(value);
+            }
         }
-        else if (arg === "--repo" && next !== undefined) {
-            repo = next;
-            i += 1;
+        else if (arg === "--repo") {
+            const value = takeValue(arg, next);
+            if (value !== null) {
+                repo = value;
+                i += 1;
+            }
         }
         else if (arg?.startsWith("--repo=")) {
-            repo = arg.slice("--repo=".length);
+            const value = equalsValue(arg, "--repo");
+            if (value.length === 0) {
+                reject(arg);
+            }
+            else {
+                repo = value;
+            }
+        }
+        else if (arg === "--project-root") {
+            const value = takeValue(arg, next);
+            if (value !== null) {
+                projectRoot = value;
+                i += 1;
+            }
         }
-        else if (arg === "--project-root" && next !== undefined) {
-            projectRoot = next;
-            i += 1;
+        else if (arg?.startsWith("--project-root=")) {
+            const value = equalsValue(arg, "--project-root");
+            if (value.length === 0) {
+                reject(arg);
+            }
+            else {
+                projectRoot = value;
+            }
         }
-        else if (arg === "--base-branch" && next !== undefined) {
-            baseBranch = next;
-            i += 1;
+        else if (arg === "--base-branch") {
+            const value = takeValue(arg, next);
+            if (value !== null) {
+                baseBranch = value;
+                i += 1;
+            }
         }
-        else if (arg === "--delivery-branch" && next !== undefined) {
-            deliveryBranch = next;
-            i += 1;
+        else if (arg?.startsWith("--base-branch=")) {
+            const value = equalsValue(arg, "--base-branch");
+            if (value.length === 0) {
+                reject(arg);
+            }
+            else {
+                baseBranch = value;
+            }
+        }
+        else if (arg === "--delivery-branch") {
+            const value = takeValue(arg, next);
+            if (value !== null) {
+                deliveryBranch = value;
+                i += 1;
+            }
         }
         else if (arg?.startsWith("--delivery-branch=")) {
-            deliveryBranch = arg.slice("--delivery-branch=".length);
+            const value = equalsValue(arg, "--delivery-branch");
+            if (value.length === 0) {
+                reject(arg);
+            }
+            else {
+                deliveryBranch = value;
+            }
+        }
+        else if (arg === "--label") {
+            const value = takeValue(arg, next);
+            if (value !== null) {
+                label = value;
+                i += 1;
+            }
         }
-        else if (arg === "--label" && next !== undefined) {
-            label = next;
-            i += 1;
+        else if (arg?.startsWith("--label=")) {
+            const value = equalsValue(arg, "--label");
+            if (value.length === 0) {
+                reject(arg);
+            }
+            else {
+                label = value;
+            }
         }
         else if (arg === "--dry-run") {
             dryRun = true;
@@ -78,23 +192,37 @@ export function parseFinalizeCohortArgv(argv) {
         else if (arg !== undefined && !arg.startsWith("-")) {
             storyTokens.push(arg);
         }
+        else if (arg !== undefined) {
+            reject(arg);
+        }
     }
     return {
         prNumbers,
         storyTokens,
         repo,
         projectRoot,
-        baseBranch,
+        ...(baseBranch !== undefined ? { baseBranch } : {}),
         deliveryBranch,
         label,
         dryRun,
         noCommit,
         noOpenPr,
         emitJson,
+        help,
+        error,
     };
 }
 export function finalizeCohortMain(argv = process.argv.slice(2)) {
-    const result = finalizeCohort(parseFinalizeCohortArgv(argv));
+    const parsed = parseFinalizeCohortArgv(argv);
+    if (parsed.help) {
+        process.stdout.write(FINALIZE_COHORT_USAGE);
+        return EXIT_OK;
+    }
+    if (parsed.error !== null) {
+        process.stderr.write(`${parsed.error}\n`);
+        return EXIT_CONFIG_ERROR;
+    }
+    const result = finalizeCohort(parsed);
     if (result.stdout.length > 0) {
         process.stdout.write(result.stdout);
     }
@@ -103,7 +231,9 @@ export function finalizeCohortMain(argv = process.argv.slice(2)) {
     }
     return result.exitCode;
 }
+/* v8 ignore start -- entry guard */
 if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
     process.exit(finalizeCohortMain());
 }
+/* v8 ignore stop */
 //# sourceMappingURL=finalize-cohort-cli.js.map

package/dist/swarm/finalize-cohort.d.ts

@@ -13,6 +13,7 @@ export interface FinalizeCohortResult {
     readonly branch: string | null;
     readonly pr_url: string | null;
     readonly delivery_branch: string | null;
+    readonly sweep_base: string;
     readonly delivery_errors: readonly string[];
     readonly errors: readonly string[];
     readonly warnings: readonly string[];

package/dist/swarm/finalize-cohort.js

@@ -327,8 +327,6 @@ export function finalizeCohort(args) {
     const prNumbers = [...(args.prNumbers ?? [])].sort((a, b) => a - b);
     const storyTokens = splitCsv(args.storyTokens ?? []);
     const repo = args.repo ?? process.env.GH_REPO ?? null;
-    // baseBranch is for the lifecycle sweep PR only — not delivery proof (#3041).
-    const baseBranch = args.baseBranch ?? "master";
     const dryRun = args.dryRun ?? false;
     const noCommit = args.noCommit ?? false;
     const noOpenPr = args.noOpenPr ?? false;
@@ -351,6 +349,12 @@ export function finalizeCohort(args) {
     const deliveryBranch = policyDelivery.source === "typed"
         ? policyDelivery.branch
         : (cliDelivery ?? policyDelivery.branch);
+    // Sweep/PR base is distinct from delivery proof (#3041). Default via the resolved
+    // delivery branch — never a hardcoded "master". --base-branch remains the override.
+    const explicitSweepBase = args.baseBranch !== undefined && args.baseBranch !== null && args.baseBranch.trim().length > 0
+        ? args.baseBranch.trim()
+        : null;
+    const baseBranch = explicitSweepBase ?? deliveryBranch;
     if (!existsSync(projectRoot)) {
         return buildResponse({
             projectRoot,
@@ -364,6 +368,7 @@ export function finalizeCohort(args) {
             branch: null,
             prUrl: null,
             deliveryBranch,
+            sweepBase: baseBranch,
             deliveryErrors: [],
             errors: [`project root does not exist: ${projectRoot}`],
             warnings: [],
@@ -385,6 +390,7 @@ export function finalizeCohort(args) {
             branch: null,
             prUrl: null,
             deliveryBranch,
+            sweepBase: baseBranch,
             deliveryErrors: [],
             errors: [`no xbrief/ directory under project root: ${projectRoot}`],
             warnings: [],
@@ -546,6 +552,7 @@ export function finalizeCohort(args) {
             branch: null,
             prUrl: null,
             deliveryBranch,
+            sweepBase: baseBranch,
             deliveryErrors,
             errors,
             warnings,
@@ -572,6 +579,7 @@ export function finalizeCohort(args) {
             branch: null,
             prUrl: null,
             deliveryBranch,
+            sweepBase: baseBranch,
             deliveryErrors,
             errors,
             warnings,
@@ -673,6 +681,7 @@ export function finalizeCohort(args) {
             branch: null,
             prUrl: null,
             deliveryBranch,
+            sweepBase: baseBranch,
             deliveryErrors,
             errors,
             warnings,
@@ -712,6 +721,7 @@ export function finalizeCohort(args) {
         branch,
         prUrl,
         deliveryBranch,
+        sweepBase: baseBranch,
         deliveryErrors,
         errors,
         warnings,
@@ -733,6 +743,7 @@ function buildResponse(input) {
         branch: input.branch,
         pr_url: input.prUrl,
         delivery_branch: input.deliveryBranch,
+        sweep_base: input.sweepBase,
         delivery_errors: input.deliveryErrors,
         errors: input.errors,
         warnings: input.warnings,
@@ -754,6 +765,7 @@ function buildResponse(input) {
     if (input.deliveryBranch !== null) {
         lines.push(`  Delivery branch: ${input.deliveryBranch}`);
     }
+    lines.push(`  Sweep base: ${input.sweepBase}`);
     if (input.prNumbers.length > 0) {
         lines.push(`  PRs: ${input.prNumbers.map((n) => `#${n}`).join(", ")}`);
     }

package/dist/swarm/routing-set-cli.js

@@ -22,6 +22,8 @@ export function routingSetMain(argv = process.argv.slice(2), environ = process.e
     let harnessDefault = false;
     for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
+        if (arg === "--")
+            continue;
         if (arg === "--project-root" && argv[i + 1] !== undefined) {
             projectRoot = argv[i + 1] ?? ".";
             i += 1;

package/dist/swarm/routing-verify.d.ts

@@ -1,5 +1,5 @@
 import { type RoutingFile } from "./routing.js";
-export declare const ROUTING_SET_CMD = "task swarm:routing-set -- --role <role> --model <slug>   (or --harness-default)";
+export declare const ROUTING_SET_CMD = "deft swarm:routing-set --role <role> --model <slug>   (or --harness-default)";
 /** Roles the pre-dispatch gate checks by default: the actual model lever. */
 export declare const DEFAULT_GATED_ROLES: readonly ["leaf-implementation"];
 export interface VerifyRoutingOptions {

package/dist/swarm/routing-verify.js

@@ -12,7 +12,7 @@
  */
 import { EXIT_CONFIG_ERROR, EXIT_GATE_FAILED, EXIT_OK } from "./constants.js";
 import { dispatchProviderFromRuntime, emptyHostDetectProbes, HARNESS_BOUND_PROVIDERS, loadRoutingFile, ROUTING_MODE_HARNESS_DEFAULT, resolveDispatchProvider, resolveModelRoute, resolveRoutingPath, } from "./routing.js";
-export const ROUTING_SET_CMD = "task swarm:routing-set -- --role <role> --model <slug>   (or --harness-default)";
+export const ROUTING_SET_CMD = "deft swarm:routing-set --role <role> --model <slug>   (or --harness-default)";
 /** Roles the pre-dispatch gate checks by default: the actual model lever. */
 export const DEFAULT_GATED_ROLES = ["leaf-implementation"];
 function resolveProvider(options) {
@@ -105,7 +105,7 @@ export function verifyRouting(options) {
         };
     }
     if (options.advise) {
-        const note = "[deft routing] NOTE: plan.policy.swarmSubagentBackend enum is deprecated (#1891); use 'task swarm:routing-set' / .deft/routing.local.json instead.";
+        const note = "[deft routing] NOTE: plan.policy.swarmSubagentBackend enum is deprecated (#1891); use 'deft swarm:routing-set' / .deft/routing.local.json instead.";
         let body;
         if (undecided.length === 0 && invalid.length === 0) {
             body = `[deft routing] provider '${provider}': all ${roles.length} gated role(s) decided.`;

package/dist/triage/bootstrap/index.js

@@ -370,12 +370,12 @@ export function formatSummary(result) {
     if (result.exitCode === 0) {
         lines.push("");
         lines.push("Next steps:");
-        lines.push("  task cache:fetch-all -- --source=github-issue --repo OWNER/NAME   # refresh the cache (#883 Story 2)");
-        lines.push("  task cache:get -- github-issue OWNER/NAME/<N>            # inspect cached issue N");
-        lines.push("  task triage:accept -- --issue <N> --repo OWNER/NAME      # accept issue N (#845 Story 3)");
-        lines.push("  task triage:reject -- --issue <N> --repo OWNER/NAME --reason 'why' # reject issue N");
-        lines.push("  task triage:bulk-accept -- --repo OWNER/NAME --label adoption-blocker # bulk accept");
-        lines.push("  task triage:refresh-active                              # pre-swarm freshness gate");
+        lines.push("  deft cache:fetch-all --source=github-issue --repo OWNER/NAME   # refresh the cache (#883 Story 2)");
+        lines.push("  deft cache:get github-issue OWNER/NAME/<N>            # inspect cached issue N");
+        lines.push("  deft triage:accept --issue <N> --repo OWNER/NAME      # accept issue N (#845 Story 3)");
+        lines.push("  deft triage:reject --issue <N> --repo OWNER/NAME --reason 'why' # reject issue N");
+        lines.push("  deft triage:bulk-accept --repo OWNER/NAME --label adoption-blocker # bulk accept");
+        lines.push("  deft triage:refresh-active                              # pre-swarm freshness gate");
     }
     return lines.join("\n");
 }

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

@@ -357,7 +357,7 @@ export declare const registryData: {
             readonly name: "task triage:metrics";
             readonly summary: "Attributed-value trend from the events ledger";
             readonly refs: "(#1709)";
-            readonly description: "Report value-feedback attribution trends from .deft-cache/events.jsonl: total signal count plus per-class (value, bypass, adoption, friction) and per-event breakdowns over a time window. Alias of the value:show handler. Requires plan.policy.valueFeedback.enabled (default OFF) — exits blocked when disabled; an empty ledger prints a no-signals message. In the maintainer repo, skipped unless DEFT_VALUE_SELF_DOGFOOD=1.";
+            readonly description: "Report value-feedback attribution trends from .deft-cache/events.jsonl: total signal count plus per-class (value, bypass, adoption, friction) and per-event breakdowns over a time window. Also composes a ceremony-cost rollup (#3508): last cold vs re-arm CLI process time, per-step ms, blocked-ritual count, recovery-tier distribution. Alias of the value:show handler. Attribution requires plan.policy.valueFeedback.enabled (default OFF) — exits blocked when disabled, but still prints the ceremony-cost section. An empty attribution ledger prints a no-signals message. In the maintainer repo, attribution is skipped unless DEFT_VALUE_SELF_DOGFOOD=1.";
             readonly usage: "task triage:metrics [-- --window=7d] [--format=text|json]";
             readonly flags: readonly [readonly ["--window WINDOW", "7d", "Time window (e.g. 7d, 30d, 24h)."], readonly ["--format text|json", "text", "Output shape (json emits the full trend object)."]];
             readonly examples: readonly ["task triage:metrics", "task triage:metrics -- --window=30d --format=json"];

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

@@ -628,7 +628,7 @@ export const registryData = {
             name: "task triage:metrics",
             summary: "Attributed-value trend from the events ledger",
             refs: "(#1709)",
-            description: "Report value-feedback attribution trends from .deft-cache/events.jsonl: total signal count plus per-class (value, bypass, adoption, friction) and per-event breakdowns over a time window. Alias of the value:show handler. Requires plan.policy.valueFeedback.enabled (default OFF) — exits blocked when disabled; an empty ledger prints a no-signals message. In the maintainer repo, skipped unless DEFT_VALUE_SELF_DOGFOOD=1.",
+            description: "Report value-feedback attribution trends from .deft-cache/events.jsonl: total signal count plus per-class (value, bypass, adoption, friction) and per-event breakdowns over a time window. Also composes a ceremony-cost rollup (#3508): last cold vs re-arm CLI process time, per-step ms, blocked-ritual count, recovery-tier distribution. Alias of the value:show handler. Attribution requires plan.policy.valueFeedback.enabled (default OFF) — exits blocked when disabled, but still prints the ceremony-cost section. An empty attribution ledger prints a no-signals message. In the maintainer repo, attribution is skipped unless DEFT_VALUE_SELF_DOGFOOD=1.",
             usage: "task triage:metrics [-- --window=7d] [--format=text|json]",
             flags: [
                 ["--window WINDOW", "7d", "Time window (e.g. 7d, 30d, 24h)."],

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

@@ -1,4 +1,4 @@
-export declare function appendAuditEntry(projectRoot: string, entry: string): string;
+export declare function appendAuditEntry(projectRoot: string, entry: string, changed?: boolean): string;
 export declare function writeTriageScope(projectRoot: string, rules: Array<Record<string, unknown>>, options?: {
     presetLabel: string;
     actor?: string;