@deftai/directive 0.88.0 → 0.90.0

package/dist/escalation-cli.js

@@ -0,0 +1,301 @@
+#!/usr/bin/env node
+/**
+ * Escalation CLI (#518 slim / #2948 Wave 5): typed queue under .deft/escalations/.
+ *
+ *   deft escalation:file -- --type cmd_approval --title "…"
+ *   deft escalation:list [--open] [--type <type>] [--format json]
+ *   deft escalation:resolve -- <id> --decision approved|denied|answered|dismissed
+ *   deft escalation:batch-approve [--ids a,b] [--include-dangerous]
+ */
+import { batchApproveEscalations, ESCALATION_TYPES, fileEscalation, isEscalationType, listEscalationsFiltered, resolveEscalation, } from "@deftai/directive-core/escalation";
+function parseArgv(argv) {
+    const base = {
+        cmd: "list",
+        projectRoot: process.cwd(),
+        type: null,
+        title: null,
+        body: null,
+        agentId: "agent",
+        contextRefs: [],
+        slaHours: null,
+        dangerous: false,
+        id: null,
+        ids: [],
+        decision: null,
+        actor: "operator",
+        note: null,
+        answer: null,
+        openOnly: false,
+        includeDangerous: false,
+        format: "text",
+    };
+    const args = [...argv];
+    while (args[0] === "--")
+        args.shift();
+    if (args.length > 0 && !args[0]?.startsWith("-")) {
+        const cmd = args.shift();
+        if (cmd === "file" || cmd === "list" || cmd === "resolve" || cmd === "batch-approve") {
+            base.cmd = cmd;
+        }
+        else if (cmd.startsWith("esc-")) {
+            base.cmd = "resolve";
+            base.id = cmd;
+        }
+        else {
+            return { ...base, error: `unknown escalation subcommand: ${cmd}` };
+        }
+    }
+    while (args[0] === "--")
+        args.shift();
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === undefined)
+            break;
+        if (a === "--project-root" || a === "--projectRoot") {
+            base.projectRoot = args[++i] ?? base.projectRoot;
+            continue;
+        }
+        if (a === "--type") {
+            base.type = args[++i] ?? null;
+            continue;
+        }
+        if (a === "--title") {
+            base.title = args[++i] ?? null;
+            continue;
+        }
+        if (a === "--body") {
+            base.body = args[++i] ?? null;
+            continue;
+        }
+        if (a === "--agent" || a === "--agent-id" || a === "--agentId") {
+            base.agentId = args[++i] ?? base.agentId;
+            continue;
+        }
+        if (a === "--context" || a === "--context-refs" || a === "--contextRefs") {
+            const raw = args[++i] ?? "";
+            base.contextRefs = raw
+                .split(/[,\s]+/)
+                .map((s) => s.trim())
+                .filter((s) => s.length > 0);
+            continue;
+        }
+        if (a === "--sla-hours" || a === "--slaHours") {
+            const n = Number(args[++i] ?? "");
+            base.slaHours = Number.isFinite(n) ? n : null;
+            continue;
+        }
+        if (a === "--dangerous") {
+            base.dangerous = true;
+            continue;
+        }
+        if (a === "--id") {
+            base.id = args[++i] ?? null;
+            continue;
+        }
+        if (a === "--ids") {
+            const raw = args[++i] ?? "";
+            base.ids = raw
+                .split(/[,\s]+/)
+                .map((s) => s.trim())
+                .filter((s) => s.length > 0);
+            continue;
+        }
+        if (a === "--decision") {
+            base.decision = args[++i] ?? null;
+            continue;
+        }
+        if (a === "--actor") {
+            base.actor = args[++i] ?? base.actor;
+            continue;
+        }
+        if (a === "--note") {
+            base.note = args[++i] ?? null;
+            continue;
+        }
+        if (a === "--answer") {
+            base.answer = args[++i] ?? null;
+            continue;
+        }
+        if (a === "--open") {
+            base.openOnly = true;
+            continue;
+        }
+        if (a === "--include-dangerous") {
+            base.includeDangerous = true;
+            continue;
+        }
+        if (a === "--format") {
+            const fmt = (args[++i] ?? "text").toLowerCase();
+            base.format = fmt === "json" ? "json" : "text";
+            continue;
+        }
+        if (!a.startsWith("-") && base.cmd === "resolve" && base.id === null) {
+            base.id = a;
+            continue;
+        }
+        if (a === "--help" || a === "-h") {
+            return { ...base, error: "help" };
+        }
+    }
+    return base;
+}
+function helpText() {
+    return [
+        "Usage:",
+        "  deft escalation:file -- --type <type> --title <text> [--body <text>] [--agent <id>]",
+        "      [--context refs…] [--sla-hours N] [--dangerous] [--format json]",
+        "  deft escalation:list [--open] [--type <type>] [--format json]",
+        "  deft escalation:resolve -- <id> --decision approved|denied|answered|dismissed",
+        "      [--note <text>] [--answer <text>] [--actor <name>]",
+        "  deft escalation:batch-approve [--ids a,b] [--include-dangerous] [--note <text>]",
+        "",
+        `Types: ${ESCALATION_TYPES.join(", ")}`,
+        "Bulk batch-approve is limited to cmd_approval + question (non-dangerous by default).",
+        "design_decision / approval / resource / external require individual resolve.",
+        "Store: .deft/escalations/<id>.json  Contract: content/contracts/escalation.md",
+        "Compose gated actions with deft authz:grant after approval (Wave 1 grants).",
+    ].join("\n");
+}
+export function main(argv = process.argv.slice(2)) {
+    const args = parseArgv(argv);
+    if (args.error === "help") {
+        process.stdout.write(`${helpText()}\n`);
+        return 0;
+    }
+    if (args.error !== undefined) {
+        process.stderr.write(`escalation: ${args.error}\n`);
+        process.stderr.write(`${helpText()}\n`);
+        return 2;
+    }
+    try {
+        switch (args.cmd) {
+            case "file": {
+                if (args.type === null || args.type.trim().length === 0) {
+                    process.stderr.write("escalation:file requires --type <type>\n");
+                    return 2;
+                }
+                if (args.title === null || args.title.trim().length === 0) {
+                    process.stderr.write("escalation:file requires --title <text>\n");
+                    return 2;
+                }
+                const event = fileEscalation({
+                    projectRoot: args.projectRoot,
+                    type: args.type,
+                    title: args.title,
+                    body: args.body ?? undefined,
+                    agentId: args.agentId,
+                    contextRefs: args.contextRefs,
+                    slaHours: args.slaHours ?? undefined,
+                    dangerous: args.dangerous,
+                    id: args.id ?? undefined,
+                });
+                if (args.format === "json") {
+                    process.stdout.write(`${JSON.stringify(event, null, 2)}\n`);
+                }
+                else {
+                    process.stdout.write(`✓ escalation filed id=${event.id} type=${event.type} status=${event.status}` +
+                        `${event.dangerous ? " dangerous=true" : ""}\n`);
+                    process.stdout.write(`  title=${event.title}\n`);
+                    process.stdout.write(`  store=.deft/escalations/${event.id}.json\n`);
+                }
+                return 0;
+            }
+            case "list": {
+                let typeFilter;
+                if (args.type !== null && args.type.trim().length > 0) {
+                    if (!isEscalationType(args.type.trim().toLowerCase())) {
+                        process.stderr.write(`escalation:list unknown --type '${args.type}'; expected: ${ESCALATION_TYPES.join(", ")}\n`);
+                        return 2;
+                    }
+                    typeFilter = args.type.trim().toLowerCase();
+                }
+                const items = listEscalationsFiltered(args.projectRoot, {
+                    openOnly: args.openOnly,
+                    type: typeFilter,
+                });
+                if (args.format === "json") {
+                    process.stdout.write(`${JSON.stringify(items, null, 2)}\n`);
+                    return 0;
+                }
+                if (items.length === 0) {
+                    process.stdout.write(args.openOnly ? "No open escalations.\n" : "No escalations on disk.\n");
+                    return 0;
+                }
+                process.stdout.write(`Escalations (${items.length}):\n`);
+                for (const e of items) {
+                    const dang = e.dangerous ? " !dangerous" : "";
+                    process.stdout.write(`  - ${e.id} [${e.status}] type=${e.type}${dang} agent=${e.agentId} sla=${e.slaHours}h\n`);
+                    process.stdout.write(`      ${e.title}\n`);
+                    if (e.resolution) {
+                        process.stdout.write(`      → ${e.resolution.decision} by ${e.resolution.resolvedBy} @ ${e.resolution.resolvedAt}\n`);
+                    }
+                }
+                return 0;
+            }
+            case "resolve": {
+                if (args.id === null || args.id.trim().length === 0) {
+                    process.stderr.write("escalation:resolve requires <id>\n");
+                    return 2;
+                }
+                if (args.decision === null || args.decision.trim().length === 0) {
+                    process.stderr.write("escalation:resolve requires --decision approved|denied|answered|dismissed\n");
+                    return 2;
+                }
+                const result = resolveEscalation({
+                    projectRoot: args.projectRoot,
+                    id: args.id,
+                    decision: args.decision,
+                    actor: args.actor,
+                    note: args.note,
+                    answer: args.answer,
+                });
+                if (!result.ok) {
+                    process.stderr.write(`escalation: ${result.message}\n`);
+                    return result.code === "not-found" ? 1 : 2;
+                }
+                if (args.format === "json") {
+                    process.stdout.write(`${JSON.stringify(result.event, null, 2)}\n`);
+                }
+                else {
+                    process.stdout.write(`✓ resolved id=${result.event.id} decision=${result.event.resolution?.decision}\n`);
+                    process.stdout.write("  For gated product actions, mint a Wave 1 grant: deft authz:grant …\n");
+                }
+                return 0;
+            }
+            case "batch-approve": {
+                const batch = batchApproveEscalations({
+                    projectRoot: args.projectRoot,
+                    ids: args.ids.length > 0 ? args.ids : undefined,
+                    actor: args.actor,
+                    note: args.note,
+                    includeDangerous: args.includeDangerous,
+                });
+                if (args.format === "json") {
+                    process.stdout.write(`${JSON.stringify(batch, null, 2)}\n`);
+                }
+                else {
+                    process.stdout.write(`✓ batch-approve approved=${batch.approved.length} skipped=${batch.skipped.length}\n`);
+                    for (const e of batch.approved) {
+                        process.stdout.write(`  + ${e.id} type=${e.type}\n`);
+                    }
+                    for (const s of batch.skipped) {
+                        process.stdout.write(`  - skip ${s.id}: ${s.reason}\n`);
+                    }
+                }
+                return 0;
+            }
+            default:
+                process.stderr.write(`${helpText()}\n`);
+                return 2;
+        }
+    }
+    catch (err) {
+        process.stderr.write(`escalation: ${String(err)}\n`);
+        return 1;
+    }
+}
+export default main;
+if (import.meta.url === `file://${process.argv[1]?.replace(/\\/g, "/")}`) {
+    process.exitCode = main();
+}
+//# sourceMappingURL=escalation-cli.js.map

