@deftai/directive-core 0.55.0

package/dist/scope/transition.js

@@ -0,0 +1,133 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { append, canonicalLogPath, newDecisionId } from "./audit-log.js";
+import { stampCompletionMetadata } from "./capacity-stamp.js";
+import { LIFECYCLE_FOLDERS, MOVE_LABELS, STATUS_PRECONDITIONS, STAY_LABELS, TRANSITIONS, } from "./constants.js";
+import { detectLifecycleFolder, updateDecomposedChildBackReferences, updateDecomposedParentBackReferences, } from "./decomposed-refs.js";
+import { syncProjectDefinitionAfterScopeMove } from "./project-definition-sync.js";
+import { formatVbriefJson, utcNowIso } from "./vbrief-json.js";
+export function runTransition(action, filePath, now = new Date()) {
+    if (!(action in TRANSITIONS)) {
+        const valid = Object.keys(TRANSITIONS).sort().join(", ");
+        return { ok: false, message: `Unknown action '${action}'. Valid actions: ${valid}` };
+    }
+    const act = action;
+    const resolvedPath = resolve(filePath);
+    if (!existsSync(resolvedPath)) {
+        return { ok: false, message: `File not found: ${resolvedPath}` };
+    }
+    const basename = resolvedPath.split(/[/\\]/).pop() ?? "";
+    if (!basename.endsWith(".vbrief.json")) {
+        return { ok: false, message: `Not a vBRIEF file (expected .vbrief.json): ${basename}` };
+    }
+    const currentFolder = detectLifecycleFolder(resolvedPath);
+    if (currentFolder === null) {
+        return {
+            ok: false,
+            message: `File is not inside a lifecycle folder (${LIFECYCLE_FOLDERS.join(", ")}): ${resolvedPath}`,
+        };
+    }
+    const { allowedSources, targetFolder, targetStatus } = TRANSITIONS[act];
+    if (!allowedSources.includes(currentFolder)) {
+        const allowedStr = allowedSources.map((s) => `${s}/`).join(", ");
+        return {
+            ok: false,
+            message: `Invalid transition: '${act}' requires file in ${allowedStr}. ` +
+                `File is in ${currentFolder}/.`,
+        };
+    }
+    let data;
+    try {
+        data = JSON.parse(readFileSync(resolvedPath, "utf8"));
+    }
+    catch (err) {
+        return { ok: false, message: `Invalid JSON in ${resolvedPath}: ${String(err)}` };
+    }
+    const plan = data.plan;
+    if (typeof plan !== "object" || plan === null || Array.isArray(plan)) {
+        return { ok: false, message: `Missing or invalid 'plan' object in ${resolvedPath}` };
+    }
+    const planObj = plan;
+    const currentStatus = String(planObj.status ?? "");
+    const requiredStatus = STATUS_PRECONDITIONS[act];
+    if (requiredStatus !== undefined) {
+        if (currentStatus === targetStatus) {
+            return {
+                ok: true,
+                message: `No-op: ${basename} is already ${targetStatus} in ${currentFolder}/`,
+            };
+        }
+        if (currentStatus !== requiredStatus) {
+            return {
+                ok: false,
+                message: `Invalid transition: '${act}' requires status='${requiredStatus}', ` +
+                    `but ${basename} has status='${currentStatus}'.`,
+            };
+        }
+    }
+    if (targetFolder !== null && targetFolder === currentFolder) {
+        return {
+            ok: true,
+            message: `No-op: ${basename} is already in ${currentFolder}/ (status: ${currentStatus})`,
+        };
+    }
+    const nowIso = utcNowIso(now);
+    planObj.status = targetStatus;
+    planObj.updated = nowIso;
+    if (act === "complete") {
+        const vbriefRoot = dirname(dirname(resolvedPath));
+        const projectRoot = dirname(vbriefRoot);
+        stampCompletionMetadata(planObj, projectRoot, nowIso);
+    }
+    writeFileSync(resolvedPath, formatVbriefJson(data), "utf8");
+    if (targetFolder !== null) {
+        const vbriefRoot = dirname(dirname(resolvedPath));
+        const destDir = join(vbriefRoot, targetFolder);
+        mkdirSync(destDir, { recursive: true });
+        const destPath = join(destDir, basename);
+        renameSync(resolvedPath, destPath);
+        updateDecomposedParentBackReferences(data, resolvedPath, destPath, vbriefRoot);
+        updateDecomposedChildBackReferences(data, resolvedPath, destPath, vbriefRoot);
+        syncProjectDefinitionAfterScopeMove(data, resolvedPath, destPath, vbriefRoot, targetStatus);
+        const actionLabel = MOVE_LABELS[act] ?? act.charAt(0).toUpperCase() + act.slice(1);
+        return {
+            ok: true,
+            message: `${actionLabel} ${basename}: ${currentFolder}/ -> ${targetFolder}/ (status: ${targetStatus})`,
+        };
+    }
+    const actionLabel = STAY_LABELS[act] ?? act.charAt(0).toUpperCase() + act.slice(1);
+    return {
+        ok: true,
+        message: `${actionLabel} ${basename}: stays in ${currentFolder}/ (status: ${targetStatus})`,
+    };
+}
+export function recordWipCapOverride(filePath, projectRoot, check, now = new Date()) {
+    try {
+        const rel = resolve(filePath).startsWith(resolve(projectRoot))
+            ? resolve(filePath)
+                .slice(resolve(projectRoot).length + 1)
+                .replace(/\\/g, "/")
+            : resolve(filePath).replace(/\\/g, "/");
+        const entry = {
+            decision_id: newDecisionId(),
+            timestamp: utcNowIso(now),
+            action: "promote",
+            vbrief_path: rel,
+            from_status: "proposed",
+            to_status: "pending",
+            actor: "operator",
+            wip_cap_override: {
+                cap: check.cap,
+                count_at_promote: check.count,
+                source: check.source,
+                reason: "--force",
+            },
+        };
+        append(entry, canonicalLogPath(projectRoot));
+    }
+    catch {
+        /* best-effort audit */
+    }
+}
+export { detectLifecycleFolder };
+//# sourceMappingURL=transition.js.map

