@deftai/directive-core 0.55.0

package/dist/lifecycle/lifecycle-hygiene.js

@@ -0,0 +1,388 @@
+import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, statSync, } from "node:fs";
+import { basename, join, resolve } from "node:path";
+import { computeReport } from "../capacity/show.js";
+import { resolveCapacityAllocation } from "../policy/capacity.js";
+import { loadProjectDefinition } from "../policy/resolve.js";
+/** Default dormancy (days) past which a partially-completed epic is stranded. */
+export const EPIC_STRANDED_DAYS_DEFAULT = 30;
+/** Default dormancy (days) past which an undecomposed epic is stale. */
+export const EPIC_STALENESS_DAYS_DEFAULT = 14;
+/** vBRIEF plan.metadata.kind values treated as epic-like parents. */
+export const PARENT_KINDS = new Set(["epic", "phase"]);
+/** Lifecycle folders scanned for epics + children (filesystem-truth view). */
+export const LIFECYCLE_FOLDERS = [
+    "proposed",
+    "pending",
+    "active",
+    "completed",
+    "cancelled",
+];
+/** plan.status values that make an epic terminal. */
+export const TERMINAL_STATUSES = new Set(["completed", "cancelled", "failed"]);
+/** Child reference type that marks an epic as decomposed. */
+export const CHILD_REF_TYPE = "x-vbrief/plan";
+/** Durable tech-debt acceptance ledger relative path segments. */
+export const TECH_DEBT_LEDGER_RELPATH = [
+    "vbrief",
+    ".audit",
+    "epic-tech-debt-accepted.jsonl",
+];
+/** Session-start nudge tiers (rate-of-harm ranking). */
+export const TIER_STRANDED = 1;
+export const TIER_STALE_EPIC = 2;
+export const TIER_CAPACITY_COLDSTART = 3;
+/** Stable nudge id for the singleton capacity cold-start nudge. */
+export const CAPACITY_COLDSTART_NUDGE_ID = "capacity-coldstart";
+/** Default actor recorded in the tech-debt ledger. */
+export const DEFAULT_ACTOR = "lifecycle-hygiene";
+function positiveInt(value, defaultValue) {
+    if (typeof value === "number" && Number.isInteger(value) && value > 0) {
+        return value;
+    }
+    return defaultValue;
+}
+/** Resolve epicStrandedDays / epicStalenessDays from PROJECT-DEFINITION. */
+export function resolveEpicThresholds(projectRoot) {
+    const [data] = loadProjectDefinition(projectRoot);
+    let raw = {};
+    if (data !== null && typeof data === "object") {
+        const plan = data.plan;
+        if (typeof plan === "object" && plan !== null && !Array.isArray(plan)) {
+            const pol = plan.policy;
+            if (typeof pol === "object" && pol !== null && !Array.isArray(pol)) {
+                const cap = pol.capacityAllocation;
+                if (typeof cap === "object" && cap !== null && !Array.isArray(cap)) {
+                    raw = cap;
+                }
+            }
+        }
+    }
+    return {
+        strandedDays: positiveInt(raw.epicStrandedDays, EPIC_STRANDED_DAYS_DEFAULT),
+        stalenessDays: positiveInt(raw.epicStalenessDays, EPIC_STALENESS_DAYS_DEFAULT),
+    };
+}
+function parseIso(value) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        return null;
+    }
+    let text = value.trim();
+    if (text.endsWith("Z")) {
+        text = `${text.slice(0, -1)}+00:00`;
+    }
+    const parsed = new Date(text);
+    if (Number.isNaN(parsed.getTime())) {
+        return null;
+    }
+    return parsed;
+}
+function updatedAt(plan, path) {
+    const stamp = parseIso(plan.updated);
+    if (stamp !== null) {
+        return stamp;
+    }
+    try {
+        return new Date(statSync(path).mtimeMs);
+    }
+    catch {
+        return null;
+    }
+}
+function kind(plan) {
+    const metadata = plan.metadata;
+    if (typeof metadata === "object" && metadata !== null && !Array.isArray(metadata)) {
+        const raw = metadata.kind;
+        if (typeof raw === "string" && raw.length > 0) {
+            return raw;
+        }
+    }
+    return "story";
+}
+function status(record) {
+    const raw = record.plan.status;
+    if (typeof raw === "string" && raw.length > 0) {
+        return raw;
+    }
+    if (record.folder === "completed") {
+        return "completed";
+    }
+    if (record.folder === "cancelled") {
+        return "cancelled";
+    }
+    return "";
+}
+function isCompleted(record) {
+    return status(record) === "completed" || record.folder === "completed";
+}
+function childRefNames(plan) {
+    const refs = plan.references;
+    if (!Array.isArray(refs)) {
+        return [];
+    }
+    const names = [];
+    for (const ref of refs) {
+        if (typeof ref !== "object" || ref === null || Array.isArray(ref)) {
+            continue;
+        }
+        const rec = ref;
+        if (rec.type !== CHILD_REF_TYPE) {
+            continue;
+        }
+        const uri = rec.uri;
+        if (typeof uri === "string" && uri.trim().length > 0) {
+            names.push(basename(uri.trim()));
+        }
+    }
+    return names;
+}
+function iterVbriefs(projectRoot) {
+    const out = [];
+    const vroot = join(resolve(projectRoot), "vbrief");
+    for (const folder of LIFECYCLE_FOLDERS) {
+        const fdir = join(vroot, folder);
+        if (!existsSync(fdir)) {
+            continue;
+        }
+        const children = readdirSync(fdir)
+            .filter((name) => name.endsWith(".vbrief.json"))
+            .sort();
+        for (const name of children) {
+            const child = join(fdir, name);
+            try {
+                const raw = readFileSync(child, "utf8");
+                const data = JSON.parse(raw);
+                const plan = typeof data === "object" && data !== null && !Array.isArray(data)
+                    ? data.plan
+                    : null;
+                if (typeof plan !== "object" || plan === null || Array.isArray(plan)) {
+                    continue;
+                }
+                out.push({
+                    name,
+                    folder,
+                    relPath: `${folder}/${name}`,
+                    plan: plan,
+                    updated: updatedAt(plan, child),
+                });
+            }
+            catch { }
+        }
+    }
+    return out;
+}
+function dormancyDays(stamps, now) {
+    const known = stamps.filter((s) => s !== null);
+    if (known.length === 0) {
+        return null;
+    }
+    const mostRecent = new Date(Math.max(...known.map((s) => s.getTime())));
+    const deltaMs = now.getTime() - mostRecent.getTime();
+    return Math.max(0, Math.floor(deltaMs / 86_400_000));
+}
+/** Absolute path to vbrief/.audit/epic-tech-debt-accepted.jsonl. */
+export function techDebtLedgerPath(projectRoot) {
+    return join(resolve(projectRoot), ...TECH_DEBT_LEDGER_RELPATH);
+}
+function utcIso(dt = null) {
+    const value = dt ?? new Date();
+    const iso = value.toISOString();
+    return `${iso.slice(0, 19)}Z`;
+}
+/** Append a tech-debt acceptance record and stop re-nudging the epic. */
+export function recordTechDebtAcceptance(projectRoot, epic, options) {
+    const epicKey = basename(epic.trim());
+    if (epicKey.length === 0) {
+        throw new Error("epic must be a non-empty basename or path");
+    }
+    const followUpRef = options.followUpRef;
+    if (typeof followUpRef !== "string" || followUpRef.trim().length === 0) {
+        throw new Error("follow_up_ref must be a non-empty reference string");
+    }
+    const path = techDebtLedgerPath(projectRoot);
+    mkdirSync(resolve(path, ".."), { recursive: true });
+    const record = {
+        accepted_at: utcIso(options.now ?? null),
+        actor: options.actor ?? DEFAULT_ACTOR,
+        epic: epicKey,
+        follow_up_ref: followUpRef.trim(),
+    };
+    appendFileSync(path, `${JSON.stringify(sortKeys(record))}\n`, "utf8");
+    return path;
+}
+/** Return the set of epic basenames already accepted as tech-debt. */
+export function loadAcceptedDebtKeys(projectRoot) {
+    const path = techDebtLedgerPath(projectRoot);
+    if (!existsSync(path)) {
+        return new Set();
+    }
+    const keys = new Set();
+    try {
+        const text = readFileSync(path, "utf8");
+        for (const line of text.split(/\r?\n/)) {
+            const stripped = line.trim();
+            if (stripped.length === 0) {
+                continue;
+            }
+            try {
+                const obj = JSON.parse(stripped);
+                if (typeof obj === "object" && obj !== null && !Array.isArray(obj)) {
+                    const epic = obj.epic;
+                    if (typeof epic === "string" && epic.length > 0) {
+                        keys.add(epic);
+                    }
+                }
+            }
+            catch { }
+        }
+    }
+    catch {
+        return keys;
+    }
+    return keys;
+}
+function renderStranded(title, dormant, threshold, completed, total) {
+    return (`[TIER-1] stranded slice: epic "${title}" dormant ${dormant}d ` +
+        `(> epicStrandedDays ${threshold}) with ${completed}/${total} children ` +
+        "completed -- finish | cancel-and-remove | accept-as-tech-debt " +
+        "(see `task capacity:show`)");
+}
+function renderStaleEpic(title, dormant, threshold) {
+    return (`[TIER-2] stale epic: undecomposed epic "${title}" dormant ${dormant}d ` +
+        `(> epicStalenessDays ${threshold}) -- needs estimation/decomposition`);
+}
+function renderCapacityColdstart(unclassified, classified, minimum) {
+    return (`[TIER-3] capacity cold-start: ${unclassified} completed vBRIEF(s) ` +
+        `unclassified (classified ${classified}/${minimum} in window) -- run ` +
+        "`task capacity:backfill --apply` to classify history and activate " +
+        "capacity accounting (#1606)");
+}
+function title(record) {
+    const raw = record.plan.title;
+    if (typeof raw === "string" && raw.trim().length > 0) {
+        return raw.trim();
+    }
+    return record.name;
+}
+function strandedNudge(epic, childNames, resolved, thresholds, now) {
+    const completed = resolved.filter((c) => isCompleted(c));
+    const total = childNames.length;
+    if (completed.length === 0 || completed.length >= total) {
+        return null;
+    }
+    const stamps = [epic.updated, ...resolved.map((c) => c.updated)];
+    const dormant = dormancyDays(stamps, now);
+    if (dormant === null || dormant <= thresholds.strandedDays) {
+        return null;
+    }
+    const epicTitle = title(epic);
+    return {
+        nudgeId: epic.name,
+        kind: "stranded",
+        tier: TIER_STRANDED,
+        title: epicTitle,
+        epicRelPath: epic.relPath,
+        dormantDays: dormant,
+        completedChildren: completed.length,
+        totalChildren: total,
+        magnitude: dormant,
+        message: renderStranded(epicTitle, dormant, thresholds.strandedDays, completed.length, total),
+    };
+}
+function staleEpicNudge(epic, thresholds, now) {
+    const dormant = dormancyDays([epic.updated], now);
+    if (dormant === null || dormant <= thresholds.stalenessDays) {
+        return null;
+    }
+    const epicTitle = title(epic);
+    return {
+        nudgeId: epic.name,
+        kind: "stale-epic",
+        tier: TIER_STALE_EPIC,
+        title: epicTitle,
+        epicRelPath: epic.relPath,
+        dormantDays: dormant,
+        completedChildren: 0,
+        totalChildren: 0,
+        magnitude: dormant,
+        message: renderStaleEpic(epicTitle, dormant, thresholds.stalenessDays),
+    };
+}
+/** Detect stranded-slice (Tier 1) + stale-epic (Tier 2) nudges. */
+export function detectLifecycleNudges(projectRoot, options = {}) {
+    const nowDt = options.now ?? new Date();
+    const thresholds = resolveEpicThresholds(projectRoot);
+    const accepted = loadAcceptedDebtKeys(projectRoot);
+    const records = iterVbriefs(projectRoot);
+    const index = new Map(records.map((r) => [r.name, r]));
+    const nudges = [];
+    for (const record of records) {
+        if (!PARENT_KINDS.has(kind(record.plan))) {
+            continue;
+        }
+        if (TERMINAL_STATUSES.has(status(record))) {
+            continue;
+        }
+        if (accepted.has(record.name)) {
+            continue;
+        }
+        const childNames = childRefNames(record.plan);
+        const resolved = childNames
+            .map((name) => index.get(name))
+            .filter((r) => r !== undefined);
+        const nudge = resolved.length > 0
+            ? strandedNudge(record, childNames, resolved, thresholds, nowDt)
+            : staleEpicNudge(record, thresholds, nowDt);
+        if (nudge !== null) {
+            nudges.push(nudge);
+        }
+    }
+    const capacityNudge = detectCapacityColdstartNudge(projectRoot, { now: nowDt });
+    if (capacityNudge !== null) {
+        nudges.push(capacityNudge);
+    }
+    nudges.sort((a, b) => {
+        if (a.tier !== b.tier) {
+            return a.tier - b.tier;
+        }
+        if (a.magnitude !== b.magnitude) {
+            return b.magnitude - a.magnitude;
+        }
+        return a.nudgeId.localeCompare(b.nudgeId);
+    });
+    return nudges;
+}
+/** Capacity classification cold-start (Tier 3) nudge (#1606). */
+export function detectCapacityColdstartNudge(projectRoot, options = {}) {
+    const allocation = resolveCapacityAllocation(projectRoot);
+    if (!allocation.configured) {
+        return null;
+    }
+    const report = computeReport(projectRoot, { now: options.now, allocation });
+    if (report.classified_completions >= report.min_sample_size) {
+        return null;
+    }
+    if (report.unclassified_completions <= 0) {
+        return null;
+    }
+    const message = renderCapacityColdstart(report.unclassified_completions, report.classified_completions, report.min_sample_size);
+    return {
+        nudgeId: CAPACITY_COLDSTART_NUDGE_ID,
+        kind: "capacity-coldstart",
+        tier: TIER_CAPACITY_COLDSTART,
+        title: "capacity cold-start",
+        epicRelPath: "",
+        dormantDays: 0,
+        completedChildren: 0,
+        totalChildren: 0,
+        magnitude: report.unclassified_completions,
+        message,
+    };
+}
+function sortKeys(value) {
+    const sorted = {};
+    for (const key of Object.keys(value).sort()) {
+        sorted[key] = value[key];
+    }
+    return sorted;
+}
+//# sourceMappingURL=lifecycle-hygiene.js.map