package/dist/hook-dispatch.d.ts

@@ -48,10 +48,16 @@ export declare function readStdinHardened(readOnce: () => string, options?: {
     nowMs?: () => number;
 }): string;
 export declare function parseArgs(argv: readonly string[]): ParsedArgs;
+/** @deprecated Prefer ParsedHookPayload from @deftai/directive-core/hooks (#2950). */
 export interface ParsedPayload {
     readonly payload: unknown;
     readonly context: HookPayloadContext;
 }
+/**
+ * Parse host hook stdin into payload + context.
+ * Pure implementation lives in core classify (`parseHookStdin`); CLI re-exports
+ * for backward-compatible imports in tests (#2734 / #2738 / #2950).
+ */
 export declare function parsePayload(raw: string): ParsedPayload;
 /**
  * Provider-neutral hook dispatch CLI entry (`deft hook:dispatch` / `deft-hook`).

package/dist/hook-dispatch.js

@@ -2,7 +2,7 @@
 import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { decideHook, hookPayloadTopLevelKeys, isHookEvent, isHookHost, normalizeHookProjectRoot, projectRootFromHookPayload, renderHostDecision, } from "@deftai/directive-core/hooks";
+import { decideHook, hookPayloadTopLevelKeys, isHookEvent, isHookHost, normalizeHookProjectRoot, parseHookStdin, projectRootFromHookPayload, renderHostDecision, } from "@deftai/directive-core/hooks";
 /**
  * How long to re-poll stdin after an empty first read before concluding the host
  * sent nothing (#2864). Keeps well under Cursor's deposited `timeout: 5` while
@@ -103,59 +103,13 @@ export function parseArgs(argv) {
         return { error: "--event is required" };
     return parsed;
 }
-const UTF8_BOM = "\uFEFF";
-const APPLY_PATCH_BEGIN_MARKER = "*** Begin Patch";
-/** Single-file Add/Update only — other *** … File: ops must fail closed (#2738 Greptile). */
-const APPLY_PATCH_MUTATION_LINE_RE = /^\*\*\* (Add File|Update File|Delete File|Move File|Rename File): (.+)$/gm;
-function stripUtf8Bom(raw) {
-    return raw.startsWith(UTF8_BOM) ? raw.slice(UTF8_BOM.length) : raw;
-}
-function trySynthesizeFreeFormApplyPatch(normalized) {
-    if (!normalized.includes(APPLY_PATCH_BEGIN_MARKER))
-        return null;
-    const mutations = [];
-    for (const match of normalized.matchAll(APPLY_PATCH_MUTATION_LINE_RE)) {
-        const op = match[1];
-        const path = match[2]?.trim();
-        if (op === undefined || !path)
-            continue;
-        mutations.push({ op, path });
-    }
-    if (mutations.length !== 1)
-        return null;
-    const sole = mutations[0];
-    if (sole === undefined || (sole.op !== "Add File" && sole.op !== "Update File"))
-        return null;
-    return {
-        payload: {
-            tool_name: "ApplyPatch",
-            tool_input: {
-                path: sole.path,
-                patch: normalized,
-            },
-        },
-        context: {},
-    };
-}
+/**
+ * Parse host hook stdin into payload + context.
+ * Pure implementation lives in core classify (`parseHookStdin`); CLI re-exports
+ * for backward-compatible imports in tests (#2734 / #2738 / #2950).
+ */
 export function parsePayload(raw) {
-    if (raw.trim().length === 0) {
-        return { payload: {}, context: { stdinEmpty: true } };
-    }
-    const normalized = stripUtf8Bom(raw);
-    if (normalized.trim().length === 0) {
-        return { payload: {}, context: { stdinEmpty: true } };
-    }
-    try {
-        return { payload: JSON.parse(normalized), context: {} };
-    }
-    catch {
-        const synthesized = trySynthesizeFreeFormApplyPatch(normalized);
-        if (synthesized !== null)
-            return synthesized;
-        // tool.before is installed only on direct-write matchers, so an unreadable
-        // payload becomes a missing-tool denial rather than a fail-open crash.
-        return { payload: {}, context: { parseFailed: true } };
-    }
+    return parseHookStdin(raw);
 }
 /**
  * Provider-neutral hook dispatch CLI entry (`deft hook:dispatch` / `deft-hook`).

package/dist/lifecycle-stats.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+export interface ParsedLifecycleStatsArgs {
+    projectRoot: string;
+    since: string;
+    json: boolean;
+    error?: string;
+}
+/** Parse lifecycle:stats CLI args. */
+export declare function parseArgs(argv: readonly string[]): ParsedLifecycleStatsArgs;
+/** Native lifecycle:stats handler (#2995). */
+export declare function run(argv?: readonly string[]): number;
+//# sourceMappingURL=lifecycle-stats.d.ts.map