package/dist/scope/undo.d.ts

@@ -0,0 +1,25 @@
+import { REVERSIBLE_ACTIONS, TERMINAL_ACTIONS } from "./constants.js";
+export interface UndoResult {
+    readonly ok: boolean;
+    readonly message: string;
+    readonly auditEntry: Record<string, unknown> | null;
+}
+export declare function isAlreadyUndone(decisionId: string, logEntries: Record<string, unknown>[]): boolean;
+export declare function findByDecisionId(decisionId: string, logEntries: Record<string, unknown>[]): Record<string, unknown> | null;
+export declare function findByBatchId(batchId: string, logEntries: Record<string, unknown>[]): Record<string, unknown>[];
+export declare function undoOne(entry: Record<string, unknown>, projectRoot: string, options?: {
+    actor?: string;
+    now?: Date;
+    logPath?: string;
+    dryRun?: boolean;
+    undoBatchId?: string;
+    logEntries?: Record<string, unknown>[];
+}): UndoResult;
+export declare function undoBatch(batchId: string, projectRoot: string, options?: {
+    actor?: string;
+    now?: Date;
+    logPath?: string;
+    dryRun?: boolean;
+}): [number, Record<string, unknown>[], string[], string[]];
+export { REVERSIBLE_ACTIONS, TERMINAL_ACTIONS };
+//# sourceMappingURL=undo.d.ts.map

package/dist/scope/undo.js