package/dist/orchestration/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./judgment-policy.js";
+export * from "./pathspec.js";
+export * from "./probe-session.js";
+export * from "./subagent-monitor.js";
+export * from "./verify-investigation.js";
+export * from "./verify-judgment-gates.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/orchestration/index.js

@@ -0,0 +1,7 @@
+export * from "./judgment-policy.js";
+export * from "./pathspec.js";
+export * from "./probe-session.js";
+export * from "./subagent-monitor.js";
+export * from "./verify-investigation.js";
+export * from "./verify-judgment-gates.js";
+//# sourceMappingURL=index.js.map

package/dist/orchestration/judgment-policy.d.ts

@@ -0,0 +1,23 @@
+export declare const GATE_CLASSES: Set<string>;
+export declare const GATE_TIERS: Set<string>;
+export declare const GATE_MATCH_PREDICATES: Set<string>;
+export declare const GATE_MATCH_STATES: Set<string>;
+export interface JudgmentGate {
+    readonly gate_id: string;
+    readonly gate_class: string;
+    readonly match: Record<string, unknown>;
+    readonly tier: string;
+    readonly reason: string;
+    readonly required_human_reviewers: number;
+}
+export interface JudgmentGatesPolicy {
+    readonly gates: readonly JudgmentGate[];
+    readonly disabled: readonly string[];
+    readonly source: string;
+    readonly error: string | null;
+}
+export declare function validateJudgmentGates(value: unknown): string[];
+export declare function validateJudgmentGatesDisabled(value: unknown): string[];
+/** Resolve judgmentGates + judgmentGatesDisabled from PROJECT-DEFINITION. */
+export declare function resolveJudgmentGates(projectRoot: string): JudgmentGatesPolicy;
+//# sourceMappingURL=judgment-policy.d.ts.map