package/dist/lifecycle-stats.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+/**
+ * CLI: deft lifecycle:stats — local xBRIEF folder counts for process rollups (#2995).
+ */
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { collectLifecycleStats, formatLifecycleStatsText, parseDurationMs, } from "@deftai/directive-core/lifecycle";
+/** Parse lifecycle:stats CLI args. */
+export function parseArgs(argv) {
+    const parsed = {
+        projectRoot: ".",
+        since: "7d",
+        json: false,
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === undefined)
+            continue;
+        if (arg === "--json") {
+            parsed.json = true;
+            continue;
+        }
+        if (arg === "--help" || arg === "-h") {
+            return {
+                ...parsed,
+                error: "usage: lifecycle:stats [--since=7d] [--json] [--project-root <path>]\n" +
+                    "  Counts xbrief lifecycle folders (filesystem only). See commands.md § lifecycle:stats.",
+            };
+        }
+        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;
+            continue;
+        }
+        if (arg.startsWith("--project-root=")) {
+            parsed.projectRoot = arg.slice("--project-root=".length);
+            continue;
+        }
+        if (arg === "--since") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --since: expected one argument" };
+            }
+            parsed.since = value;
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith("--since=")) {
+            parsed.since = arg.slice("--since=".length);
+            continue;
+        }
+        if (arg.startsWith("-")) {
+            return { ...parsed, error: `unknown flag: ${arg}` };
+        }
+        return { ...parsed, error: `unexpected argument: ${arg}` };
+    }
+    return parsed;
+}
+/** Native lifecycle:stats handler (#2995). */
+export function run(argv = process.argv.slice(2)) {
+    const args = parseArgs(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`lifecycle_stats: ${args.error}\n`);
+        return 2;
+    }
+    try {
+        parseDurationMs(args.since);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`lifecycle_stats: ${msg}\n`);
+        return 2;
+    }
+    try {
+        const stats = collectLifecycleStats({
+            projectRoot: resolve(args.projectRoot),
+            since: args.since,
+        });
+        if (args.json) {
+            process.stdout.write(`${JSON.stringify(stats, null, 2)}\n`);
+        }
+        else {
+            process.stdout.write(formatLifecycleStatsText(stats));
+        }
+        return 0;
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`lifecycle_stats: ${msg}\n`);
+        return 1;
+    }
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=lifecycle-stats.js.map