@@ -0,0 +1,334 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { basename, join, relative, resolve } from "node:path";
+import { append, canonicalLogPath, newDecisionId, readAll } from "./audit-log.js";
+import { REVERSIBLE_ACTIONS, TERMINAL_ACTIONS } from "./constants.js";
+import { formatVbriefJson, utcNowIso } from "./vbrief-json.js";
+function vbriefRoot(projectRoot) {
+    return join(resolve(projectRoot), "vbrief");
+}
+function absForEntryPath(projectRoot, vbriefPath) {
+    return resolve(projectRoot, vbriefPath);
+}
+export function isAlreadyUndone(decisionId, logEntries) {
+    for (const entry of logEntries) {
+        if (entry.action !== "undo") {
+            continue;
+        }
+        const meta = entry.undo_meta;
+        if (typeof meta === "object" &&
+            meta !== null &&
+            !Array.isArray(meta) &&
+            meta.original_decision_id === decisionId) {
+            return true;
+        }
+    }
+    return false;
+}
+export function findByDecisionId(decisionId, logEntries) {
+    for (const entry of logEntries) {
+        if (entry.decision_id === decisionId) {
+            return entry;
+        }
+    }
+    return null;
+}
+export function findByBatchId(batchId, logEntries) {
+    const out = [];
+    for (const entry of logEntries) {
+        const meta = entry.demote_meta;
+        let bid;
+        if (typeof meta === "object" && meta !== null && !Array.isArray(meta)) {
+            bid = meta.batch_id;
+        }
+        if (bid === undefined) {
+            bid = entry.batch_id;
+        }
+        if (bid === batchId) {
+            out.push(entry);
+        }
+    }
+    return out;
+}
+function inversePlan(entry, logEntries) {
+    const action = entry.action;
+    if (action === "demote") {
+        return {
+            srcRelpath: String(entry.vbrief_path ?? ""),
+            destFolder: "pending",
+            newStatus: "pending",
+            fromStatus: "proposed",
+            toStatus: "pending",
+        };
+    }
+    if (action === "cancel") {
+        const meta = entry.cancel_meta;
+        let cancelledFrom;
+        if (typeof meta === "object" && meta !== null && !Array.isArray(meta)) {
+            cancelledFrom = meta.cancelled_from;
+        }
+        if (cancelledFrom === undefined || cancelledFrom === null || cancelledFrom === "") {
+            cancelledFrom = entry.cancelled_from;
+        }
+        if (cancelledFrom === undefined || cancelledFrom === null || cancelledFrom === "") {
+            cancelledFrom = entry.from_status;
+        }
+        if (typeof cancelledFrom !== "string" || cancelledFrom.length === 0) {
+            return null;
+        }
+        const folderMap = {
+            running: "active",
+            blocked: "active",
+            completed: "completed",
+            failed: "completed",
+            cancelled: "cancelled",
+            proposed: "proposed",
+            pending: "pending",
+            active: "active",
+        };
+        const destFolder = folderMap[cancelledFrom] ?? cancelledFrom;
+        const statusMap = {
+            proposed: "proposed",
+            pending: "pending",
+            active: "running",
+            completed: "completed",
+            cancelled: "cancelled",
+        };
+        const newStatus = statusMap[destFolder] ?? destFolder;
+        return {
+            srcRelpath: String(entry.vbrief_path ?? ""),
+            destFolder,
+            newStatus,
+            fromStatus: "cancelled",
+            toStatus: newStatus,
+        };
+    }
+    if (action === "restore") {
+        return {
+            srcRelpath: String(entry.vbrief_path ?? ""),
+            destFolder: "cancelled",
+            newStatus: "cancelled",
+            fromStatus: "proposed",
+            toStatus: "cancelled",
+        };
+    }
+    if (action === "undo") {
+        const meta = entry.undo_meta;
+        if (typeof meta !== "object" || meta === null || Array.isArray(meta)) {
+            return null;
+        }
+        const originalId = meta.original_decision_id;
+        if (typeof originalId !== "string") {
+            return null;
+        }
+        const original = findByDecisionId(originalId, logEntries);
+        if (original === null) {
+            return null;
+        }
+        const originalAction = original.action;
+        if (originalAction === "demote") {
+            return {
+                srcRelpath: String(entry.vbrief_path ?? ""),
+                destFolder: "proposed",
+                newStatus: "proposed",
+                fromStatus: "pending",
+                toStatus: "proposed",
+            };
+        }
+        if (originalAction === "cancel") {
+            return {
+                srcRelpath: String(entry.vbrief_path ?? ""),
+                destFolder: "cancelled",
+                newStatus: "cancelled",
+                fromStatus: String(entry.to_status ?? "proposed"),
+                toStatus: "cancelled",
+            };
+        }
+        if (originalAction === "restore") {
+            return {
+                srcRelpath: String(entry.vbrief_path ?? ""),
+                destFolder: "proposed",
+                newStatus: "proposed",
+                fromStatus: "cancelled",
+                toStatus: "proposed",
+            };
+        }
+        return null;
+    }
+    return null;
+}
+function moveAndFlip(srcFile, destFolder, newStatus, timestamp) {
+    if (!existsSync(srcFile)) {
+        return [false, `File not found: ${srcFile}`, null];
+    }
+    let data;
+    try {
+        data = JSON.parse(readFileSync(srcFile, "utf8"));
+    }
+    catch (err) {
+        return [false, `Invalid JSON in ${srcFile}: ${String(err)}`, null];
+    }
+    const plan = data.plan;
+    if (typeof plan !== "object" || plan === null || Array.isArray(plan)) {
+        return [false, `Missing or invalid 'plan' object in ${srcFile}`, null];
+    }
+    const planObj = plan;
+    planObj.status = newStatus;
+    planObj.updated = timestamp;
+    writeFileSync(srcFile, formatVbriefJson(data), "utf8");
+    mkdirSync(destFolder, { recursive: true });
+    const destPath = join(destFolder, basename(srcFile));
+    renameSync(srcFile, destPath);
+    return [true, "ok", destPath];
+}
+function buildUndoEntry(options) {
+    const undoMeta = {
+        original_decision_id: options.entry.decision_id,
+        original_action: options.entry.action ?? "",
+    };
+    if (options.undoBatchId !== undefined) {
+        undoMeta.undo_batch_id = options.undoBatchId;
+    }
+    return {
+        decision_id: newDecisionId(),
+        timestamp: options.timestamp,
+        action: "undo",
+        vbrief_path: options.newRelpath,
+        from_status: options.fromStatus,
+        to_status: options.toStatus,
+        actor: options.actor,
+        undo_meta: undoMeta,
+    };
+}
+export function undoOne(entry, projectRoot, options = {}) {
+    const action = String(entry.action ?? "");
+    const decisionId = String(entry.decision_id ?? "");
+    const actor = options.actor ?? "operator";
+    const now = options.now ?? new Date();
+    const logPath = options.logPath ?? canonicalLogPath(projectRoot);
+    let logEntries = options.logEntries ?? readAll(logPath);
+    if (TERMINAL_ACTIONS.has(action)) {
+        return {
+            ok: false,
+            message: `Refusing to undo terminal action '${action}' (decision_id=${decisionId}). ` +
+                "Use git revert or hand-edit.",
+            auditEntry: null,
+        };
+    }
+    if (!REVERSIBLE_ACTIONS.has(action)) {
+        return {
+            ok: false,
+            message: `Refusing to undo unknown action '${action}' (decision_id=${decisionId}).`,
+            auditEntry: null,
+        };
+    }
+    if (isAlreadyUndone(decisionId, logEntries)) {
+        return {
+            ok: true,
+            message: `No-op: entry ${decisionId} is already undone (idempotent re-run).`,
+            auditEntry: null,
+        };
+    }
+    const plan = inversePlan(entry, logEntries);
+    if (plan === null) {
+        return {
+            ok: false,
+            message: `Cannot derive inverse transition for entry ${decisionId} (action='${action}'). ` +
+                "Missing required metadata.",
+            auditEntry: null,
+        };
+    }
+    const srcPath = absForEntryPath(projectRoot, plan.srcRelpath);
+    const destFolderPath = join(vbriefRoot(projectRoot), plan.destFolder);
+    const timestamp = utcNowIso(now);
+    if (options.dryRun === true) {
+        let srcDisplay;
+        try {
+            srcDisplay = relative(resolve(projectRoot), srcPath).replace(/\\/g, "/");
+        }
+        catch {
+            srcDisplay = srcPath;
+        }
+        const msg = `DRY-RUN: would undo ${action} (decision_id=${decisionId}) -- ` +
+            `${srcDisplay} -> vbrief/${plan.destFolder}/ (status: ${plan.newStatus})`;
+        const preview = buildUndoEntry({
+            entry,
+            timestamp,
+            actor,
+            fromStatus: plan.fromStatus,
+            toStatus: plan.toStatus,
+            newRelpath: `vbrief/${plan.destFolder}/${basename(srcPath)}`,
+            undoBatchId: options.undoBatchId,
+        });
+        return { ok: true, message: msg, auditEntry: preview };
+    }
+    const [ok, fsMsg, destPath] = moveAndFlip(srcPath, destFolderPath, plan.newStatus, timestamp);
+    if (!ok || destPath === null) {
+        return { ok: false, message: fsMsg, auditEntry: null };
+    }
+    let destRelpath;
+    try {
+        destRelpath = relative(resolve(projectRoot), destPath).replace(/\\/g, "/");
+    }
+    catch {
+        destRelpath = destPath.replace(/\\/g, "/");
+    }
+    const undoEntry = buildUndoEntry({
+        entry,
+        timestamp,
+        actor,
+        fromStatus: plan.fromStatus,
+        toStatus: plan.toStatus,
+        newRelpath: destRelpath,
+        undoBatchId: options.undoBatchId,
+    });
+    append(undoEntry, logPath);
+    logEntries = readAll(logPath);
+    return {
+        ok: true,
+        message: `Undid ${action} (decision_id=${decisionId}): ${basename(destPath)} -> ` +
+            `vbrief/${plan.destFolder}/ (status: ${plan.newStatus})`,
+        auditEntry: undoEntry,
+    };
+}
+export function undoBatch(batchId, projectRoot, options = {}) {
+    const logPath = options.logPath ?? canonicalLogPath(projectRoot);
+    let logEntries = readAll(logPath);
+    const members = findByBatchId(batchId, logEntries);
+    if (members.length === 0) {
+        return [0, [], [`No audit entries found for batch_id=${batchId}.`], []];
+    }
+    const undoBatchId = options.dryRun === true ? `DRY-RUN-${newDecisionId()}` : newDecisionId();
+    const auditEntries = [];
+    const skipped = [];
+    const previews = [];
+    let undone = 0;
+    members.sort((a, b) => String(a.timestamp ?? "").localeCompare(String(b.timestamp ?? "")));
+    for (const member of members) {
+        const result = undoOne(member, projectRoot, {
+            ...options,
+            undoBatchId,
+            logEntries,
+        });
+        if (result.ok) {
+            if (result.auditEntry !== null) {
+                auditEntries.push(result.auditEntry);
+                if (options.dryRun === true) {
+                    previews.push(result.message);
+                }
+                else {
+                    logEntries = readAll(logPath);
+                }
+                undone += 1;
+            }
+            else {
+                skipped.push(result.message);
+            }
+        }
+        else {
+            skipped.push(result.message);
+        }
+    }
+    return [undone, auditEntries, skipped, previews];
+}
+export { REVERSIBLE_ACTIONS, TERMINAL_ACTIONS };
+//# sourceMappingURL=undo.js.map

