@deftai/directive-core 0.91.0 → 0.93.0

package/dist/policy/host-slash-commands.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Per-host slash-command deposit policy (#3054 / epic #55 L6).
+ *
+ * Parallel to {@link plan.policy.hostHooks}: default multi-host enablement for
+ * every host that has a real emitter (no stubs). Per-host `false` opts out.
+ */
+import { type SlashEmitterHostId } from "../slash/emitters.js";
+export declare const FIELD_HOST_SLASH_COMMANDS = "plan.policy.hostSlashCommands";
+export declare const FIELD_HOST_SLASH_COMMANDS_CLI_ALIAS = "hostSlashCommands";
+/** Per-host Directive slash-command deposit toggles (#3054). */
+export type HostSlashCommandsPolicy = Record<SlashEmitterHostId, boolean>;
+/** Default = all hosts with real emitters enabled (L6; not single-host-only). */
+export declare const DEFAULT_HOST_SLASH_COMMANDS_POLICY: HostSlashCommandsPolicy;
+export interface HostSlashCommandsPolicyField {
+    readonly name: string;
+    readonly current: HostSlashCommandsPolicy;
+    readonly default: HostSlashCommandsPolicy;
+    readonly source: string;
+}
+/** Resolve typed slash-command deposit policy from raw PROJECT-DEFINITION value. */
+export declare function resolveHostSlashCommandsPolicy(raw: unknown): HostSlashCommandsPolicy;
+export declare function validateHostSlashCommands(value: unknown): string[];
+export declare function isHostSlashCommandDepositEnabled(host: SlashEmitterHostId, policy?: HostSlashCommandsPolicy): boolean;
+/** Inspector row for `policy:show --field=hostSlashCommands`. */
+export declare function inspectHostSlashCommands(data: Record<string, unknown> | null): HostSlashCommandsPolicyField;
+/** Resolve slash-command deposit policy from PROJECT-DEFINITION on disk. */
+export declare function loadHostSlashCommandsPolicyFromProject(projectRoot: string): HostSlashCommandsPolicy;
+//# sourceMappingURL=host-slash-commands.d.ts.map

package/dist/policy/host-slash-commands.js

@@ -0,0 +1,103 @@
+/**
+ * Per-host slash-command deposit policy (#3054 / epic #55 L6).
+ *
+ * Parallel to {@link plan.policy.hostHooks}: default multi-host enablement for
+ * every host that has a real emitter (no stubs). Per-host `false` opts out.
+ */
+import { isSlashEmitterHostId, SLASH_EMITTER_HOSTS, } from "../slash/emitters.js";
+import { readPlanPolicy } from "./plan-extensions.js";
+import { loadProjectDefinition } from "./resolve.js";
+export const FIELD_HOST_SLASH_COMMANDS = "plan.policy.hostSlashCommands";
+export const FIELD_HOST_SLASH_COMMANDS_CLI_ALIAS = "hostSlashCommands";
+/** Default = all hosts with real emitters enabled (L6; not single-host-only). */
+export const DEFAULT_HOST_SLASH_COMMANDS_POLICY = Object.freeze({
+    claude: true,
+    cursor: true,
+    grok: true,
+    codex: true,
+});
+function readHostBoolean(rec, host, fallback) {
+    if (host in rec && typeof rec[host] === "boolean") {
+        return rec[host];
+    }
+    return fallback;
+}
+/** Resolve typed slash-command deposit policy from raw PROJECT-DEFINITION value. */
+export function resolveHostSlashCommandsPolicy(raw) {
+    if (raw === null || raw === undefined) {
+        return { ...DEFAULT_HOST_SLASH_COMMANDS_POLICY };
+    }
+    if (typeof raw !== "object" || Array.isArray(raw)) {
+        return { ...DEFAULT_HOST_SLASH_COMMANDS_POLICY };
+    }
+    const rec = raw;
+    return {
+        claude: readHostBoolean(rec, "claude", DEFAULT_HOST_SLASH_COMMANDS_POLICY.claude),
+        cursor: readHostBoolean(rec, "cursor", DEFAULT_HOST_SLASH_COMMANDS_POLICY.cursor),
+        grok: readHostBoolean(rec, "grok", DEFAULT_HOST_SLASH_COMMANDS_POLICY.grok),
+        codex: readHostBoolean(rec, "codex", DEFAULT_HOST_SLASH_COMMANDS_POLICY.codex),
+    };
+}
+export function validateHostSlashCommands(value) {
+    if (value === null || value === undefined) {
+        return [];
+    }
+    if (typeof value !== "object" || Array.isArray(value)) {
+        return [`${FIELD_HOST_SLASH_COMMANDS} must be an object; got ${typeof value}`];
+    }
+    const rec = value;
+    const errors = [];
+    for (const host of SLASH_EMITTER_HOSTS) {
+        if (host in rec && typeof rec[host] !== "boolean") {
+            errors.push(`${FIELD_HOST_SLASH_COMMANDS}.${host} must be a boolean`);
+        }
+    }
+    for (const key of Object.keys(rec)) {
+        if (!isSlashEmitterHostId(key)) {
+            errors.push(`${FIELD_HOST_SLASH_COMMANDS}.${key} is not a slash emitter host (${SLASH_EMITTER_HOSTS.join(", ")})`);
+        }
+    }
+    return errors;
+}
+export function isHostSlashCommandDepositEnabled(host, policy = DEFAULT_HOST_SLASH_COMMANDS_POLICY) {
+    return policy[host];
+}
+function fieldFromResolved(resolved, source) {
+    return {
+        name: FIELD_HOST_SLASH_COMMANDS,
+        current: resolved,
+        default: { ...DEFAULT_HOST_SLASH_COMMANDS_POLICY },
+        source,
+    };
+}
+/** Inspector row for `policy:show --field=hostSlashCommands`. */
+export function inspectHostSlashCommands(data) {
+    if (data === null) {
+        return fieldFromResolved({ ...DEFAULT_HOST_SLASH_COMMANDS_POLICY }, "default");
+    }
+    const policyBlock = readPlanPolicy(data.plan);
+    if (typeof policyBlock !== "object" ||
+        policyBlock === null ||
+        Array.isArray(policyBlock) ||
+        !("hostSlashCommands" in policyBlock)) {
+        return fieldFromResolved({ ...DEFAULT_HOST_SLASH_COMMANDS_POLICY }, "default");
+    }
+    const resolved = resolveHostSlashCommandsPolicy(policyBlock.hostSlashCommands);
+    return fieldFromResolved(resolved, "typed");
+}
+/** Resolve slash-command deposit policy from PROJECT-DEFINITION on disk. */
+export function loadHostSlashCommandsPolicyFromProject(projectRoot) {
+    const [data] = loadProjectDefinition(projectRoot);
+    if (data === null) {
+        return { ...DEFAULT_HOST_SLASH_COMMANDS_POLICY };
+    }
+    const policyBlock = readPlanPolicy(data.plan);
+    if (typeof policyBlock !== "object" ||
+        policyBlock === null ||
+        Array.isArray(policyBlock) ||
+        !("hostSlashCommands" in policyBlock)) {
+        return { ...DEFAULT_HOST_SLASH_COMMANDS_POLICY };
+    }
+    return resolveHostSlashCommandsPolicy(policyBlock.hostSlashCommands);
+}
+//# sourceMappingURL=host-slash-commands.js.map

package/dist/policy/index.d.ts

@@ -2,8 +2,11 @@ export * from "./agents-md-advisory.js";
 export * from "./autonomy.js";
 export * from "./capacity.js";
 export * from "./decisions.js";
+export * from "./deft-directive-disable.js";
+export * from "./delivery-branch.js";
 export * from "./disclosure.js";
 export * from "./host-hooks.js";
+export * from "./host-slash-commands.js";
 export * from "./hotfix-criteria.js";
 export * from "./intent-ceiling.js";
 export * from "./no-deft-directive.js";

package/dist/policy/index.js

@@ -1,4 +1,8 @@
+import { FIELD_HOST_SKILL_DISCOVERY, FIELD_HOST_SKILL_DISCOVERY_CLI_ALIAS, inspectHostSkillDiscovery, } from "../init-deposit/skill-discovery-hosts.js";
+import { FIELD_OPENCLAW_PRODUCT_COMMANDS, FIELD_OPENCLAW_PRODUCT_COMMANDS_CLI_ALIAS, inspectOpenClawProductCommands, } from "../slash/openclaw-deposit.js";
+import { FIELD_DELIVERY_BRANCH, FIELD_DELIVERY_BRANCH_CLI_ALIAS, inspectDeliveryBranch, } from "./delivery-branch.js";
 import { FIELD_HOST_HOOKS, FIELD_HOST_HOOKS_CLI_ALIAS, inspectHostHooks } from "./host-hooks.js";
+import { FIELD_HOST_SLASH_COMMANDS, FIELD_HOST_SLASH_COMMANDS_CLI_ALIAS, inspectHostSlashCommands, } from "./host-slash-commands.js";
 import { FIELD_HOTFIX_CRITERIA, FIELD_HOTFIX_CRITERIA_CLI_ALIAS, inspectHotfixCriteria, } from "./hotfix-criteria.js";
 import { readPlanPolicy } from "./plan-extensions.js";
 import { FIELD_PRODUCT_SIGNAL, FIELD_PRODUCT_SIGNAL_CLI_ALIAS, inspectProductSignal, } from "./product-signal.js";
@@ -12,8 +16,11 @@ export * from "./agents-md-advisory.js";
 export * from "./autonomy.js";
 export * from "./capacity.js";
 export * from "./decisions.js";
+export * from "./deft-directive-disable.js";
+export * from "./delivery-branch.js";
 export * from "./disclosure.js";
 export * from "./host-hooks.js";
+export * from "./host-slash-commands.js";
 export * from "./hotfix-criteria.js";
 export * from "./intent-ceiling.js";
 export * from "./no-deft-directive.js";
@@ -38,6 +45,7 @@ export const FIELD_TRIAGE_RANKING_LABELS = "plan.policy.triageRankingLabels";
 export const FIELD_TRIAGE_AUTO_CLASSIFY = "plan.policy.triageAutoClassify";
 export const FIELD_TRIAGE_HOLD_MARKERS = "plan.policy.triageHoldMarkers";
 export const FIELD_SWARM_SUBAGENT_BACKEND = "plan.policy.swarmSubagentBackend";
+// deliveryBranch also exported from delivery-branch.js via export *
 export const DEFAULT_SESSION_RITUAL_STALENESS_HOURS = 4;
 export const DEFAULT_TRIAGE_SCOPE_VALUE = [
     { rule: "all-open" },
@@ -278,6 +286,33 @@ function inspectHostHooksField(data) {
         source: field.source,
     };
 }
+function inspectHostSlashCommandsField(data) {
+    const field = inspectHostSlashCommands(data);
+    return {
+        name: field.name,
+        current: field.current,
+        default: field.default,
+        source: field.source,
+    };
+}
+function inspectOpenClawProductCommandsField(data) {
+    const field = inspectOpenClawProductCommands(data);
+    return {
+        name: field.name,
+        current: field.current,
+        default: field.default,
+        source: field.source,
+    };
+}
+function inspectHostSkillDiscoveryField(data) {
+    const field = inspectHostSkillDiscovery(data);
+    return {
+        name: field.name,
+        current: field.current,
+        default: field.default,
+        source: field.source,
+    };
+}
 function inspectRequireHumanMergeField(data, projectRoot) {
     const field = inspectRequireHumanMerge(data, projectRoot);
     return {
@@ -296,6 +331,15 @@ function inspectHotfixCriteriaField(data) {
         source: field.source,
     };
 }
+function inspectDeliveryBranchField(data, projectRoot) {
+    const field = inspectDeliveryBranch(data, projectRoot);
+    return {
+        name: field.name,
+        current: field.current,
+        default: field.default,
+        source: field.source,
+    };
+}
 const REGISTERED_POLICIES = [
     inspectAllowDirectCommits,
     inspectWipCap,
@@ -308,7 +352,11 @@ const REGISTERED_POLICIES = [
         emptyIsTyped: true,
     }),
     inspectSwarmSubagentBackend,
+    inspectDeliveryBranchField,
     inspectHostHooksField,
+    inspectHostSlashCommandsField,
+    inspectOpenClawProductCommandsField,
+    inspectHostSkillDiscoveryField,
     inspectStalenessTicklerField,
     inspectRuntimeAuthorityField,
     inspectProductSignalField,
@@ -333,11 +381,19 @@ export function inspectOnePolicy(name, projectRoot) {
                     ? FIELD_RUNTIME_AUTHORITY
                     : name === FIELD_HOST_HOOKS_CLI_ALIAS
                         ? FIELD_HOST_HOOKS
-                        : name === FIELD_REQUIRE_HUMAN_MERGE_CLI_ALIAS
-                            ? FIELD_REQUIRE_HUMAN_MERGE
-                            : name === FIELD_HOTFIX_CRITERIA_CLI_ALIAS
-                                ? FIELD_HOTFIX_CRITERIA
-                                : name;
+                        : name === FIELD_HOST_SLASH_COMMANDS_CLI_ALIAS
+                            ? FIELD_HOST_SLASH_COMMANDS
+                            : name === FIELD_OPENCLAW_PRODUCT_COMMANDS_CLI_ALIAS
+                                ? FIELD_OPENCLAW_PRODUCT_COMMANDS
+                                : name === FIELD_HOST_SKILL_DISCOVERY_CLI_ALIAS
+                                    ? FIELD_HOST_SKILL_DISCOVERY
+                                    : name === FIELD_REQUIRE_HUMAN_MERGE_CLI_ALIAS
+                                        ? FIELD_REQUIRE_HUMAN_MERGE
+                                        : name === FIELD_HOTFIX_CRITERIA_CLI_ALIAS
+                                            ? FIELD_HOTFIX_CRITERIA
+                                            : name === FIELD_DELIVERY_BRANCH_CLI_ALIAS
+                                                ? FIELD_DELIVERY_BRANCH
+                                                : name;
     for (const field of inspectAllPolicies(projectRoot)) {
         if (field.name === normalized)
             return field;

package/dist/scope/brief-io.d.ts

@@ -22,5 +22,7 @@ export type AtomicWriteBriefResult = {
     readonly message: string;
 };
 /** Validate then atomically persist a brief (temp file + rename). */
-export declare function atomicWriteBrief(filePath: string, data: JsonObject, vbriefRoot: string): AtomicWriteBriefResult;
+export declare function atomicWriteBrief(filePath: string, data: JsonObject, vbriefRoot: string, options?: {
+    readonly projectRoot?: string;
+}): AtomicWriteBriefResult;
 //# sourceMappingURL=brief-io.d.ts.map

package/dist/scope/brief-io.js

@@ -1,5 +1,5 @@
 import { existsSync, readFileSync } from "node:fs";
-import { resolve } from "node:path";
+import { dirname, resolve } from "node:path";
 import { atomicWriteText } from "../cache/io.js";
 import { hasArtifactSuffix } from "../layout/resolve.js";
 import { pythonJsonPretty } from "../vbrief-build/json.js";
@@ -60,13 +60,15 @@ export function validateBriefForPersist(filePath, data, vbriefRoot) {
     return errors.join("; ");
 }
 /** Validate then atomically persist a brief (temp file + rename). */
-export function atomicWriteBrief(filePath, data, vbriefRoot) {
+export function atomicWriteBrief(filePath, data, vbriefRoot, options = {}) {
     const validationError = validateBriefForPersist(filePath, data, vbriefRoot);
     if (validationError !== null) {
         return { ok: false, message: validationError };
     }
+    // #3042: contain against projectRoot (parent of xbrief/), not dirname(filePath).
+    const projectRoot = options.projectRoot ?? dirname(resolve(vbriefRoot));
     try {
-        atomicWriteText(filePath, formatBriefJson(data));
+        atomicWriteText(filePath, formatBriefJson(data), { projectRoot });
         return { ok: true };
     }
     catch (err) {

package/dist/scope/delivery-evidence.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Delivery integrity for scope completion (#3041).
+ *
+ * A code-bearing scope must not acquire a delivered disposition unless the
+ * merge/delivered commit is an ancestor of the refreshed remote delivery ref,
+ * or an explicit auditable non-delivery disposition is recorded.
+ *
+ * Deploy / UAT are separate axes and MUST NOT be inferred from Git alone.
+ */
+import { type GitRunner } from "../session/git.js";
+/** Handoff states that Git delivery can assert (deploy/UAT never inferred). */
+export declare const HANDOFF_STATES: readonly ["implemented", "pr_open", "merged_to_integration", "delivered"];
+export type HandoffState = (typeof HANDOFF_STATES)[number];
+/** Explicit non-delivery terminal dispositions (never render as shipped). */
+export declare const NON_DELIVERY_DISPOSITIONS: readonly ["cancelled", "superseded", "experiment_archived", "accepted_not_delivered"];
+export type NonDeliveryDisposition = (typeof NON_DELIVERY_DISPOSITIONS)[number];
+/** Delivery verification outcome for completion provenance. */
+export type DeliveryDisposition = "delivered" | "merged_to_integration" | "not_delivered" | NonDeliveryDisposition | "unknown" | "unverified";
+export interface CompletionProvenance {
+    readonly repository: string | null;
+    readonly implementationCommit: string | null;
+    readonly prNumber: number | null;
+    readonly prBase: string | null;
+    readonly mergeCommit: string | null;
+    readonly deliveryBranch: string;
+    readonly deliveryCommit: string | null;
+    readonly verifiedAt: string;
+    readonly verifier: string;
+    readonly disposition: DeliveryDisposition;
+    readonly handoffState: HandoffState | "unknown";
+    /** Always null unless explicitly supplied — never inferred from Git (#3041). */
+    readonly deployed: boolean | null;
+    /** Always null unless explicitly supplied — never inferred from Git (#3041). */
+    readonly uatVerified: boolean | null;
+}
+export interface DeliveryEvidenceInput {
+    readonly repository?: string | null;
+    readonly implementationCommit?: string | null;
+    readonly prNumber?: number | null;
+    readonly prBase?: string | null;
+    readonly mergeCommit?: string | null;
+    readonly deliveryBranch?: string | null;
+    readonly deliveryCommit?: string | null;
+    readonly mergedAt?: string | null;
+    /** Explicit deploy/UAT (optional; never auto-filled from Git). */
+    readonly deployed?: boolean | null;
+    readonly uatVerified?: boolean | null;
+    readonly verifier?: string | null;
+}
+export interface DeliveryGateOptions {
+    readonly projectRoot: string;
+    readonly plan: Record<string, unknown>;
+    readonly nowIso: string;
+    readonly evidence?: DeliveryEvidenceInput | null;
+    readonly nonDeliveryDisposition?: NonDeliveryDisposition | null;
+    readonly runGit?: GitRunner;
+    readonly verifier?: string;
+    /**
+     * When true, skip remote refresh + ancestry (tests only that inject pre-validated
+     * evidence). Production callers leave this false.
+     */
+    readonly assumeEvidenceValidated?: boolean;
+}
+export interface DeliveryGateResult {
+    readonly ok: boolean;
+    readonly message: string;
+    readonly provenance: CompletionProvenance | null;
+    readonly codeBearing: boolean;
+}
+export declare function isNonDeliveryDisposition(value: unknown): value is NonDeliveryDisposition;
+/** True when the brief is treated as code-bearing for the delivery gate (#3041). */
+export declare function isCodeBearingScope(plan: Record<string, unknown>): boolean;
+export declare function hasGithubIssueRef(plan: Record<string, unknown>): boolean;
+/**
+ * Classify stored completion provenance for read paths.
+ * Legacy completed records without provenance → unknown/unverified (not delivered).
+ */
+export declare function classifyStoredDeliveryDisposition(plan: Record<string, unknown>): DeliveryDisposition;
+/**
+ * Refresh the remote delivery ref. Failure blocks delivered completion (#3041).
+ */
+export declare function refreshRemoteDeliveryRef(projectRoot: string, deliveryBranch: string, runGit?: GitRunner): {
+    ok: boolean;
+    error: string | null;
+    remoteRef: string;
+};
+/**
+ * Validate that mergeCommit is an ancestor of the refreshed remote delivery ref.
+ */
+export declare function verifyDeliveryAncestry(projectRoot: string, mergeCommit: string, deliveryBranch: string, runGit?: GitRunner): {
+    ok: boolean;
+    error: string | null;
+    remoteTip: string | null;
+};
+/**
+ * Gate delivered completion for a code-bearing scope (#3041).
+ *
+ * Returns ok=true with provenance when:
+ * - scope is not code-bearing (provenance may be null or non-code note), OR
+ * - explicit non-delivery disposition is provided, OR
+ * - durable delivery evidence validates (PR base == deliveryBranch, merge commit
+ *   ancestor of refreshed remote delivery ref).
+ */
+export declare function evaluateDeliveryGate(options: DeliveryGateOptions): DeliveryGateResult;
+/** Stamp completion provenance onto plan.metadata (mutates plan). */
+export declare function stampDeliveryProvenance(plan: Record<string, unknown>, provenance: CompletionProvenance): void;
+/**
+ * Parse a PR REST payload into delivery evidence fields.
+ * Expects GitHub pulls API shape (merged_at, base.ref, merge_commit_sha, …).
+ */
+export declare function evidenceFromPrPayload(payload: Record<string, unknown>, prNumber: number, repository: string | null, deliveryBranch?: string | null): DeliveryEvidenceInput;
+//# sourceMappingURL=delivery-evidence.d.ts.map