package/dist/policy.d.ts

@@ -7,7 +7,7 @@ interface ShowArgs {
     error?: string;
 }
 interface SetArgs {
-    cmd: "show" | "enforce-branches" | "allow-direct-commits" | "enable-value-feedback" | "clear-value-feedback" | "disable-directive" | "enable-directive" | "resolve";
+    cmd: "show" | "enforce-branches" | "allow-direct-commits" | "allow-bot-merge" | "enable-value-feedback" | "clear-value-feedback" | "disable-directive" | "enable-directive" | "resolve";
     confirm: boolean;
     actor: string;
     note: string;

package/dist/policy.js

@@ -6,7 +6,7 @@
 import { existsSync } from "node:fs";
 import { resolve as pathResolve, relative } from "node:path";
 import { fileURLToPath } from "node:url";
-import { clearValueFeedback, createNoDeftDirectiveFlag, describeShadowedPlanExtension, detectNoDeftDirective, detectShadowedPlanExtensions, disclosureLine, enableValueFeedback, FIELD_VALUE_FEEDBACK, FIELD_VALUE_FEEDBACK_CLI_ALIAS, formatValueFeedbackStatusLine, inspectAllPolicies, inspectOnePolicy, loadProjectDefinition, NO_DEFT_DIRECTIVE_DISABLED_MESSAGE, NO_DEFT_DIRECTIVE_FLAG_NAME, NO_DEFT_DIRECTIVE_INCONSISTENT_MESSAGE, policyColonInvocation, projectDefinitionPath, pythonListRepr, pythonStringRepr, registeredPolicyNames, removeNoDeftDirectiveFlag, renderJson, renderText, resolvePolicy, resolveValueFeedback, setPolicy, } from "@deftai/directive-core/policy";
+import { ALLOW_BOT_MERGE_CAPABILITY_COST, clearValueFeedback, createNoDeftDirectiveFlag, describeShadowedPlanExtension, detectNoDeftDirective, detectShadowedPlanExtensions, disclosureLine, enableValueFeedback, FIELD_VALUE_FEEDBACK, FIELD_VALUE_FEEDBACK_CLI_ALIAS, formatValueFeedbackStatusLine, humanMergeDisclosureLine, inspectAllPolicies, inspectOnePolicy, loadProjectDefinition, NO_DEFT_DIRECTIVE_DISABLED_MESSAGE, NO_DEFT_DIRECTIVE_FLAG_NAME, NO_DEFT_DIRECTIVE_INCONSISTENT_MESSAGE, policyColonInvocation, projectDefinitionPath, pythonListRepr, pythonStringRepr, registeredPolicyNames, removeNoDeftDirectiveFlag, renderJson, renderText, resolveHumanMergePolicy, resolvePolicy, resolveValueFeedback, setPolicy, setRequireHumanMerge, } from "@deftai/directive-core/policy";
 const CAPABILITY_COST_DISCLOSURE = "\u26a0 Capability-cost disclosure -- enabling direct commits to the default " +
     "branch turns OFF the deft branch-protection policy.\n" +
     "  \u2022 Pre-commit + pre-push hooks will no longer block default-branch " +
@@ -114,7 +114,7 @@ export function parseShowArgs(argv) {
 /** Parse argv for the policy CLI (show + set subcommands). */
 export function parseArgs(argv) {
     if (argv.length === 0) {
-        const usage = "usage: policy [show|enforce-branches|allow-direct-commits|enable-value-feedback|clear-value-feedback|disable-directive|enable-directive|resolve] ...";
+        const usage = "usage: policy [show|enforce-branches|allow-direct-commits|allow-bot-merge|enable-value-feedback|clear-value-feedback|disable-directive|enable-directive|resolve] ...";
         return makeSetError(usage);
     }
     const cmd = argv[0];
@@ -148,6 +148,7 @@ export function parseArgs(argv) {
     }
     if (cmd === "enforce-branches" ||
         cmd === "allow-direct-commits" ||
+        cmd === "allow-bot-merge" ||
         cmd === "enable-value-feedback" ||
         cmd === "clear-value-feedback" ||
         cmd === "disable-directive" ||
@@ -157,13 +158,15 @@ export function parseArgs(argv) {
             ? policyColonInvocation("enforce-branches")
             : cmd === "allow-direct-commits"
                 ? policyColonInvocation("allow-direct-commits")
-                : cmd === "enable-value-feedback"
-                    ? policyColonInvocation("enable-value-feedback")
-                    : cmd === "clear-value-feedback"
-                        ? policyColonInvocation("clear-value-feedback")
-                        : cmd === "disable-directive"
-                            ? policyColonInvocation("disable-directive")
-                            : policyColonInvocation("enable-directive");
+                : cmd === "allow-bot-merge"
+                    ? policyColonInvocation("allow-bot-merge")
+                    : cmd === "enable-value-feedback"
+                        ? policyColonInvocation("enable-value-feedback")
+                        : cmd === "clear-value-feedback"
+                            ? policyColonInvocation("clear-value-feedback")
+                            : cmd === "disable-directive"
+                                ? policyColonInvocation("disable-directive")
+                                : policyColonInvocation("enable-directive");
         let note = "";
         let projectRoot = ".";
         for (let i = 1; i < argv.length; i += 1) {
@@ -381,6 +384,48 @@ function runEnableDirective(args) {
     process.stdout.write("Directive opt-out cleared. Run `directive init` or `directive update` to ensure install.\n");
     return 0;
 }
+/** Allow agent/bot merge by writing requireHumanMerge=false (#1193). */
+function runAllowBotMerge(args) {
+    const projectRoot = pathResolve(args.projectRoot);
+    if (!args.confirm) {
+        process.stdout.write(`${ALLOW_BOT_MERGE_CAPABILITY_COST}\n\n`);
+        process.stdout.write(`Re-run with --confirm to apply: ${policyColonInvocation("allow-bot-merge", " -- --confirm")}\n`);
+        return 1;
+    }
+    try {
+        const { changed, auditEntry } = setRequireHumanMerge(projectRoot, {
+            requireHumanMerge: false,
+            actor: args.actor,
+            note: args.note,
+        });
+        process.stdout.write(`\u2713 plan.policy.requireHumanMerge=false (human merge gate OFF; agent may merge).\n`);
+        if (changed) {
+            process.stdout.write(`  audit: meta/policy-changes.log :: ${auditEntry}\n`);
+        }
+        else {
+            process.stdout.write("  no-op: value already matched (audit entry still appended for trail).\n");
+        }
+        const line = humanMergeDisclosureLine(resolveHumanMergePolicy(projectRoot));
+        if (line !== null) {
+            process.stdout.write(`${line}\n`);
+        }
+        else {
+            process.stdout.write("[deft policy] Human merge gate is OFF; agent may merge when other gates allow.\n");
+        }
+        return 0;
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (message.includes("PROJECT-DEFINITION not found")) {
+            process.stderr.write(`\u274c ${message}\n`);
+            const pdRel = relative(projectRoot, projectDefinitionPath(projectRoot));
+            process.stderr.write(`  Recovery: run \`task setup\` to generate ${pdRel}.\n`);
+            return 2;
+        }
+        process.stderr.write(`\u274c Config error: ${message}\n`);
+        return 2;
+    }
+}
 /** Run the policy CLI; returns process exit code. */
 export function run(argv) {
     const args = parseArgs(argv);
@@ -402,6 +447,9 @@ export function run(argv) {
     if (args.cmd === "enforce-branches" || args.cmd === "allow-direct-commits") {
         return runSet(args);
     }
+    if (args.cmd === "allow-bot-merge") {
+        return runAllowBotMerge(args);
+    }
     if (args.cmd === "enable-value-feedback") {
         return runEnableValueFeedback(args);
     }

package/dist/pr-finish-loop.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export declare function run(argv: string[]): number;
+//# sourceMappingURL=pr-finish-loop.d.ts.map

package/dist/pr-finish-loop.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { fileURLToPath } from "node:url";
+import { cmdPrFinishLoop } from "@deftai/directive-core/dist/finish-loop/main.js";
+export function run(argv) {
+    return cmdPrFinishLoop(argv);
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=pr-finish-loop.js.map

package/dist/session-ready.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+export interface ParsedSessionReadyArgs {
+    projectRoot: string;
+    emitJson: boolean;
+    withNetwork: boolean;
+    repo: string | null;
+    error?: string;
+}
+/** Parse session:ready CLI args. */
+export declare function parseArgs(argv: readonly string[]): ParsedSessionReadyArgs;
+/** Native session:ready handler (#2993). */
+export declare function run(argv?: readonly string[]): number;
+//# sourceMappingURL=session-ready.d.ts.map