package/dist/scope/vbrief-json.d.ts

@@ -0,0 +1,4 @@
+/** Format vBRIEF JSON like Python json.dumps(..., indent=2, ensure_ascii=False) + newline. */
+export declare function formatVbriefJson(data: unknown): string;
+export declare function utcNowIso(now?: Date): string;
+//# sourceMappingURL=vbrief-json.d.ts.map

package/dist/scope/vbrief-json.js

@@ -0,0 +1,8 @@
+/** Format vBRIEF JSON like Python json.dumps(..., indent=2, ensure_ascii=False) + newline. */
+export function formatVbriefJson(data) {
+    return `${JSON.stringify(data, null, 2)}\n`;
+}
+export function utcNowIso(now = new Date()) {
+    return now.toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+//# sourceMappingURL=vbrief-json.js.map

package/dist/scope/vbrief-ref.d.ts

@@ -0,0 +1,11 @@
+/** Resolve a vBRIEF reference URI to an absolute path, or null. */
+export declare function resolveVbriefRef(uri: unknown, vbriefDir: string): string | null;
+/** Collect planRef values from the plan root and top-level items. */
+export declare function collectPlanRefs(plan: Record<string, unknown>): string[];
+/** Collect x-vbrief/plan child reference uris from a parent plan. */
+export declare function collectChildUris(plan: Record<string, unknown>): string[];
+/** Return registry IDs that may name a vBRIEF filename. */
+export declare function scopeIdsForFilename(filename: string): Set<string>;
+export declare function relativeToVbrief(path: string, vbriefRoot: string): string | null;
+export declare function canonicalRelpath(filePath: string, projectRoot: string): string;
+//# sourceMappingURL=vbrief-ref.d.ts.map

package/dist/scope/vbrief-ref.js

@@ -0,0 +1,100 @@
+import { resolve } from "node:path";
+/** Resolve a vBRIEF reference URI to an absolute path, or null. */
+export function resolveVbriefRef(uri, vbriefDir) {
+    if (typeof uri !== "string" || uri.length === 0) {
+        return null;
+    }
+    let rel;
+    if (uri.startsWith("file://")) {
+        rel = uri.slice("file://".length);
+    }
+    else if (uri.startsWith("http://") || uri.startsWith("https://") || uri.startsWith("#")) {
+        return null;
+    }
+    else {
+        rel = uri;
+    }
+    return resolve(vbriefDir, rel);
+}
+/** Collect planRef values from the plan root and top-level items. */
+export function collectPlanRefs(plan) {
+    const refs = [];
+    const rootRef = plan.planRef;
+    if (typeof rootRef === "string" && rootRef.length > 0) {
+        refs.push(rootRef);
+    }
+    const items = plan.items;
+    if (Array.isArray(items)) {
+        for (const item of items) {
+            if (typeof item === "object" && item !== null && !Array.isArray(item)) {
+                const itemRef = item.planRef;
+                if (typeof itemRef === "string" && itemRef.length > 0) {
+                    refs.push(itemRef);
+                }
+            }
+        }
+    }
+    return refs;
+}
+/** Collect x-vbrief/plan child reference uris from a parent plan. */
+export function collectChildUris(plan) {
+    const uris = [];
+    const refs = plan.references;
+    if (!Array.isArray(refs)) {
+        return uris;
+    }
+    for (const ref of refs) {
+        if (typeof ref !== "object" || ref === null || Array.isArray(ref)) {
+            continue;
+        }
+        const r = ref;
+        if (r.type !== "x-vbrief/plan") {
+            continue;
+        }
+        const uri = r.uri;
+        if (typeof uri === "string" && uri.length > 0) {
+            uris.push(uri);
+        }
+    }
+    return uris;
+}
+/** Return registry IDs that may name a vBRIEF filename. */
+export function scopeIdsForFilename(filename) {
+    let fullId;
+    if (filename.endsWith(".vbrief.json")) {
+        fullId = filename.slice(0, -".vbrief.json".length);
+    }
+    else {
+        fullId = filename.replace(/\.[^.]+$/, "");
+    }
+    const ids = new Set([fullId]);
+    const parts = fullId.split("-");
+    if (parts.length >= 4) {
+        const [y, m, d, ...rest] = parts;
+        if (y?.length === 4 &&
+            m?.length === 2 &&
+            d?.length === 2 &&
+            [y, m, d].every((p) => /^\d+$/.test(p)) &&
+            rest.length > 0) {
+            ids.add(rest.join("-"));
+        }
+    }
+    return ids;
+}
+export function relativeToVbrief(path, vbriefRoot) {
+    const resolved = resolve(path);
+    const root = resolve(vbriefRoot);
+    if (!resolved.startsWith(`${root}/`) && resolved !== root) {
+        return null;
+    }
+    return resolved.slice(root.length + 1).replace(/\\/g, "/");
+}
+export function canonicalRelpath(filePath, projectRoot) {
+    const resolved = resolve(filePath);
+    const root = resolve(projectRoot);
+    if (resolved.startsWith(`${root}/`) || resolved === root) {
+        return resolved.slice(root.length + (resolved === root ? 0 : 1)).replace(/\\/g, "/");
+    }
+    return resolved.replace(/\\/g, "/");
+}
+//# sourceMappingURL=vbrief-ref.js.map

package/dist/scope/wip-cap-check.d.ts

@@ -0,0 +1,11 @@
+export interface WipCapCheck {
+    readonly allowed: boolean;
+    readonly cap: number;
+    readonly count: number;
+    readonly source: string;
+    readonly forceOverride: boolean;
+}
+/** Resolve WIP cap and decide if promotion is allowed (#1124). */
+export declare function checkWipCap(projectRoot: string, force?: boolean): WipCapCheck;
+export declare function formatWipCapRefusal(check: WipCapCheck): string;
+//# sourceMappingURL=wip-cap-check.d.ts.map

package/dist/scope/wip-cap-check.js

@@ -0,0 +1,23 @@
+import { countVbriefWip, resolveWipCap } from "../policy/wip.js";
+/** Resolve WIP cap and decide if promotion is allowed (#1124). */
+export function checkWipCap(projectRoot, force = false) {
+    const capResult = resolveWipCap(projectRoot);
+    const cap = capResult.cap;
+    const count = countVbriefWip(projectRoot);
+    const overCap = count >= cap;
+    if (!overCap) {
+        return { allowed: true, cap, count, source: capResult.source, forceOverride: false };
+    }
+    if (force) {
+        return { allowed: true, cap, count, source: capResult.source, forceOverride: true };
+    }
+    return { allowed: false, cap, count, source: capResult.source, forceOverride: false };
+}
+export function formatWipCapRefusal(check) {
+    return (`ERROR: WIP cap reached (${check.count}/${check.cap} in pending/+active/). ` +
+        "Either:\n" +
+        "  task scope:demote <existing>                              # return one to proposed/\n" +
+        "  task scope:demote --batch --older-than-days 30            # bulk relief (D9 folded into D1)\n" +
+        "  task scope:promote <file> --force                          # override (logged)");
+}
+//# sourceMappingURL=wip-cap-check.js.map

package/dist/session/git.d.ts

@@ -0,0 +1,14 @@
+export interface GitRunResult {
+    readonly code: number;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+export type GitRunner = (projectRoot: string, args: readonly string[]) => GitRunResult;
+export declare const defaultGitRunner: GitRunner;
+export declare function gitHead(projectRoot: string, runGit?: GitRunner): {
+    head: string | null;
+    error: string | null;
+};
+export declare function worktreePath(projectRoot: string, runGit?: GitRunner): string;
+export declare function detectBranch(projectRoot: string, runGit?: GitRunner): string | null;
+//# sourceMappingURL=git.d.ts.map