@deftai/directive 0.88.0 → 0.89.0

package/dist/authz.d.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+export declare function main(argv?: string[]): number;
+export default main;
+//# sourceMappingURL=authz.d.ts.map

package/dist/authz.js

@@ -0,0 +1,363 @@
+#!/usr/bin/env node
+/**
+ * Authz CLI (#2944 Wave 1 + #1095 Wave 4): human-origin grants + UAT lease +
+ * AFK closed-verb templates (mint via mintHumanOriginGrant only).
+ *
+ *   deft authz:show
+ *   deft authz:uat-start -- --campaign <id> [--actor <name>] [--note <text>]
+ *   deft authz:uat-suspend
+ *   deft authz:grant -- --operations edit,push --surfaces 'src/**' --cohort <id> ...
+ *   deft authz:grant -- --template release-publish --target 0.30.0
+ *   deft authz:grant -- --template finish-loop
+ *   deft authz:revoke -- <grant-id>
+ */
+import { AFK_TEMPLATE_NAMES, AUTHZ_OPERATIONS, CLOSED_VERB_TEMPLATE_NAMES, FINISH_LOOP_TEMPLATE_NAME, isAfkTemplateName, isClosedVerbTemplateName, isFinishLoopTemplateName, mintAfkTemplateGrant, mintHumanOriginGrant, revokeGrant, showAuthzSnapshot, startUatLease, suspendUatLease, } from "@deftai/directive-core/authz";
+function parseOps(raw) {
+    const allowed = new Set(AUTHZ_OPERATIONS);
+    const out = [];
+    for (const part of raw.split(/[,\s]+/)) {
+        const op = part.trim().toLowerCase();
+        if (op.length === 0)
+            continue;
+        if (!allowed.has(op)) {
+            throw new Error(`unknown operation '${op}'; expected one of ${AUTHZ_OPERATIONS.join(", ")}`);
+        }
+        out.push(op);
+    }
+    return out;
+}
+function parseArgv(argv) {
+    const base = {
+        cmd: "show",
+        projectRoot: process.cwd(),
+        campaign: null,
+        actor: "operator",
+        note: null,
+        operations: [],
+        surfaces: [],
+        cohort: null,
+        planRef: null,
+        repo: null,
+        branch: null,
+        storyIds: [],
+        issueIds: [],
+        expiresAt: null,
+        singleUse: false,
+        grantId: null,
+        template: null,
+        target: null,
+        format: "text",
+    };
+    const args = [...argv];
+    // Drop leading `--` separators from task-style invocation.
+    while (args[0] === "--")
+        args.shift();
+    if (args.length > 0 && !args[0]?.startsWith("-")) {
+        const cmd = args.shift();
+        if (cmd === "show" ||
+            cmd === "uat-start" ||
+            cmd === "uat-suspend" ||
+            cmd === "grant" ||
+            cmd === "revoke") {
+            base.cmd = cmd;
+        }
+        else if (cmd.startsWith("grant-")) {
+            base.cmd = "revoke";
+            base.grantId = cmd;
+        }
+        else {
+            return { ...base, error: `unknown authz 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 === "--campaign") {
+            base.campaign = 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 === "--operations" || a === "--ops") {
+            try {
+                base.operations = parseOps(args[++i] ?? "");
+            }
+            catch (err) {
+                return { ...base, error: String(err) };
+            }
+            continue;
+        }
+        if (a === "--surfaces") {
+            const raw = args[++i] ?? "";
+            base.surfaces = raw
+                .split(/[,\s]+/)
+                .map((s) => s.trim())
+                .filter((s) => s.length > 0);
+            continue;
+        }
+        if (a === "--cohort") {
+            base.cohort = args[++i] ?? null;
+            continue;
+        }
+        if (a === "--plan-ref" || a === "--planRef") {
+            base.planRef = args[++i] ?? null;
+            continue;
+        }
+        if (a === "--repo") {
+            base.repo = args[++i] ?? null;
+            continue;
+        }
+        if (a === "--branch") {
+            base.branch = args[++i] ?? null;
+            continue;
+        }
+        if (a === "--stories" || a === "--story-ids") {
+            const raw = args[++i] ?? "";
+            base.storyIds = raw
+                .split(/[,\s]+/)
+                .map((s) => s.trim())
+                .filter((s) => s.length > 0);
+            continue;
+        }
+        if (a === "--issues" || a === "--issue-ids") {
+            const raw = args[++i] ?? "";
+            base.issueIds = raw
+                .split(/[,\s]+/)
+                .map((s) => Number(s.trim()))
+                .filter((n) => Number.isFinite(n));
+            continue;
+        }
+        if (a === "--expires" || a === "--expires-at") {
+            base.expiresAt = args[++i] ?? null;
+            continue;
+        }
+        if (a === "--single-use") {
+            base.singleUse = true;
+            continue;
+        }
+        if (a === "--format") {
+            const fmt = (args[++i] ?? "text").toLowerCase();
+            base.format = fmt === "json" ? "json" : "text";
+            continue;
+        }
+        if (a === "--grant-id") {
+            base.grantId = args[++i] ?? null;
+            continue;
+        }
+        if (a === "--template") {
+            base.template = args[++i] ?? null;
+            continue;
+        }
+        if (a === "--target") {
+            base.target = args[++i] ?? null;
+            continue;
+        }
+        if (!a.startsWith("-") && base.cmd === "revoke" && base.grantId === null) {
+            base.grantId = a;
+            continue;
+        }
+        if (a === "--help" || a === "-h") {
+            return { ...base, error: "help" };
+        }
+    }
+    return base;
+}
+function helpText() {
+    return [
+        "Usage:",
+        "  deft authz:show [--format json]",
+        "  deft authz:uat-start -- --campaign <id> [--actor <name>] [--note <text>]",
+        "  deft authz:uat-suspend",
+        "  deft authz:grant -- --operations edit,push --surfaces 'src/**' --cohort <id> \\",
+        "      [--stories 2944] [--plan-ref <id>] [--repo owner/name] [--branch <b>] [--expires ISO]",
+        "  deft authz:grant -- --template release-publish --target 0.30.0 [--actor <name>] [--expires ISO]",
+        "  deft authz:grant -- --template finish-loop [--actor <name>] [--expires ISO]",
+        "  deft authz:revoke -- <grant-id>",
+        "",
+        "Human-origin grants are minted only via this CLI (origin.kind=operator-cli).",
+        "Self-authored xBRIEF/lifecycle/dispatch tokens never satisfy implement gates (#2944).",
+        "",
+        `AFK templates (#1095 / #871): ${AFK_TEMPLATE_NAMES.join(", ")}`,
+        `  Closed-verb (#1095): ${CLOSED_VERB_TEMPLATE_NAMES.join(", ")} — require --target`,
+        `  Finish-loop (#871): ${FINISH_LOOP_TEMPLATE_NAME} — edit/push/pr/merge (no release ops)`,
+        "  Templates call mintHumanOriginGrant only — no second session-auth mint engine.",
+        "  Env bypass for a single shell: DEFT_ALLOW_RELEASE_PUBLISH=1 / DEFT_ALLOW_FINISH_LOOP=1.",
+    ].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(`authz: ${args.error}\n`);
+        process.stderr.write(`${helpText()}\n`);
+        return 2;
+    }
+    try {
+        switch (args.cmd) {
+            case "show": {
+                const snap = showAuthzSnapshot(args.projectRoot);
+                if (args.format === "json") {
+                    process.stdout.write(`${JSON.stringify(snap, null, 2)}\n`);
+                    return 0;
+                }
+                const uat = snap.state.uat;
+                if (uat === null) {
+                    process.stdout.write("UAT lease: inactive\n");
+                }
+                else {
+                    process.stdout.write(`UAT lease: ${uat.active ? "ACTIVE" : "suspended"} campaign=${uat.campaignId}\n`);
+                    process.stdout.write(`  started=${uat.startedAt} by=${uat.startedBy.actor} (${uat.startedBy.kind})\n`);
+                    if (uat.suspendedAt)
+                        process.stdout.write(`  suspended=${uat.suspendedAt}\n`);
+                }
+                process.stdout.write(`Active human-origin grants: ${snap.activeGrants.length}\n`);
+                for (const g of snap.activeGrants) {
+                    process.stdout.write(`  - ${g.id} ops=[${g.scope.operations.join(",")}] ` +
+                        `cohort=${g.scope.cohortId ?? "-"} surfaces=${g.scope.surfaces.join("|") || "*"}\n`);
+                }
+                const rejected = snap.allGrants.length - snap.activeGrants.length;
+                if (rejected > 0) {
+                    process.stdout.write(`(${rejected} grant file(s) present but not active/human-origin)\n`);
+                }
+                return 0;
+            }
+            case "uat-start": {
+                if (args.campaign === null || args.campaign.trim().length === 0) {
+                    process.stderr.write("authz:uat-start requires --campaign <id>\n");
+                    return 2;
+                }
+                const { lease } = startUatLease({
+                    projectRoot: args.projectRoot,
+                    campaignId: args.campaign,
+                    actor: args.actor,
+                    note: args.note,
+                });
+                process.stdout.write(`✓ UAT lease ACTIVE campaign=${lease.campaignId} (human-origin operator-cli)\n`);
+                process.stdout.write("  Product edit/push/PR/merge denied until a named fix cohort grant is minted.\n");
+                process.stdout.write("  Tests, evidence capture, and issue filing remain allowed.\n");
+                return 0;
+            }
+            case "uat-suspend": {
+                const state = suspendUatLease({
+                    projectRoot: args.projectRoot,
+                    actor: args.actor,
+                });
+                if (state.uat === null) {
+                    process.stdout.write("UAT lease was already inactive.\n");
+                }
+                else {
+                    process.stdout.write(`✓ UAT lease suspended campaign=${state.uat.campaignId} at ${state.uat.suspendedAt}\n`);
+                }
+                return 0;
+            }
+            case "grant": {
+                // AFK template path (#1095 / #871): presets only — still mintHumanOriginGrant.
+                if (args.template !== null && args.template.trim().length > 0) {
+                    if (!isAfkTemplateName(args.template)) {
+                        process.stderr.write(`authz:grant unknown --template '${args.template}'; expected one of: ${AFK_TEMPLATE_NAMES.join(", ")}\n`);
+                        return 2;
+                    }
+                    if (isClosedVerbTemplateName(args.template) &&
+                        (args.target === null || args.target.trim().length === 0)) {
+                        process.stderr.write(`authz:grant --template ${args.template} requires --target <version>\n`);
+                        return 2;
+                    }
+                    const grant = mintAfkTemplateGrant({
+                        projectRoot: args.projectRoot,
+                        template: args.template,
+                        target: args.target,
+                        actor: args.actor,
+                        expiresAt: args.expiresAt,
+                        singleUse: args.singleUse,
+                        planRef: args.planRef,
+                        repo: args.repo,
+                        branch: args.branch,
+                        surfaces: args.surfaces,
+                        storyIds: args.storyIds,
+                        issueIds: args.issueIds,
+                        cohortId: args.cohort,
+                    });
+                    process.stdout.write(`✓ human-origin grant minted id=${grant.id} origin=${grant.origin.kind} ` +
+                        `template=${args.template}\n`);
+                    if (isFinishLoopTemplateName(args.template)) {
+                        process.stdout.write(`  ops=[${grant.scope.operations.join(",")}] ` +
+                            `(finish-loop walk-away; release-* NOT authorized)\n`);
+                    }
+                    else {
+                        process.stdout.write(`  ops=[${grant.scope.operations.join(",")}] target surfaces=${grant.scope.surfaces.join(", ")}\n`);
+                    }
+                    process.stdout.write("  Authorization SoT: Wave 1 grant store (.deft/authz/grants) — not session-auth.\n");
+                    return 0;
+                }
+                if (args.operations.length === 0) {
+                    process.stderr.write("authz:grant requires --operations <edit,push,...> or --template <finish-loop|release-*> \n");
+                    return 2;
+                }
+                const grant = mintHumanOriginGrant({
+                    projectRoot: args.projectRoot,
+                    actor: args.actor,
+                    operations: args.operations,
+                    surfaces: args.surfaces,
+                    cohortId: args.cohort,
+                    planRef: args.planRef,
+                    repo: args.repo,
+                    branch: args.branch,
+                    storyIds: args.storyIds,
+                    issueIds: args.issueIds,
+                    expiresAt: args.expiresAt,
+                    singleUse: args.singleUse,
+                });
+                process.stdout.write(`✓ human-origin grant minted id=${grant.id} origin=${grant.origin.kind}\n`);
+                process.stdout.write(`  ops=[${grant.scope.operations.join(",")}] cohort=${grant.scope.cohortId ?? "-"}\n`);
+                if (grant.scope.surfaces.length > 0) {
+                    process.stdout.write(`  surfaces=${grant.scope.surfaces.join(", ")}\n`);
+                }
+                return 0;
+            }
+            case "revoke": {
+                if (args.grantId === null) {
+                    process.stderr.write("authz:revoke requires <grant-id>\n");
+                    return 2;
+                }
+                const revoked = revokeGrant({
+                    projectRoot: args.projectRoot,
+                    grantId: args.grantId,
+                });
+                if (revoked === null) {
+                    process.stderr.write(`authz: grant not found: ${args.grantId}\n`);
+                    return 1;
+                }
+                process.stdout.write(`✓ grant revoked id=${revoked.id} at ${revoked.semantics.revokedAt}\n`);
+                return 0;
+            }
+            default:
+                process.stderr.write(`${helpText()}\n`);
+                return 2;
+        }
+    }
+    catch (err) {
+        process.stderr.write(`authz: ${String(err)}\n`);
+        return 1;
+    }
+}
+export default main;
+if (import.meta.url === `file://${process.argv[1]?.replace(/\\/g, "/")}`) {
+    process.exitCode = main();
+}
+//# sourceMappingURL=authz.js.map

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

@@ -36,6 +36,7 @@ export const PR_VERB_MAP = {
     "check-closing-keywords": "pr-closing-keywords",
     "wait-mergeable-and-merge": "pr-wait-mergeable",
     watch: "pr-watch",
+    "finish-loop": "pr-finish-loop",
 };
 /** verify:* aliases that map to non-verify-* handler stems. */
 export const VERIFY_VERB_MAP = {
@@ -74,8 +75,18 @@ export const SUBCOMMAND_ROUTES = {
     "policy:enable-directive": ["policy", "enable-directive"],
     "policy:enforce-branches": ["policy", "enforce-branches"],
     "policy:allow-direct-commits": ["policy", "allow-direct-commits"],
+    "policy:allow-bot-merge": ["policy", "allow-bot-merge"],
     "policy:enable-value-feedback": ["policy", "enable-value-feedback"],
     "policy:clear-value-feedback": ["policy", "clear-value-feedback"],
+    "authz:show": ["authz", "show"],
+    "authz:uat-start": ["authz", "uat-start"],
+    "authz:uat-suspend": ["authz", "uat-suspend"],
+    "authz:grant": ["authz", "grant"],
+    "authz:revoke": ["authz", "revoke"],
+    "escalation:file": ["escalation-cli", "file"],
+    "escalation:list": ["escalation-cli", "list"],
+    "escalation:resolve": ["escalation-cli", "resolve"],
+    "escalation:batch-approve": ["escalation-cli", "batch-approve"],
     "product-signal:status": ["product-signal", "status"],
     "product-signal:enable": ["product-signal", "enable"],
     "product-signal:consent": ["product-signal", "consent"],
@@ -89,9 +100,11 @@ export const SUBCOMMAND_ROUTES = {
     "github-body:issue-create": ["github-body", "issue-create"],
     "github-body:issue-edit": ["github-body", "issue-edit"],
     "github-body:issue-fetch": ["github-body", "issue-fetch"],
+    "github-body:issue-lint": ["github-body", "issue-lint"],
     "github-body:comment-create": ["github-body", "comment-create"],
     "github-body:comment-edit": ["github-body", "comment-edit"],
     "github-body:pr-edit": ["github-body", "pr-edit"],
+    "github-body:pr-lint": ["github-body", "pr-lint"],
     "plan-sequence:set": ["plan-sequence", "set"],
     "plan-sequence:current": ["plan-sequence", "current"],
     "plan-sequence:clear": ["plan-sequence", "clear"],

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

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

package/dist/directive-finish-loop.js

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

package/dist/dispatch.d.ts

@@ -10,13 +10,17 @@ export interface DispatchIo {
     writeErr: (text: string) => void;
 }
 /** CLI modules in packages/cli/src (excluding parity harnesses and bin/index). */
-export declare const CLI_MODULE_VERBS: readonly ["agents-refresh", "cache", "check", "capacity-backfill", "capacity-show", "codebase-default-extractor", "codebase-map", "codebase-map-fresh", "codebase-projection-registry", "codebase-provider", "doctor", "install-upgrade", "install-uninstall", "migrate-preflight", "migrate-xbrief", "migrate-category-b", "framework-check-updates", "hook-dispatch", "umbrella-current-shape", "changelog-check", "change-init", "commit-lint", "coverage-hotspots", "policy", "pr-closing-keywords", "pr-merge-readiness", "pr-monitor", "pr-protected-issues", "pr-wait-mergeable", "pr-watch", "preflight-cache", "preflight-gh", "probe-session", "release", "release-e2e", "release-publish", "release-rollback", "scope-lifecycle", "lifecycle-event", "session-start", "plan-sequence", "slice", "subagent-monitor", "toolchain-check", "triage-actions", "triage-bootstrap", "triage-bulk", "triage-classify", "triage-help", "triage-queue", "triage-reconcile", "triage-refresh", "triage-scope", "triage-scope-drift", "triage-smoketest", "triage-subscribe", "triage-summary", "triage-welcome", "ts-check-lane", "vbrief-activate", "vbrief-build", "vbrief-preflight", "vbrief-reconcile", "vbrief-validate", "vbrief-validation", "verify-branch", "verify-encoding", "verify-forward-coverage", "verify-hooks-installed", "verify-investigation", "verify-judgment-gates", "verify-no-task-runtime", "validate-links", "validate-strategy-output", "verify-biome-config", "verify-bridge-drift", "verify-capacity", "verify-content-manifest", "verify-skill-external-fetch-gate", "verify-contract-drift", "verify-cursor-tier1", "verify-openclaw-tier1", "verify-go-freeze", "verify-scm-boundary", "verify-session-ritual", "verify-plan-sequence", "verify-stubs", "verify-xbrief-drift", "rule-ownership-lint", "verify-story-ready", "verify-review-monitor", "verify-subagent-alive", "review-monitor-register", "review-monitor-release", "verify-tools", "verify-wip-cap", "verify-orphan-active", "verify-agents-md-budget", "verify-agents-md-advisory", "verify-eval-health-relocation", "verify-eval-triggers-relocation", "eval-health", "eval-run", "eval-report", "eval-triggers"];
+export declare const CLI_MODULE_VERBS: readonly ["agents-refresh", "cache", "check", "capacity-backfill", "capacity-show", "codebase-default-extractor", "codebase-map", "codebase-map-fresh", "codebase-projection-registry", "codebase-provider", "doctor", "install-upgrade", "install-uninstall", "migrate-preflight", "migrate-xbrief", "migrate-category-b", "framework-check-updates", "hook-dispatch", "umbrella-current-shape", "changelog-check", "change-init", "commit-lint", "coverage-hotspots", "policy", "authz", "escalation-cli", "pr-closing-keywords", "pr-merge-readiness", "pr-monitor", "pr-protected-issues", "pr-wait-mergeable", "pr-watch", "pr-finish-loop", "directive-finish-loop", "preflight-cache", "preflight-gh", "probe-session", "release", "release-e2e", "release-publish", "release-rollback", "scope-lifecycle", "lifecycle-event", "session-start", "plan-sequence", "slice", "subagent-monitor", "toolchain-check", "triage-actions", "triage-bootstrap", "triage-bulk", "triage-classify", "triage-help", "triage-queue", "triage-reconcile", "triage-refresh", "triage-scope", "triage-scope-drift", "triage-smoketest", "triage-subscribe", "triage-summary", "triage-welcome", "ts-check-lane", "vbrief-activate", "vbrief-build", "vbrief-preflight", "vbrief-reconcile", "vbrief-validate", "vbrief-validation", "verify-branch", "verify-encoding", "verify-forward-coverage", "verify-hooks-installed", "verify-investigation", "verify-judgment-gates", "verify-no-task-runtime", "validate-links", "validate-strategy-output", "verify-biome-config", "verify-bridge-drift", "verify-capacity", "verify-contained-writes", "verify-content-manifest", "verify-skill-external-fetch-gate", "verify-contract-drift", "verify-cursor-tier1", "verify-openclaw-tier1", "verify-go-freeze", "verify-scm-boundary", "verify-session-ritual", "verify-plan-sequence", "verify-stubs", "verify-xbrief-drift", "rule-ownership-lint", "verify-story-ready", "verify-review-monitor", "verify-subagent-alive", "review-monitor-register", "review-monitor-release", "verify-tools", "verify-wip-cap", "verify-orphan-active", "verify-agents-md-budget", "verify-agents-md-advisory", "verify-eval-health-relocation", "verify-eval-triggers-relocation", "eval-health", "eval-run", "eval-report", "eval-triggers"];
 /** Core-only CLI entrypoints without a packages/cli wrapper. */
 export declare const CORE_MODULE_VERBS: readonly ["scm", "github-auth-modes", "github-body", "issue-emit", "issue-ingest", "issue-sync-from-xbrief", "reconcile-issues", "swarm-launch", "swarm-complete-cohort", "swarm-finalize-cohort", "swarm-readiness", "swarm-routing-verify", "swarm-routing-set", "swarm-verify-review-clean", "swarm-worktrees", "framework-commands", "pack-render", "packs-slice", "prd-render", "export-spec", "project-render", "roadmap-render", "rule-map", "spec-render", "spec-validate", "code-structure-validate", "pack-migrate-skills", "pack-migrate-rules", "pack-migrate-strategies", "pack-migrate-patterns", "pack-migrate-swarm-spec", "policy-set", "setup-ghx", "scope-undo", "scope-demote", "scope-decompose", "changelog-resolve-unreleased", "architecture-preflight-sor", "feedback-file", "value-readback", "product-signal"];
 /** Colon aliases for triage-actions (mirrors cli-router SUBCOMMAND_ROUTES). */
 export declare const TRIAGE_ACTION_ALIAS_SUBCOMMANDS: Readonly<Record<string, string>>;
 /** Colon aliases for policy subcommands (mirrors cli-router SUBCOMMAND_ROUTES). */
 export declare const POLICY_ACTION_ALIAS_SUBCOMMANDS: Readonly<Record<string, string>>;
+/** Colon aliases for authz subcommands (#2944). */
+export declare const AUTHZ_ACTION_ALIAS_SUBCOMMANDS: Readonly<Record<string, string>>;
+/** Colon aliases for escalation subcommands (#518). */
+export declare const ESCALATION_ACTION_ALIAS_SUBCOMMANDS: Readonly<Record<string, string>>;
 /** Colon aliases for plan-sequence subcommands (#2402). */
 export declare const PLAN_SEQUENCE_ALIAS_SUBCOMMANDS: Readonly<Record<string, string>>;
 /** Colon aliases for product-signal subcommands (#2693). */

package/dist/dispatch.js

@@ -50,12 +50,16 @@ export const CLI_MODULE_VERBS = [
     "commit-lint",
     "coverage-hotspots",
     "policy",
+    "authz",
+    "escalation-cli",
     "pr-closing-keywords",
     "pr-merge-readiness",
     "pr-monitor",
     "pr-protected-issues",
     "pr-wait-mergeable",
     "pr-watch",
+    "pr-finish-loop",
+    "directive-finish-loop",
     "preflight-cache",
     "preflight-gh",
     "probe-session",
@@ -103,6 +107,7 @@ export const CLI_MODULE_VERBS = [
     "verify-biome-config",
     "verify-bridge-drift",
     "verify-capacity",
+    "verify-contained-writes",
     "verify-content-manifest",
     "verify-skill-external-fetch-gate",
     "verify-contract-drift",
@@ -193,12 +198,30 @@ export const POLICY_ACTION_ALIAS_SUBCOMMANDS = {
     "policy:show": "show",
     "policy:enforce-branches": "enforce-branches",
     "policy:allow-direct-commits": "allow-direct-commits",
+    "policy:allow-bot-merge": "allow-bot-merge",
     "policy:enable-value-feedback": "enable-value-feedback",
     "policy:clear-value-feedback": "clear-value-feedback",
     "policy:disable-directive": "disable-directive",
     "policy:enable-directive": "enable-directive",
 };
 const POLICY_ACTION_COLON_ALIASES = Object.fromEntries(Object.keys(POLICY_ACTION_ALIAS_SUBCOMMANDS).map((alias) => [alias, "policy"]));
+/** Colon aliases for authz subcommands (#2944). */
+export const AUTHZ_ACTION_ALIAS_SUBCOMMANDS = {
+    "authz:show": "show",
+    "authz:uat-start": "uat-start",
+    "authz:uat-suspend": "uat-suspend",
+    "authz:grant": "grant",
+    "authz:revoke": "revoke",
+};
+const AUTHZ_ACTION_COLON_ALIASES = Object.fromEntries(Object.keys(AUTHZ_ACTION_ALIAS_SUBCOMMANDS).map((alias) => [alias, "authz"]));
+/** Colon aliases for escalation subcommands (#518). */
+export const ESCALATION_ACTION_ALIAS_SUBCOMMANDS = {
+    "escalation:file": "file",
+    "escalation:list": "list",
+    "escalation:resolve": "resolve",
+    "escalation:batch-approve": "batch-approve",
+};
+const ESCALATION_ACTION_COLON_ALIASES = Object.fromEntries(Object.keys(ESCALATION_ACTION_ALIAS_SUBCOMMANDS).map((alias) => [alias, "escalation-cli"]));
 /** Colon aliases for plan-sequence subcommands (#2402). */
 export const PLAN_SEQUENCE_ALIAS_SUBCOMMANDS = {
     "plan-sequence:set": "set",
@@ -251,6 +274,7 @@ export const VERB_ALIASES = {
     "verify:rule-ownership": "rule-ownership-lint",
     "rule:ownership-lint": "rule-ownership-lint",
     "verify:biome-config": "verify-biome-config",
+    "verify:contained-writes": "verify-contained-writes",
     "verify:content-manifest": "verify-content-manifest",
     "verify:skill-external-fetch-gate": "verify-skill-external-fetch-gate",
     "verify:contract-drift": "verify-contract-drift",
@@ -275,6 +299,8 @@ export const VERB_ALIASES = {
     "triage:scope": "triage-scope",
     ...TRIAGE_ACTION_COLON_ALIASES,
     ...POLICY_ACTION_COLON_ALIASES,
+    ...AUTHZ_ACTION_COLON_ALIASES,
+    ...ESCALATION_ACTION_COLON_ALIASES,
     ...PRODUCT_SIGNAL_COLON_ALIASES,
     "agents:refresh": "agents-refresh",
     "migrate:preflight": "migrate-preflight",
@@ -295,6 +321,8 @@ export const VERB_ALIASES = {
     "docs:rule-map": "rule-map",
     "project:export-spec": "export-spec",
     "pr:watch": "pr-watch",
+    "pr:finish-loop": "pr-finish-loop",
+    "directive:finish-loop": "directive-finish-loop",
     doctor: "doctor",
     "eval:health": "eval-health",
     "feedback:file": "feedback-file",
@@ -311,6 +339,7 @@ const SUBDIR_CLI_STEMS = {
     "verify-stubs": "verify-source-cli/verify-stubs",
     "rule-ownership-lint": "verify-source-cli/rule-ownership-lint",
     "verify-biome-config": "verify-source-cli/verify-biome-config",
+    "verify-contained-writes": "verify-source-cli/verify-contained-writes",
     "verify-content-manifest": "verify-source-cli/verify-content-manifest",
     "verify-skill-external-fetch-gate": "verify-source-cli/verify-skill-external-fetch-gate",
     "verify-contract-drift": "verify-source-cli/verify-contract-drift",
@@ -2598,6 +2627,8 @@ export async function dispatch(argv, io = defaultIo()) {
         const handler = await loadHandler(canonical, io);
         const triageSubcommand = verb !== undefined ? TRIAGE_ACTION_ALIAS_SUBCOMMANDS[verb] : undefined;
         const policySubcommand = verb !== undefined ? POLICY_ACTION_ALIAS_SUBCOMMANDS[verb] : undefined;
+        const authzSubcommand = verb !== undefined ? AUTHZ_ACTION_ALIAS_SUBCOMMANDS[verb] : undefined;
+        const escalationSubcommand = verb !== undefined ? ESCALATION_ACTION_ALIAS_SUBCOMMANDS[verb] : undefined;
         const planSequenceSubcommand = verb !== undefined ? PLAN_SEQUENCE_ALIAS_SUBCOMMANDS[verb] : undefined;
         const productSignalSubcommand = verb !== undefined ? PRODUCT_SIGNAL_ALIAS_SUBCOMMANDS[verb] : undefined;
         const handlerArgv = canonical === "framework-commands" && verb !== undefined && verb !== canonical
@@ -2606,11 +2637,15 @@ export async function dispatch(argv, io = defaultIo()) {
                 ? [triageSubcommand, ...rest]
                 : policySubcommand !== undefined && canonical === "policy"
                     ? [policySubcommand, ...rest]
-                    : planSequenceSubcommand !== undefined && canonical === "plan-sequence"
-                        ? [planSequenceSubcommand, ...rest]
-                        : productSignalSubcommand !== undefined && canonical === "product-signal"
-                            ? [productSignalSubcommand, ...rest]
-                            : rest;
+                    : authzSubcommand !== undefined && canonical === "authz"
+                        ? [authzSubcommand, ...rest]
+                        : escalationSubcommand !== undefined && canonical === "escalation-cli"
+                            ? [escalationSubcommand, ...rest]
+                            : planSequenceSubcommand !== undefined && canonical === "plan-sequence"
+                                ? [planSequenceSubcommand, ...rest]
+                                : productSignalSubcommand !== undefined && canonical === "product-signal"
+                                    ? [productSignalSubcommand, ...rest]
+                                    : rest;
         return await invokeHandler(handler, handlerArgv);
     }
     catch (err) {

package/dist/escalation-cli.d.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+export declare function main(argv?: string[]): number;
+export default main;
+//# sourceMappingURL=escalation-cli.d.ts.map

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/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/verify-source-cli/verify-contained-writes.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+interface ParsedArgs {
+    projectRoot: string;
+    enforce: boolean;
+    help?: boolean;
+    error?: string;
+}
+/** Parse verify-contained-writes CLI args (#2951). */
+export declare function parseArgs(argv: string[]): ParsedArgs;
+/** Run the gate and return the process exit code. */
+export declare function run(argv: string[]): number;
+export {};
+//# sourceMappingURL=verify-contained-writes.d.ts.map

package/dist/verify-source-cli/verify-contained-writes.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+/**
+ * CLI for task verify:contained-writes (#2951 Phase 1).
+ * Fail-open by default; pass --enforce for fail-closed (later phases).
+ */
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { evaluateContainedWrites } from "@deftai/directive-core/verify-source";
+/** Parse verify-contained-writes CLI args (#2951). */
+export function parseArgs(argv) {
+    const parsed = { projectRoot: ".", enforce: false };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--project-root") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --project-root: expected one argument" };
+            }
+            parsed.projectRoot = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--project-root=")) {
+            parsed.projectRoot = arg.slice("--project-root=".length);
+        }
+        else if (arg === "--enforce") {
+            parsed.enforce = true;
+        }
+        else if (arg === "--help" || arg === "-h") {
+            return { ...parsed, help: true };
+        }
+        else {
+            return { ...parsed, error: `unrecognized argument: ${arg}` };
+        }
+    }
+    return parsed;
+}
+const HELP_TEXT = "Usage: verify-contained-writes [--project-root <path>] [--enforce]\n" +
+    "  Inventory raw write sinks outside the allowlist (#2951).\n" +
+    "  Default: fail-open (exit 0 with advisory report).\n" +
+    "  --enforce: fail closed (exit 1) when non-allowlisted sinks remain.\n";
+/** Run the gate and return the process exit code. */
+export function run(argv) {
+    const args = parseArgs(argv);
+    if (args.help === true) {
+        process.stdout.write(HELP_TEXT);
+        return 0;
+    }
+    if (args.error !== undefined) {
+        process.stderr.write(`verify_contained_writes: ${args.error}\n`);
+        return 2;
+    }
+    const result = evaluateContainedWrites({
+        projectRoot: resolve(args.projectRoot),
+        enforce: args.enforce,
+    });
+    if (result.stream === "stdout") {
+        process.stdout.write(`${result.message}\n`);
+    }
+    else {
+        process.stderr.write(`${result.message}\n`);
+    }
+    return result.code;
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=verify-contained-writes.js.map

package/package.json

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