@deftai/directive-core 0.55.0

package/dist/policy/index.js

@@ -0,0 +1,298 @@
+import { coerceLegacyNarrative, LEGACY_NARRATIVE_KEY, loadProjectDefinition } from "./resolve.js";
+import { DEFAULT_WIP_CAP } from "./wip.js";
+export * from "./autonomy.js";
+export * from "./capacity.js";
+export * from "./decisions.js";
+export * from "./disclosure.js";
+export * from "./resolve.js";
+export * from "./wip.js";
+export const FIELD_ALLOW_DIRECT_COMMITS = "plan.policy.allowDirectCommitsToMaster";
+export const FIELD_WIP_CAP = "plan.policy.wipCap";
+export const FIELD_SESSION_RITUAL_STALENESS_HOURS = "plan.policy.sessionRitualStalenessHours";
+export const FIELD_TRIAGE_SCOPE = "plan.policy.triageScope";
+export const FIELD_TRIAGE_SCOPE_IGNORES = "plan.policy.triageScopeIgnores";
+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";
+export const DEFAULT_SESSION_RITUAL_STALENESS_HOURS = 4;
+export const DEFAULT_TRIAGE_SCOPE_VALUE = [
+    { rule: "all-open" },
+];
+export const DEFAULT_TRIAGE_SCOPE_IGNORES_VALUE = [];
+export const DEFAULT_TRIAGE_RANKING_LABELS_VALUE = [];
+export const DEFAULT_TRIAGE_AUTO_CLASSIFY_VALUE = [];
+export const KNOWN_SUBAGENT_BACKEND_IDS = new Set(["composer", "cursor-cloud", "grok-build"]);
+const FALLBACK_HOLD_MARKERS = [
+    "do not implement",
+    "BLOCKED",
+    "HOLDING",
+    "Holding / capture only",
+];
+function getPlan(data) {
+    if (data === null)
+        return {};
+    const plan = data.plan;
+    if (typeof plan === "object" && plan !== null && !Array.isArray(plan)) {
+        return plan;
+    }
+    return {};
+}
+function getPolicyBlock(data) {
+    const policy = getPlan(data).policy;
+    if (typeof policy === "object" && policy !== null && !Array.isArray(policy)) {
+        return policy;
+    }
+    return {};
+}
+function getNarratives(data) {
+    const narratives = getPlan(data).narratives;
+    if (typeof narratives === "object" && narratives !== null && !Array.isArray(narratives)) {
+        return narratives;
+    }
+    return {};
+}
+function defaultHoldMarkers() {
+    return [...FALLBACK_HOLD_MARKERS];
+}
+function inspectAllowDirectCommits(data) {
+    const policyBlock = getPolicyBlock(data);
+    if ("allowDirectCommitsToMaster" in policyBlock) {
+        const raw = policyBlock.allowDirectCommitsToMaster;
+        const current = typeof raw === "boolean" ? raw : false;
+        return {
+            name: FIELD_ALLOW_DIRECT_COMMITS,
+            current,
+            default: false,
+            source: "typed",
+        };
+    }
+    const narratives = getNarratives(data);
+    if (LEGACY_NARRATIVE_KEY in narratives) {
+        const { allow } = coerceLegacyNarrative(narratives[LEGACY_NARRATIVE_KEY]);
+        return {
+            name: FIELD_ALLOW_DIRECT_COMMITS,
+            current: allow,
+            default: false,
+            source: "legacy",
+        };
+    }
+    return {
+        name: FIELD_ALLOW_DIRECT_COMMITS,
+        current: false,
+        default: false,
+        source: "default",
+    };
+}
+function inspectWipCap(data) {
+    const policyBlock = getPolicyBlock(data);
+    if ("wipCap" in policyBlock) {
+        const raw = policyBlock.wipCap;
+        let current = DEFAULT_WIP_CAP;
+        if (typeof raw === "number" && Number.isInteger(raw) && raw >= 0) {
+            current = raw;
+        }
+        return {
+            name: FIELD_WIP_CAP,
+            current,
+            default: DEFAULT_WIP_CAP,
+            source: "typed",
+        };
+    }
+    return {
+        name: FIELD_WIP_CAP,
+        current: DEFAULT_WIP_CAP,
+        default: DEFAULT_WIP_CAP,
+        source: "default",
+    };
+}
+function inspectSessionRitualStalenessHours(data) {
+    const policyBlock = getPolicyBlock(data);
+    if ("sessionRitualStalenessHours" in policyBlock) {
+        const raw = policyBlock.sessionRitualStalenessHours;
+        if (raw === null) {
+            return {
+                name: FIELD_SESSION_RITUAL_STALENESS_HOURS,
+                current: DEFAULT_SESSION_RITUAL_STALENESS_HOURS,
+                default: DEFAULT_SESSION_RITUAL_STALENESS_HOURS,
+                source: "default",
+            };
+        }
+        let current = DEFAULT_SESSION_RITUAL_STALENESS_HOURS;
+        let source = "default-on-error";
+        if (typeof raw === "number" && Number.isInteger(raw) && raw > 0) {
+            current = raw;
+            source = "typed";
+        }
+        return {
+            name: FIELD_SESSION_RITUAL_STALENESS_HOURS,
+            current,
+            default: DEFAULT_SESSION_RITUAL_STALENESS_HOURS,
+            source,
+        };
+    }
+    return {
+        name: FIELD_SESSION_RITUAL_STALENESS_HOURS,
+        current: DEFAULT_SESSION_RITUAL_STALENESS_HOURS,
+        default: DEFAULT_SESSION_RITUAL_STALENESS_HOURS,
+        source: "default",
+    };
+}
+function listFieldInspector(data, key, name, defaultValue, options) {
+    const policyBlock = getPolicyBlock(data);
+    if (!(key in policyBlock)) {
+        return {
+            name,
+            current: [...defaultValue],
+            default: [...defaultValue],
+            source: "default",
+        };
+    }
+    const raw = policyBlock[key];
+    if (!Array.isArray(raw)) {
+        return {
+            name,
+            current: [...defaultValue],
+            default: [...defaultValue],
+            source: "default",
+        };
+    }
+    if (raw.length === 0 && !options?.emptyIsTyped) {
+        return {
+            name,
+            current: [...defaultValue],
+            default: [...defaultValue],
+            source: "default",
+        };
+    }
+    if (options?.emptyIsTyped && raw.every((s) => typeof s === "string")) {
+        const cleaned = raw.filter((s) => typeof s === "string" && s.trim().length > 0);
+        return {
+            name,
+            current: cleaned,
+            default: [...defaultValue],
+            source: "typed",
+        };
+    }
+    return {
+        name,
+        current: [...raw],
+        default: [...defaultValue],
+        source: "typed",
+    };
+}
+function inspectSwarmSubagentBackend(data) {
+    const policyBlock = getPolicyBlock(data);
+    if (!("swarmSubagentBackend" in policyBlock)) {
+        return {
+            name: FIELD_SWARM_SUBAGENT_BACKEND,
+            current: null,
+            default: null,
+            source: "default",
+        };
+    }
+    const raw = policyBlock.swarmSubagentBackend;
+    if (typeof raw === "string") {
+        const bid = raw.trim();
+        if (bid.length > 0 && KNOWN_SUBAGENT_BACKEND_IDS.has(bid)) {
+            return {
+                name: FIELD_SWARM_SUBAGENT_BACKEND,
+                current: bid,
+                default: null,
+                source: "typed",
+            };
+        }
+    }
+    return {
+        name: FIELD_SWARM_SUBAGENT_BACKEND,
+        current: null,
+        default: null,
+        source: "default-on-error",
+    };
+}
+const REGISTERED_POLICIES = [
+    inspectAllowDirectCommits,
+    inspectWipCap,
+    inspectSessionRitualStalenessHours,
+    (data) => listFieldInspector(data, "triageScope", FIELD_TRIAGE_SCOPE, DEFAULT_TRIAGE_SCOPE_VALUE),
+    (data) => listFieldInspector(data, "triageScopeIgnores", FIELD_TRIAGE_SCOPE_IGNORES, DEFAULT_TRIAGE_SCOPE_IGNORES_VALUE),
+    (data) => listFieldInspector(data, "triageRankingLabels", FIELD_TRIAGE_RANKING_LABELS, DEFAULT_TRIAGE_RANKING_LABELS_VALUE),
+    (data) => listFieldInspector(data, "triageAutoClassify", FIELD_TRIAGE_AUTO_CLASSIFY, DEFAULT_TRIAGE_AUTO_CLASSIFY_VALUE),
+    (data) => listFieldInspector(data, "triageHoldMarkers", FIELD_TRIAGE_HOLD_MARKERS, defaultHoldMarkers(), {
+        emptyIsTyped: true,
+    }),
+    inspectSwarmSubagentBackend,
+];
+/** Walk registered inspectors and return one row per field (#1148). */
+export function inspectAllPolicies(projectRoot) {
+    const [data] = loadProjectDefinition(projectRoot);
+    return REGISTERED_POLICIES.map((inspect) => inspect(data));
+}
+/** Look up a single registered field by canonical dotted-path name. */
+export function inspectOnePolicy(name, projectRoot) {
+    for (const field of inspectAllPolicies(projectRoot)) {
+        if (field.name === name)
+            return field;
+    }
+    return null;
+}
+/** Return canonical names of every registered typed-policy field. */
+export function registeredPolicyNames() {
+    return REGISTERED_POLICIES.map((inspect) => inspect(null).name);
+}
+function utcIso(now) {
+    const dt = now ?? new Date();
+    return dt.toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+export function fieldToDict(field) {
+    return {
+        name: field.name,
+        current: field.current,
+        default: field.default,
+        source: field.source,
+    };
+}
+/** Render the JSON envelope {generated_at, fields: [...]}. */
+export function renderJson(fields, now) {
+    const envelope = {
+        generated_at: utcIso(now),
+        fields: fields.map(fieldToDict),
+    };
+    return JSON.stringify(envelope, null, 2);
+}
+function formatValue(value) {
+    if (value === null)
+        return "None";
+    if (typeof value === "boolean")
+        return value ? "true" : "false";
+    if (Array.isArray(value) || typeof value === "object") {
+        // Match Python json.dumps(..., ensure_ascii=False, sort_keys=False) spacing.
+        return JSON.stringify(value).replace(/":/g, '": ').replace(/,"/g, ', "');
+    }
+    if (typeof value === "string")
+        return value;
+    return String(value);
+}
+/** Render the human-readable text format from the issue body. */
+export function renderText(fields) {
+    if (fields.length === 0) {
+        return ("[policy] (no fields changed)\n" +
+            "  All registered policies are at their framework defaults. " +
+            "Re-run without `--changed-only` to inspect them.");
+    }
+    return fields
+        .map((field) => `[policy] ${field.name}\n` +
+        `  current: ${formatValue(field.current)}\n` +
+        `  default: ${formatValue(field.default)}\n` +
+        `  source:  ${field.source}`)
+        .join("\n\n");
+}
+/** Python repr for a string (single-quoted). */
+export function pythonStringRepr(value) {
+    return `'${value}'`;
+}
+/** Python repr for a list of strings. */
+export function pythonListRepr(items) {
+    return `[${items.map((i) => pythonStringRepr(i)).join(", ")}]`;
+}
+//# sourceMappingURL=index.js.map

package/dist/policy/resolve.d.ts

@@ -0,0 +1,38 @@
+/** Filesystem-relative location of the project-definition vBRIEF. */
+export declare const PROJECT_DEFINITION_REL_PATH = "vbrief/PROJECT-DEFINITION.vbrief.json";
+/** Environment variable emergency bypass for branch protection (#747). */
+export declare const ENV_BYPASS = "DEFT_ALLOW_DEFAULT_BRANCH_COMMIT";
+/** Legacy narrative key replaced by the typed flag (#746). */
+export declare const LEGACY_NARRATIVE_KEY = "Allow direct commits to master";
+/** Audit log relative path (#746). */
+export declare const AUDIT_LOG_REL_PATH = "meta/policy-changes.log";
+export type PolicySource = "typed" | "legacy-narrative" | "env-bypass" | "default-fail-closed";
+export interface PolicyResult {
+    readonly allowDirectCommits: boolean;
+    readonly source: PolicySource;
+    readonly deprecationWarning: string | null;
+    readonly error: string | null;
+}
+/** Resolve absolute path to PROJECT-DEFINITION.vbrief.json. */
+export declare function projectDefinitionPath(projectRoot: string): string;
+/** Best-effort coerce a legacy narrative value to a boolean. */
+export declare function coerceLegacyNarrative(value: unknown): {
+    allow: boolean;
+    raw: string;
+};
+/** Load and parse PROJECT-DEFINITION. Returns [data, error]. */
+export declare function loadProjectDefinition(projectRoot: string): [Record<string, unknown> | null, string | null];
+/** Resolve the effective branch-commit policy (#746 / #747). */
+export declare function resolvePolicy(projectRoot: string): PolicyResult;
+/** Append a one-line audit entry to meta/policy-changes.log (#746). */
+export declare function appendAuditLog(projectRoot: string, entry: string): string;
+/** Write the typed policy flag back to PROJECT-DEFINITION (#746). */
+export declare function setPolicy(projectRoot: string, options: {
+    allowDirectCommits: boolean;
+    actor?: string;
+    note?: string;
+}): {
+    changed: boolean;
+    auditEntry: string;
+};
+//# sourceMappingURL=resolve.d.ts.map

package/dist/policy/resolve.js

@@ -0,0 +1,228 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join, resolve as pathResolve } from "node:path";
+/** Filesystem-relative location of the project-definition vBRIEF. */
+export const PROJECT_DEFINITION_REL_PATH = "vbrief/PROJECT-DEFINITION.vbrief.json";
+/** Environment variable emergency bypass for branch protection (#747). */
+export const ENV_BYPASS = "DEFT_ALLOW_DEFAULT_BRANCH_COMMIT";
+/** Legacy narrative key replaced by the typed flag (#746). */
+export const LEGACY_NARRATIVE_KEY = "Allow direct commits to master";
+/** Audit log relative path (#746). */
+export const AUDIT_LOG_REL_PATH = "meta/policy-changes.log";
+const TRUTHY = new Set(["1", "true", "yes", "on"]);
+/** Resolve absolute path to PROJECT-DEFINITION.vbrief.json. */
+export function projectDefinitionPath(projectRoot) {
+    return join(pathResolve(projectRoot), PROJECT_DEFINITION_REL_PATH);
+}
+function envBypassActive() {
+    const raw = process.env[ENV_BYPASS] ?? "";
+    return TRUTHY.has(raw.trim().toLowerCase());
+}
+function pythonTypeName(value) {
+    if (value === null)
+        return "None";
+    if (Array.isArray(value))
+        return "list";
+    if (typeof value === "boolean")
+        return "bool";
+    if (typeof value === "number")
+        return Number.isInteger(value) ? "int" : "float";
+    if (typeof value === "string")
+        return "str";
+    if (typeof value === "object")
+        return "dict";
+    return typeof value;
+}
+function pythonRepr(value) {
+    if (value === undefined)
+        return "None";
+    if (typeof value === "string")
+        return `'${value}'`;
+    if (value === null)
+        return "None";
+    if (typeof value === "boolean")
+        return value ? "True" : "False";
+    return String(value);
+}
+/** Best-effort coerce a legacy narrative value to a boolean. */
+export function coerceLegacyNarrative(value) {
+    if (typeof value === "boolean") {
+        return { allow: value, raw: pythonRepr(value) };
+    }
+    if (typeof value !== "string") {
+        return { allow: false, raw: pythonRepr(value) };
+    }
+    const raw = value.trim();
+    const low = raw.toLowerCase();
+    if (["true", "yes", "on", "1"].includes(low)) {
+        return { allow: true, raw };
+    }
+    const match = /:\s*(true|yes|on|1)\b/.exec(low);
+    if (match !== null) {
+        return { allow: true, raw };
+    }
+    return { allow: false, raw };
+}
+/** Load and parse PROJECT-DEFINITION. Returns [data, error]. */
+export function loadProjectDefinition(projectRoot) {
+    const path = projectDefinitionPath(projectRoot);
+    if (!existsSync(path)) {
+        return [null, `PROJECT-DEFINITION not found at ${path}`];
+    }
+    try {
+        const text = readFileSync(path, { encoding: "utf8" });
+        const data = JSON.parse(text);
+        return [data, null];
+    }
+    catch (err) {
+        if (err instanceof SyntaxError) {
+            return [null, `PROJECT-DEFINITION at ${path} is not valid JSON: ${String(err)}`];
+        }
+        return [null, `PROJECT-DEFINITION at ${path} cannot be read: ${String(err)}`];
+    }
+}
+/** Resolve the effective branch-commit policy (#746 / #747). */
+export function resolvePolicy(projectRoot) {
+    if (envBypassActive()) {
+        return {
+            allowDirectCommits: true,
+            source: "env-bypass",
+            deprecationWarning: null,
+            error: null,
+        };
+    }
+    const [data, err] = loadProjectDefinition(projectRoot);
+    if (data === null) {
+        return {
+            allowDirectCommits: false,
+            source: "default-fail-closed",
+            deprecationWarning: null,
+            error: err,
+        };
+    }
+    const plan = data.plan;
+    if (typeof plan !== "object" || plan === null || Array.isArray(plan)) {
+        return {
+            allowDirectCommits: false,
+            source: "default-fail-closed",
+            deprecationWarning: null,
+            error: "PROJECT-DEFINITION 'plan' is not an object",
+        };
+    }
+    const planObj = plan;
+    const policyBlock = planObj.policy;
+    if (typeof policyBlock === "object" &&
+        policyBlock !== null &&
+        !Array.isArray(policyBlock) &&
+        "allowDirectCommitsToMaster" in policyBlock) {
+        const raw = policyBlock.allowDirectCommitsToMaster;
+        if (typeof raw !== "boolean") {
+            return {
+                allowDirectCommits: false,
+                source: "default-fail-closed",
+                deprecationWarning: null,
+                error: `plan.policy.allowDirectCommitsToMaster must be a boolean; got ${pythonTypeName(raw)} (${pythonRepr(raw)})`,
+            };
+        }
+        return {
+            allowDirectCommits: raw,
+            source: "typed",
+            deprecationWarning: null,
+            error: null,
+        };
+    }
+    const narratives = planObj.narratives;
+    if (typeof narratives === "object" &&
+        narratives !== null &&
+        !Array.isArray(narratives) &&
+        LEGACY_NARRATIVE_KEY in narratives) {
+        const { allow, raw } = coerceLegacyNarrative(narratives[LEGACY_NARRATIVE_KEY]);
+        const warn = `DEPRECATED: PROJECT-DEFINITION uses the legacy narrative key ` +
+            `'${LEGACY_NARRATIVE_KEY}' (${pythonRepr(raw)}). Migrate to typed ` +
+            `plan.policy.allowDirectCommitsToMaster (#746). Run ` +
+            `\`task policy:enforce-branches\` or \`task policy:allow-direct-commits ` +
+            `-- --confirm\` to set the typed flag explicitly.`;
+        return {
+            allowDirectCommits: allow,
+            source: "legacy-narrative",
+            deprecationWarning: warn,
+            error: null,
+        };
+    }
+    return {
+        allowDirectCommits: false,
+        source: "default-fail-closed",
+        deprecationWarning: null,
+        error: null,
+    };
+}
+function nowIso() {
+    return new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+/** Append a one-line audit entry to meta/policy-changes.log (#746). */
+export function appendAuditLog(projectRoot, entry) {
+    const logPath = join(pathResolve(projectRoot), AUDIT_LOG_REL_PATH);
+    mkdirSync(join(logPath, ".."), { recursive: true });
+    const line = `${nowIso()} ${entry}\n`;
+    if (!existsSync(logPath)) {
+        const header = "# meta/policy-changes.log -- audit trail for " +
+            "policy.allowDirectCommitsToMaster transitions (#746)\n";
+        writeFileSync(logPath, header, { encoding: "utf8" });
+    }
+    appendFileSync(logPath, line, { encoding: "utf8" });
+    return logPath;
+}
+/** Write the typed policy flag back to PROJECT-DEFINITION (#746). */
+export function setPolicy(projectRoot, options) {
+    const { allowDirectCommits, actor = "agent", note = "" } = options;
+    const path = projectDefinitionPath(projectRoot);
+    if (!existsSync(path)) {
+        throw new Error(`PROJECT-DEFINITION not found at ${path}`);
+    }
+    const data = JSON.parse(readFileSync(path, { encoding: "utf8" }));
+    if (typeof data.plan !== "object" || data.plan === null || Array.isArray(data.plan)) {
+        if (data.plan === undefined) {
+            data.plan = {};
+        }
+        else {
+            throw new Error("PROJECT-DEFINITION 'plan' is not an object");
+        }
+    }
+    const plan = data.plan;
+    if (typeof plan.policy !== "object" || plan.policy === null || Array.isArray(plan.policy)) {
+        if (plan.policy === undefined) {
+            plan.policy = {};
+        }
+        else {
+            throw new Error("plan.policy is not an object");
+        }
+    }
+    const policyBlock = plan.policy;
+    const previous = policyBlock.allowDirectCommitsToMaster;
+    policyBlock.allowDirectCommitsToMaster = Boolean(allowDirectCommits);
+    let legacyDropped = false;
+    const narratives = plan.narratives;
+    if (typeof narratives === "object" &&
+        narratives !== null &&
+        !Array.isArray(narratives) &&
+        LEGACY_NARRATIVE_KEY in narratives) {
+        delete narratives[LEGACY_NARRATIVE_KEY];
+        legacyDropped = true;
+    }
+    writeFileSync(path, `${JSON.stringify(data, null, 2)}\n`, { encoding: "utf8" });
+    const changed = previous !== Boolean(allowDirectCommits) || legacyDropped;
+    const parts = [
+        `actor=${actor}`,
+        `allowDirectCommitsToMaster=${allowDirectCommits ? "true" : "false"}`,
+        `previous=${pythonRepr(previous)}`,
+    ];
+    if (legacyDropped) {
+        parts.push("legacy-narrative-migrated=true");
+    }
+    if (note) {
+        parts.push(`note=${note.replace(/\n/g, " ").replace(/\r/g, " ")}`);
+    }
+    const auditEntry = parts.join(" ");
+    appendAuditLog(projectRoot, auditEntry);
+    return { changed, auditEntry };
+}
+//# sourceMappingURL=resolve.js.map

package/dist/policy/wip.d.ts

@@ -0,0 +1,15 @@
+/** Framework default WIP cap (#1124 / umbrella #1119). */
+export declare const DEFAULT_WIP_CAP = 10;
+/** vBRIEF lifecycle folders that count toward the WIP set. */
+export declare const WIP_LIFECYCLE_DIRS: readonly ["pending", "active"];
+export type WipCapSource = "typed" | "default" | "default-on-error";
+export interface WipCapResult {
+    readonly cap: number;
+    readonly source: WipCapSource;
+    readonly error: string | null;
+}
+/** Resolve plan.policy.wipCap from PROJECT-DEFINITION (#1124). */
+export declare function resolveWipCap(projectRoot: string): WipCapResult;
+/** Count *.vbrief.json files in vbrief/pending/ + vbrief/active/ (#1124). */
+export declare function countVbriefWip(projectRoot: string): number;
+//# sourceMappingURL=wip.d.ts.map

package/dist/policy/wip.js

@@ -0,0 +1,81 @@
+import { existsSync, readdirSync } from "node:fs";
+import { join, resolve as pathResolve } from "node:path";
+import { loadProjectDefinition } from "./resolve.js";
+/** Framework default WIP cap (#1124 / umbrella #1119). */
+export const DEFAULT_WIP_CAP = 10;
+/** vBRIEF lifecycle folders that count toward the WIP set. */
+export const WIP_LIFECYCLE_DIRS = ["pending", "active"];
+function pythonTypeName(value) {
+    if (value === null)
+        return "None";
+    if (Array.isArray(value))
+        return "list";
+    if (typeof value === "boolean")
+        return "bool";
+    if (typeof value === "number")
+        return Number.isInteger(value) ? "int" : "float";
+    if (typeof value === "string")
+        return "str";
+    if (typeof value === "object")
+        return "dict";
+    return typeof value;
+}
+function pythonRepr(value) {
+    if (typeof value === "string")
+        return `'${value}'`;
+    if (value === null)
+        return "None";
+    if (typeof value === "boolean")
+        return value ? "True" : "False";
+    return String(value);
+}
+/** Resolve plan.policy.wipCap from PROJECT-DEFINITION (#1124). */
+export function resolveWipCap(projectRoot) {
+    const [data, err] = loadProjectDefinition(projectRoot);
+    if (data === null) {
+        return { cap: DEFAULT_WIP_CAP, source: "default", error: err };
+    }
+    const plan = data.plan;
+    if (typeof plan !== "object" || plan === null || Array.isArray(plan)) {
+        return {
+            cap: DEFAULT_WIP_CAP,
+            source: "default",
+            error: "PROJECT-DEFINITION 'plan' is not an object",
+        };
+    }
+    const policyBlock = plan.policy;
+    if (typeof policyBlock !== "object" ||
+        policyBlock === null ||
+        Array.isArray(policyBlock) ||
+        !("wipCap" in policyBlock)) {
+        return { cap: DEFAULT_WIP_CAP, source: "default", error: null };
+    }
+    const raw = policyBlock.wipCap;
+    if (typeof raw !== "number" || !Number.isInteger(raw) || raw < 0) {
+        return {
+            cap: DEFAULT_WIP_CAP,
+            source: "default-on-error",
+            error: `plan.policy.wipCap must be a non-negative integer; got ${pythonTypeName(raw)} (${pythonRepr(raw)})`,
+        };
+    }
+    return { cap: raw, source: "typed", error: null };
+}
+/** Count *.vbrief.json files in vbrief/pending/ + vbrief/active/ (#1124). */
+export function countVbriefWip(projectRoot) {
+    let total = 0;
+    const vbriefRoot = join(pathResolve(projectRoot), "vbrief");
+    for (const sub of WIP_LIFECYCLE_DIRS) {
+        const folder = join(vbriefRoot, sub);
+        if (!existsSync(folder)) {
+            continue;
+        }
+        const entries = readdirSync(folder, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isFile() && entry.name.endsWith(".vbrief.json")) {
+                total += 1;
+            }
+        }
+    }
+    return total;
+}
+//# sourceMappingURL=wip.js.map

package/dist/pr-closing-keywords/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const EXIT_OK = 0;
+export declare const EXIT_HITS_FOUND = 1;
+export declare const EXIT_CONFIG_ERROR = 2;
+export declare const GH_TIMEOUT_S = 30;
+export declare const WINDOW_RADIUS = 20;
+//# sourceMappingURL=constants.d.ts.map

package/dist/pr-closing-keywords/constants.js

@@ -0,0 +1,6 @@
+export const EXIT_OK = 0;
+export const EXIT_HITS_FOUND = 1;
+export const EXIT_CONFIG_ERROR = 2;
+export const GH_TIMEOUT_S = 30;
+export const WINDOW_RADIUS = 20;
+//# sourceMappingURL=constants.js.map

package/dist/pr-closing-keywords/detect.d.ts

@@ -0,0 +1,5 @@
+import type { Hit } from "./types.js";
+export declare const CLOSING_KEYWORD_RE: RegExp;
+export declare function renderHit(hit: Hit): string;
+export declare function findHits(text: string, source: string): Hit[];
+//# sourceMappingURL=detect.d.ts.map