package/dist/orchestration/judgment-policy.js

@@ -0,0 +1,228 @@
+/**
+ * Judgment-gate policy resolution (#1419). Port of scripts/policy.py judgment-gate section.
+ */
+import { loadProjectDefinition } from "../policy/resolve.js";
+export const GATE_CLASSES = new Set(["mechanical", "declared"]);
+export const GATE_TIERS = new Set(["auto", "review", "block"]);
+export const GATE_MATCH_PREDICATES = new Set(["labels", "body-text", "paths", "state", "age-days"]);
+export const GATE_MATCH_STATES = new Set(["open", "closed"]);
+function validateStrList(value, prefix, key) {
+    if (!Array.isArray(value) || value.length === 0) {
+        return [`${prefix}.${key} must be a non-empty list of strings`];
+    }
+    const errors = [];
+    for (let j = 0; j < value.length; j += 1) {
+        const item = value[j];
+        if (typeof item !== "string" || item.length === 0) {
+            errors.push(`${prefix}.${key}[${j}] must be a non-empty string`);
+        }
+    }
+    return errors;
+}
+function validateGlobPredicate(value, prefix) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return [`${prefix} must be an object with an 'any-of' glob list`];
+    }
+    const obj = value;
+    if (!("any-of" in obj)) {
+        return [`${prefix} requires 'any-of'`];
+    }
+    return validateStrList(obj["any-of"], prefix, "any-of");
+}
+function validateGateLabels(value, prefix) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return [`${prefix} must be an object`];
+    }
+    const obj = value;
+    const anyOf = obj["any-of"];
+    const allOf = obj["all-of"];
+    if (anyOf === undefined && allOf === undefined) {
+        return [`${prefix} requires 'any-of' or 'all-of'`];
+    }
+    if (anyOf !== undefined && allOf !== undefined) {
+        return [`${prefix}: 'any-of' and 'all-of' are mutually exclusive`];
+    }
+    const key = anyOf !== undefined ? "any-of" : "all-of";
+    return validateStrList(anyOf ?? allOf, prefix, key);
+}
+function validateGateAnyOf(value, prefix) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return [`${prefix} must be an object`];
+    }
+    const obj = value;
+    if (!("any-of" in obj)) {
+        return [`${prefix} requires 'any-of'`];
+    }
+    return validateStrList(obj["any-of"], prefix, "any-of");
+}
+function validateGateAgeDays(value, prefix) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return [`${prefix} must be an object`];
+    }
+    const gt = value.gt;
+    if (typeof gt !== "number" || !Number.isInteger(gt) || gt < 0) {
+        return [`${prefix}.gt must be a non-negative integer; got ${JSON.stringify(gt)}`];
+    }
+    return [];
+}
+function validateGateMatch(match, prefix) {
+    if (typeof match !== "object" || match === null || Array.isArray(match)) {
+        return [`${prefix} must be an object`];
+    }
+    const mobj = match;
+    const used = Object.keys(mobj)
+        .filter((k) => GATE_MATCH_PREDICATES.has(k))
+        .sort();
+    if (used.length === 0) {
+        return [`${prefix} requires at least one of ${[...GATE_MATCH_PREDICATES].sort().join(", ")}`];
+    }
+    const errors = [];
+    const extra = Object.keys(mobj)
+        .filter((k) => !GATE_MATCH_PREDICATES.has(k))
+        .sort();
+    if (extra.length > 0) {
+        errors.push(`${prefix} has unrecognised predicate(s) ${JSON.stringify(extra)}; expected only ${[...GATE_MATCH_PREDICATES].sort().join(", ")}`);
+    }
+    if ("paths" in mobj) {
+        errors.push(...validateGlobPredicate(mobj.paths, `${prefix}.paths`));
+    }
+    if ("labels" in mobj) {
+        errors.push(...validateGateLabels(mobj.labels, `${prefix}.labels`));
+    }
+    if ("body-text" in mobj) {
+        errors.push(...validateGateAnyOf(mobj["body-text"], `${prefix}.body-text`));
+    }
+    if ("state" in mobj && !GATE_MATCH_STATES.has(String(mobj.state))) {
+        errors.push(`${prefix}.state must be one of ${[...GATE_MATCH_STATES].sort().join(", ")}; got ${JSON.stringify(mobj.state)}`);
+    }
+    if ("age-days" in mobj) {
+        errors.push(...validateGateAgeDays(mobj["age-days"], `${prefix}.age-days`));
+    }
+    return errors;
+}
+function validateSingleGate(gate, prefix) {
+    if (typeof gate !== "object" || gate === null || Array.isArray(gate)) {
+        return [[`${prefix} must be an object; got ${typeof gate}`], null];
+    }
+    const g = gate;
+    const errors = [];
+    const gid = g.id;
+    let resolvedId = null;
+    if (typeof gid !== "string" || !gid.trim()) {
+        errors.push(`${prefix}.id must be a non-empty string`);
+    }
+    else {
+        resolvedId = gid;
+    }
+    if (!GATE_CLASSES.has(String(g.class))) {
+        errors.push(`${prefix}.class must be one of ${[...GATE_CLASSES].sort().join(", ")}; got ${JSON.stringify(g.class)}`);
+    }
+    if (!GATE_TIERS.has(String(g.tier))) {
+        errors.push(`${prefix}.tier must be one of ${[...GATE_TIERS].sort().join(", ")}; got ${JSON.stringify(g.tier)}`);
+    }
+    const reason = g.reason;
+    if (typeof reason !== "string" || !reason.trim()) {
+        errors.push(`${prefix}.reason must be a non-empty string`);
+    }
+    if ("requiredHumanReviewers" in g) {
+        const rhr = g.requiredHumanReviewers;
+        if (typeof rhr !== "number" || !Number.isInteger(rhr) || rhr < 0) {
+            errors.push(`${prefix}.requiredHumanReviewers must be a non-negative integer; got ${JSON.stringify(rhr)}`);
+        }
+    }
+    errors.push(...validateGateMatch(g.match, `${prefix}.match`));
+    return [errors, resolvedId];
+}
+export function validateJudgmentGates(value) {
+    if (value === null || value === undefined) {
+        return [];
+    }
+    if (!Array.isArray(value)) {
+        return [`plan.policy.judgmentGates must be a list of gate objects; got ${typeof value}`];
+    }
+    const errors = [];
+    const ids = [];
+    for (let idx = 0; idx < value.length; idx += 1) {
+        const [gateErrors, gateId] = validateSingleGate(value[idx], `plan.policy.judgmentGates[${idx}]`);
+        errors.push(...gateErrors);
+        if (gateId !== null) {
+            ids.push(gateId);
+        }
+    }
+    const duplicates = [...new Set(ids.filter((g, i) => ids.indexOf(g) !== i))].sort();
+    if (duplicates.length > 0) {
+        errors.push(`plan.policy.judgmentGates ids must be unique; duplicates: ${duplicates.join(", ")}`);
+    }
+    return errors;
+}
+export function validateJudgmentGatesDisabled(value) {
+    if (value === null || value === undefined) {
+        return [];
+    }
+    if (!Array.isArray(value)) {
+        return [`plan.policy.judgmentGatesDisabled must be a list of gate ids; got ${typeof value}`];
+    }
+    const errors = [];
+    for (let j = 0; j < value.length; j += 1) {
+        const item = value[j];
+        if (typeof item !== "string" || !item.trim()) {
+            errors.push(`plan.policy.judgmentGatesDisabled[${j}] must be a non-empty string`);
+        }
+    }
+    return errors;
+}
+function defaultPolicy(source, error = null) {
+    return { gates: [], disabled: [], source, error };
+}
+function getPolicyBlock(data) {
+    const plan = data.plan;
+    if (typeof plan === "object" && plan !== null && !Array.isArray(plan)) {
+        const policy = plan.policy;
+        if (typeof policy === "object" && policy !== null && !Array.isArray(policy)) {
+            return policy;
+        }
+    }
+    return {};
+}
+/** Resolve judgmentGates + judgmentGatesDisabled from PROJECT-DEFINITION. */
+export function resolveJudgmentGates(projectRoot) {
+    const [data, err] = loadProjectDefinition(projectRoot);
+    if (data === null) {
+        return defaultPolicy("default", err);
+    }
+    const policyBlock = getPolicyBlock(data);
+    const rawGates = policyBlock.judgmentGates;
+    const rawDisabled = policyBlock.judgmentGatesDisabled;
+    if (rawGates === undefined && rawDisabled === undefined) {
+        return defaultPolicy("default");
+    }
+    const errors = [
+        ...validateJudgmentGates(rawGates),
+        ...validateJudgmentGatesDisabled(rawDisabled),
+    ];
+    if (errors.length > 0) {
+        return defaultPolicy("default-on-error", errors[0] ?? null);
+    }
+    const gates = [];
+    if (Array.isArray(rawGates)) {
+        for (const gate of rawGates) {
+            if (typeof gate !== "object" || gate === null || Array.isArray(gate)) {
+                continue;
+            }
+            const g = gate;
+            gates.push({
+                gate_id: String(g.id),
+                gate_class: String(g.class),
+                match: { ...g.match },
+                tier: String(g.tier),
+                reason: String(g.reason),
+                required_human_reviewers: Number(g.requiredHumanReviewers ?? 0),
+            });
+        }
+    }
+    const disabled = Array.isArray(rawDisabled)
+        ? rawDisabled.filter((d) => typeof d === "string")
+        : [];
+    return { gates, disabled, source: "typed", error: null };
+}
+//# sourceMappingURL=judgment-policy.js.map

package/dist/orchestration/pathspec.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Minimal gitignore-style glob matcher (#1419). Linear segment scanner — no
+ * backtracking regex (CodeQL js/polynomial-redos safe).
+ */
+/** Normalise path separators to forward slashes. */
+export declare function normalizePath(path: string): string;
+/** True when *path* matches the glob *pattern* (anchored full-path match). */
+export declare function matchPath(pattern: string, path: string): boolean;
+/** True when *path* matches any glob in *patterns*. */
+export declare function matchAny(patterns: unknown, path: string): boolean;
+//# sourceMappingURL=pathspec.d.ts.map