@deftai/directive-core 0.104.0 → 0.105.0

package/dist/policy/forge-outage-retry.js

@@ -0,0 +1,157 @@
+/**
+ * Typed plan.policy.forgeOutageRetryMinutes (#3422).
+ *
+ * Re-probe interval after a forge / SCM API outage drop-back.
+ * Precedence: USER.md Personal > project policy > framework default 30.
+ * Integer minutes, minimum 5.
+ */
+import { readFileSync } from "node:fs";
+import { resolveUserMdPath } from "../user-config/resolve-user-md.js";
+import { readPlanPolicy } from "./plan-extensions.js";
+import { loadProjectDefinition } from "./resolve.js";
+export const FIELD_FORGE_OUTAGE_RETRY_MINUTES = "plan.policy.forgeOutageRetryMinutes";
+export const FIELD_FORGE_OUTAGE_RETRY_MINUTES_CLI_ALIAS = "forgeOutageRetryMinutes";
+export const DEFAULT_FORGE_OUTAGE_RETRY_MINUTES = 30;
+export const MIN_FORGE_OUTAGE_RETRY_MINUTES = 5;
+/** Validate a raw integer-minutes value. */
+export function validateForgeOutageRetryMinutes(raw) {
+    if (typeof raw !== "number" || !Number.isInteger(raw)) {
+        return (`${FIELD_FORGE_OUTAGE_RETRY_MINUTES} must be an integer >= ` +
+            `${MIN_FORGE_OUTAGE_RETRY_MINUTES}; got ${typeof raw}`);
+    }
+    if (raw < MIN_FORGE_OUTAGE_RETRY_MINUTES) {
+        return (`${FIELD_FORGE_OUTAGE_RETRY_MINUTES} must be >= ` +
+            `${MIN_FORGE_OUTAGE_RETRY_MINUTES}; got ${raw}`);
+    }
+    return null;
+}
+/**
+ * Parse USER.md Personal forge-outage retry minutes.
+ *
+ * Accepts `forgeOutageRetryMinutes: 15` or `Forge outage retry: 15m`.
+ */
+export function parseForgeOutageRetryMinutesFromUserMd(text) {
+    const lines = text.split(/\r?\n/);
+    let inPersonal = false;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (/^##\s+personal\b/i.test(trimmed)) {
+            inPersonal = true;
+            continue;
+        }
+        if (inPersonal && /^##\s+/.test(trimmed)) {
+            break;
+        }
+        if (!inPersonal)
+            continue;
+        const stripped = trimmed.replace(/\*\*/g, "").replace(/^-\s*/, "");
+        const keyed = stripped.match(/^forgeOutageRetryMinutes\s*:\s*(.+)$/i);
+        const labeled = stripped.match(/^Forge outage retry\s*:\s*(.+)$/i);
+        const raw = keyed?.[1] ?? labeled?.[1];
+        if (raw === undefined)
+            continue;
+        const parsed = parseMinutesToken(raw);
+        if (parsed !== null)
+            return parsed;
+    }
+    return null;
+}
+function parseMinutesToken(raw) {
+    const token = raw.replace(/\*\*/g, "").trim();
+    const match = token.match(/^(\d+)\s*(?:m(?:in(?:ute)?s?)?)?$/i);
+    if (match?.[1] === undefined)
+        return null;
+    const minutes = Number(match[1]);
+    if (!Number.isInteger(minutes))
+        return null;
+    return minutes;
+}
+function readUserMdText(options) {
+    if (options.userMdText !== undefined) {
+        return options.userMdText;
+    }
+    const projectRoot = options.projectRoot ?? process.cwd();
+    const resolved = resolveUserMdPath({
+        projectRoot,
+        env: options.env ?? process.env,
+    });
+    if (!resolved.found)
+        return null;
+    try {
+        return readFileSync(resolved.path, { encoding: "utf8" });
+    }
+    catch {
+        return null;
+    }
+}
+function readProjectMinutes(projectRoot) {
+    const [data, err] = loadProjectDefinition(projectRoot);
+    if (data === null) {
+        return { present: false, minutes: null, error: err };
+    }
+    const policyBlock = readPlanPolicy(data.plan);
+    if (typeof policyBlock !== "object" ||
+        policyBlock === null ||
+        Array.isArray(policyBlock) ||
+        !("forgeOutageRetryMinutes" in policyBlock)) {
+        return { present: false, minutes: null, error: null };
+    }
+    const raw = policyBlock.forgeOutageRetryMinutes;
+    if (raw === null) {
+        return { present: false, minutes: null, error: null };
+    }
+    const validationError = validateForgeOutageRetryMinutes(raw);
+    if (validationError !== null) {
+        return { present: true, minutes: null, error: validationError };
+    }
+    return { present: true, minutes: raw, error: null };
+}
+/**
+ * Resolve forge-outage re-probe minutes (#3422).
+ *
+ * 1. Valid USER.md Personal value
+ * 2. Valid plan.policy.forgeOutageRetryMinutes
+ * 3. Framework default 30
+ */
+export function resolveForgeOutageRetryMinutes(options = {}) {
+    const userMdText = readUserMdText(options);
+    if (userMdText !== null) {
+        const personal = parseForgeOutageRetryMinutesFromUserMd(userMdText);
+        if (personal !== null) {
+            const personalError = validateForgeOutageRetryMinutes(personal);
+            if (personalError === null) {
+                return { minutes: personal, source: "user-md", error: null };
+            }
+        }
+    }
+    const projectRoot = options.projectRoot;
+    if (projectRoot !== undefined && projectRoot !== null && projectRoot.length > 0) {
+        const project = readProjectMinutes(projectRoot);
+        if (project.minutes !== null) {
+            return { minutes: project.minutes, source: "typed", error: null };
+        }
+        if (project.present && project.error !== null) {
+            return {
+                minutes: DEFAULT_FORGE_OUTAGE_RETRY_MINUTES,
+                source: "default-on-error",
+                error: project.error,
+            };
+        }
+    }
+    return {
+        minutes: DEFAULT_FORGE_OUTAGE_RETRY_MINUTES,
+        source: "default",
+        error: null,
+    };
+}
+/** Inspector row for `task policy:show --field=forgeOutageRetryMinutes`. */
+export function inspectForgeOutageRetryMinutes(_data, projectRoot) {
+    const resolved = resolveForgeOutageRetryMinutes({ projectRoot });
+    return {
+        name: FIELD_FORGE_OUTAGE_RETRY_MINUTES,
+        current: resolved.minutes,
+        default: DEFAULT_FORGE_OUTAGE_RETRY_MINUTES,
+        source: resolved.source,
+    };
+}
+//# sourceMappingURL=forge-outage-retry.js.map

package/dist/policy/index.d.ts

@@ -1,6 +1,8 @@
 export * from "./ac-pass-banking.js";
 export * from "./agents-md-advisory.js";
 export * from "./autonomy.js";
+export * from "./base-branch.js";
+export * from "./branch-sync.js";
 export * from "./capacity.js";
 export * from "./ceremony-dial.js";
 export * from "./ceremony-dial-escalation.js";
@@ -10,6 +12,8 @@ export * from "./decisions.js";
 export * from "./deft-directive-disable.js";
 export * from "./delivery-branch.js";
 export * from "./disclosure.js";
+export * from "./file-size-thresholds.js";
+export * from "./forge-outage-retry.js";
 export * from "./host-hooks.js";
 export * from "./host-slash-commands.js";
 export * from "./hotfix-criteria.js";
@@ -21,10 +25,13 @@ export * from "./org-force-on-migration.js";
 export * from "./plan-extensions.js";
 export * from "./policy-invocation.js";
 export * from "./product-signal.js";
+export * from "./project-invariants.js";
 export * from "./require-human-merge.js";
 export * from "./resolve.js";
 export * from "./runtime-authority.js";
 export * from "./staleness-tickler.js";
+export * from "./sync-default.js";
+export * from "./sync-max-files.js";
 export * from "./value-feedback.js";
 export * from "./value-feedback-autoenable.js";
 export * from "./wip.js";

package/dist/policy/index.js

@@ -1,25 +1,31 @@
 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_AC_PASS_BANKING, FIELD_AC_PASS_BANKING_CLI_ALIAS, inspectAcPassBanking, } from "./ac-pass-banking.js";
+import { FIELD_BASE_BRANCH, FIELD_BASE_BRANCH_CLI_ALIAS, inspectBaseBranch, } from "./base-branch.js";
 import { FIELD_CEREMONY_DIAL, FIELD_CEREMONY_DIAL_CLI_ALIAS, inspectCeremonyDial, } from "./ceremony-dial.js";
 import { FIELD_CHECK_RESUME, FIELD_CHECK_RESUME_CLI_ALIAS, inspectCheckResume, } from "./check-resume.js";
 import { FIELD_COVERAGE_DEBT, FIELD_COVERAGE_DEBT_CLI_ALIAS, inspectCoverageDebt, } from "./coverage-debt.js";
 import { FIELD_DELIVERY_BRANCH, FIELD_DELIVERY_BRANCH_CLI_ALIAS, inspectDeliveryBranch, } from "./delivery-branch.js";
+import { FIELD_FORGE_OUTAGE_RETRY_MINUTES, FIELD_FORGE_OUTAGE_RETRY_MINUTES_CLI_ALIAS, inspectForgeOutageRetryMinutes, } from "./forge-outage-retry.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 { FIELD_MIN_GREPTILE_CONFIDENCE, FIELD_MIN_GREPTILE_CONFIDENCE_CLI_ALIAS, inspectMinGreptileConfidence, } from "./min-greptile-confidence.js";
 import { readPlanPolicy } from "./plan-extensions.js";
 import { FIELD_PRODUCT_SIGNAL, FIELD_PRODUCT_SIGNAL_CLI_ALIAS, inspectProductSignal, } from "./product-signal.js";
+import { FIELD_PROJECT_INVARIANTS, FIELD_PROJECT_INVARIANTS_CLI_ALIAS, inspectProjectInvariants, } from "./project-invariants.js";
 import { FIELD_REQUIRE_HUMAN_MERGE, FIELD_REQUIRE_HUMAN_MERGE_CLI_ALIAS, inspectRequireHumanMerge, } from "./require-human-merge.js";
 import { coerceLegacyNarrative, LEGACY_NARRATIVE_KEY, loadProjectDefinition } from "./resolve.js";
 import { FIELD_RUNTIME_AUTHORITY, FIELD_RUNTIME_AUTHORITY_CLI_ALIAS, inspectRuntimeAuthority, } from "./runtime-authority.js";
 import { FIELD_STALENESS_TICKLER, FIELD_STALENESS_TICKLER_CLI_ALIAS, inspectStalenessTickler, } from "./staleness-tickler.js";
+import { FIELD_SYNC_MAX_FILES, FIELD_SYNC_MAX_FILES_CLI_ALIAS, inspectSyncMaxFiles, } from "./sync-max-files.js";
 import { FIELD_VALUE_FEEDBACK, FIELD_VALUE_FEEDBACK_CLI_ALIAS, inspectValueFeedback, } from "./value-feedback.js";
 import { DEFAULT_WIP_CAP } from "./wip.js";
 export * from "./ac-pass-banking.js";
 export * from "./agents-md-advisory.js";
 export * from "./autonomy.js";
+export * from "./base-branch.js";
+export * from "./branch-sync.js";
 export * from "./capacity.js";
 export * from "./ceremony-dial.js";
 export * from "./ceremony-dial-escalation.js";
@@ -29,6 +35,8 @@ export * from "./decisions.js";
 export * from "./deft-directive-disable.js";
 export * from "./delivery-branch.js";
 export * from "./disclosure.js";
+export * from "./file-size-thresholds.js";
+export * from "./forge-outage-retry.js";
 export * from "./host-hooks.js";
 export * from "./host-slash-commands.js";
 export * from "./hotfix-criteria.js";
@@ -40,10 +48,13 @@ export * from "./org-force-on-migration.js";
 export * from "./plan-extensions.js";
 export * from "./policy-invocation.js";
 export * from "./product-signal.js";
+export * from "./project-invariants.js";
 export * from "./require-human-merge.js";
 export * from "./resolve.js";
 export * from "./runtime-authority.js";
 export * from "./staleness-tickler.js";
+export * from "./sync-default.js";
+export * from "./sync-max-files.js";
 export * from "./value-feedback.js";
 export * from "./value-feedback-autoenable.js";
 export * from "./wip.js";
@@ -404,6 +415,15 @@ function inspectDeliveryBranchField(data, projectRoot) {
         source: field.source,
     };
 }
+function inspectBaseBranchField(data, projectRoot) {
+    const field = inspectBaseBranch(data, projectRoot);
+    return {
+        name: field.name,
+        current: field.current,
+        default: field.default,
+        source: field.source,
+    };
+}
 function inspectMinGreptileConfidenceField(data, projectRoot) {
     const field = inspectMinGreptileConfidence(data, projectRoot);
     return {
@@ -431,6 +451,33 @@ function inspectAcPassBankingField(data, projectRoot) {
         source: field.source,
     };
 }
+function inspectSyncMaxFilesField(data, projectRoot) {
+    const field = inspectSyncMaxFiles(data, projectRoot);
+    return {
+        name: field.name,
+        current: field.current,
+        default: field.default,
+        source: field.source,
+    };
+}
+function inspectForgeOutageRetryMinutesField(data, projectRoot) {
+    const field = inspectForgeOutageRetryMinutes(data, projectRoot);
+    return {
+        name: field.name,
+        current: field.current,
+        default: field.default,
+        source: field.source,
+    };
+}
+function inspectProjectInvariantsField(data, projectRoot) {
+    const field = inspectProjectInvariants(data, projectRoot);
+    return {
+        name: field.name,
+        current: field.current,
+        default: field.default,
+        source: field.source,
+    };
+}
 const REGISTERED_POLICIES = [
     inspectAllowDirectCommits,
     inspectWipCap,
@@ -445,6 +492,7 @@ const REGISTERED_POLICIES = [
     inspectTriageLabelMirrorField,
     inspectSwarmSubagentBackend,
     inspectDeliveryBranchField,
+    inspectBaseBranchField,
     inspectMinGreptileConfidenceField,
     inspectHostHooksField,
     inspectHostSlashCommandsField,
@@ -460,6 +508,9 @@ const REGISTERED_POLICIES = [
     inspectHotfixCriteriaField,
     inspectCeremonyDialField,
     inspectAcPassBankingField,
+    inspectSyncMaxFilesField,
+    inspectForgeOutageRetryMinutesField,
+    inspectProjectInvariantsField,
 ];
 /** Walk registered inspectors and return one row per field (#1148). */
 export function inspectAllPolicies(projectRoot) {
@@ -494,13 +545,21 @@ export function inspectOnePolicy(name, projectRoot) {
                                                     ? FIELD_HOTFIX_CRITERIA
                                                     : name === FIELD_DELIVERY_BRANCH_CLI_ALIAS
                                                         ? FIELD_DELIVERY_BRANCH
-                                                        : name === FIELD_MIN_GREPTILE_CONFIDENCE_CLI_ALIAS
-                                                            ? FIELD_MIN_GREPTILE_CONFIDENCE
-                                                            : name === FIELD_CEREMONY_DIAL_CLI_ALIAS
-                                                                ? FIELD_CEREMONY_DIAL
-                                                                : name === FIELD_AC_PASS_BANKING_CLI_ALIAS
-                                                                    ? FIELD_AC_PASS_BANKING
-                                                                    : name;
+                                                        : name === FIELD_BASE_BRANCH_CLI_ALIAS
+                                                            ? FIELD_BASE_BRANCH
+                                                            : name === FIELD_MIN_GREPTILE_CONFIDENCE_CLI_ALIAS
+                                                                ? FIELD_MIN_GREPTILE_CONFIDENCE
+                                                                : name === FIELD_CEREMONY_DIAL_CLI_ALIAS
+                                                                    ? FIELD_CEREMONY_DIAL
+                                                                    : name === FIELD_AC_PASS_BANKING_CLI_ALIAS
+                                                                        ? FIELD_AC_PASS_BANKING
+                                                                        : name === FIELD_SYNC_MAX_FILES_CLI_ALIAS
+                                                                            ? FIELD_SYNC_MAX_FILES
+                                                                            : name === FIELD_FORGE_OUTAGE_RETRY_MINUTES_CLI_ALIAS
+                                                                                ? FIELD_FORGE_OUTAGE_RETRY_MINUTES
+                                                                                : name === FIELD_PROJECT_INVARIANTS_CLI_ALIAS
+                                                                                    ? FIELD_PROJECT_INVARIANTS
+                                                                                    : name;
     for (const field of inspectAllPolicies(projectRoot)) {
         if (field.name === normalized)
             return field;

package/dist/policy/project-invariants.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Typed plan.policy.projectInvariants (#3425 Story A).
+ *
+ * Authored project-level must-not-break contracts. Empty or absent list is a
+ * no-op. Parse/validate only — preflight fail-closed is Story B.
+ */
+export declare const FIELD_PROJECT_INVARIANTS = "plan.policy.projectInvariants";
+export declare const FIELD_PROJECT_INVARIANTS_CLI_ALIAS = "projectInvariants";
+export interface ProjectInvariantContractSurface {
+    readonly paths: readonly string[];
+    readonly moduleIds: readonly string[];
+}
+export interface ProjectInvariant {
+    readonly id: string;
+    readonly statement: string;
+    readonly contractSurface: ProjectInvariantContractSurface;
+}
+export type ProjectInvariantsSource = "typed" | "default" | "default-on-error";
+export interface ProjectInvariantsParseResult {
+    readonly invariants: readonly ProjectInvariant[];
+    readonly errors: readonly string[];
+}
+export interface ProjectInvariantsResolved {
+    readonly invariants: readonly ProjectInvariant[];
+    readonly source: ProjectInvariantsSource;
+    readonly error: string | null;
+}
+export interface ProjectInvariantsPolicyField {
+    readonly name: typeof FIELD_PROJECT_INVARIANTS;
+    readonly current: readonly ProjectInvariant[];
+    readonly default: readonly ProjectInvariant[];
+    readonly source: string;
+}
+/** Parse a raw projectInvariants value. Absent/null → empty list, no errors. */
+export declare function parseProjectInvariants(raw: unknown): ProjectInvariantsParseResult;
+/**
+ * Map codeStructure.modules[] id → pathGlobs for applicability intersection.
+ * Pure: pass PROJECT-DEFINITION (or plan) data, no disk IO.
+ */
+export declare function extractModulePathGlobs(projectDefinition: unknown): Record<string, string[]>;
+/**
+ * Resolve projectInvariants from PROJECT-DEFINITION data already in memory.
+ * Absent/null → default empty. Present invalid → default-on-error + message.
+ */
+export declare function resolveProjectInvariantsFromData(data: Record<string, unknown> | null): ProjectInvariantsResolved;
+/** Resolve from a project root via the PROJECT-DEFINITION IO path. */
+export declare function resolveProjectInvariants(projectRoot: string): ProjectInvariantsResolved;
+/** Inspector row for `task policy:show --field=projectInvariants`. */
+export declare function inspectProjectInvariants(data: Record<string, unknown> | null, projectRoot?: string): ProjectInvariantsPolicyField;
+//# sourceMappingURL=project-invariants.d.ts.map

package/dist/policy/project-invariants.js

@@ -0,0 +1,205 @@
+/**
+ * Typed plan.policy.projectInvariants (#3425 Story A).
+ *
+ * Authored project-level must-not-break contracts. Empty or absent list is a
+ * no-op. Parse/validate only — preflight fail-closed is Story B.
+ */
+import { readPlanPolicy } from "./plan-extensions.js";
+import { loadProjectDefinition } from "./resolve.js";
+export const FIELD_PROJECT_INVARIANTS = "plan.policy.projectInvariants";
+export const FIELD_PROJECT_INVARIANTS_CLI_ALIAS = "projectInvariants";
+const EMPTY = [];
+function asRecord(value) {
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        return value;
+    }
+    return null;
+}
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function asStrList(value) {
+    if (value === null || value === undefined)
+        return [];
+    if (typeof value === "string")
+        return value.trim().length > 0 ? [value.trim()] : [];
+    if (Array.isArray(value)) {
+        return value.map((item) => String(item).trim()).filter((s) => s.length > 0);
+    }
+    return [];
+}
+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 parseContractSurface(body, loc) {
+    const nested = asRecord(body.contractSurface) ?? asRecord(body.contract_surface) ?? asRecord(body.contract);
+    const pathSource = nested ?? body;
+    const moduleSource = nested ?? body;
+    const pathsRaw = pathSource.paths ?? pathSource.pathGlobs ?? pathSource.path_globs ?? body.paths;
+    const moduleRaw = moduleSource.moduleIds ??
+        moduleSource.module_ids ??
+        moduleSource.modules ??
+        body.moduleIds ??
+        body.module_ids;
+    // Shorthand: contractSurface / contract_surface as a string list of paths.
+    const shorthand = body.contractSurface ?? body.contract_surface ?? body.contract;
+    const paths = [...asStrList(pathsRaw), ...(nested === null ? asStrList(shorthand) : [])];
+    const moduleIds = asStrList(moduleRaw);
+    if (paths.length === 0 && moduleIds.length === 0) {
+        return {
+            surface: null,
+            errors: [
+                `${loc}: contract surface requires paths[] and/or moduleIds[] ` +
+                    `(must-not-break module/contract)`,
+            ],
+        };
+    }
+    return {
+        surface: { paths, moduleIds },
+        errors: [],
+    };
+}
+/** Parse a raw projectInvariants value. Absent/null → empty list, no errors. */
+export function parseProjectInvariants(raw) {
+    if (raw === null || raw === undefined) {
+        return { invariants: EMPTY, errors: [] };
+    }
+    if (!Array.isArray(raw)) {
+        return {
+            invariants: EMPTY,
+            errors: [`${FIELD_PROJECT_INVARIANTS} must be an array; got ${pythonTypeName(raw)}`],
+        };
+    }
+    const invariants = [];
+    const errors = [];
+    const seen = new Set();
+    for (let i = 0; i < raw.length; i += 1) {
+        const loc = `${FIELD_PROJECT_INVARIANTS}[${i}]`;
+        const item = raw[i];
+        const rec = asRecord(item);
+        if (rec === null) {
+            errors.push(`${loc}: entry must be an object`);
+            continue;
+        }
+        const id = rec.id;
+        const statement = rec.statement ?? rec.Statement;
+        if (!isNonEmptyString(id)) {
+            errors.push(`${loc}: id is required`);
+            continue;
+        }
+        const trimmedId = id.trim();
+        if (seen.has(trimmedId)) {
+            errors.push(`${loc}: duplicate id '${trimmedId}'`);
+            continue;
+        }
+        if (!isNonEmptyString(statement)) {
+            errors.push(`${loc}: statement is required`);
+            continue;
+        }
+        const { surface, errors: surfaceErrors } = parseContractSurface(rec, loc);
+        errors.push(...surfaceErrors);
+        if (surface === null)
+            continue;
+        seen.add(trimmedId);
+        invariants.push({
+            id: trimmedId,
+            statement: String(statement).trim(),
+            contractSurface: surface,
+        });
+    }
+    return { invariants, errors };
+}
+/**
+ * Map codeStructure.modules[] id → pathGlobs for applicability intersection.
+ * Pure: pass PROJECT-DEFINITION (or plan) data, no disk IO.
+ */
+export function extractModulePathGlobs(projectDefinition) {
+    const root = asRecord(projectDefinition);
+    if (root === null)
+        return {};
+    const plan = asRecord(root.plan) ?? root;
+    const architecture = asRecord(plan.architecture);
+    if (architecture === null)
+        return {};
+    const codeStructure = asRecord(architecture.codeStructure ?? architecture.code_structure);
+    if (codeStructure === null)
+        return {};
+    const modules = codeStructure.modules;
+    if (!Array.isArray(modules))
+        return {};
+    const out = {};
+    for (const item of modules) {
+        const rec = asRecord(item);
+        if (rec === null || !isNonEmptyString(rec.id))
+            continue;
+        const globs = asStrList(rec.pathGlobs ?? rec.path_globs ?? rec.paths);
+        if (globs.length === 0)
+            continue;
+        out[rec.id.trim()] = globs;
+    }
+    return out;
+}
+function readPolicyBlock(data) {
+    if (data === null)
+        return null;
+    const policy = readPlanPolicy(data.plan);
+    return asRecord(policy);
+}
+/**
+ * Resolve projectInvariants from PROJECT-DEFINITION data already in memory.
+ * Absent/null → default empty. Present invalid → default-on-error + message.
+ */
+export function resolveProjectInvariantsFromData(data) {
+    const policy = readPolicyBlock(data);
+    if (policy === null || !("projectInvariants" in policy)) {
+        return { invariants: EMPTY, source: "default", error: null };
+    }
+    const raw = policy.projectInvariants;
+    if (raw === null) {
+        return { invariants: EMPTY, source: "default", error: null };
+    }
+    const parsed = parseProjectInvariants(raw);
+    if (parsed.errors.length > 0) {
+        return {
+            invariants: EMPTY,
+            source: "default-on-error",
+            error: parsed.errors.join("; "),
+        };
+    }
+    return { invariants: parsed.invariants, source: "typed", error: null };
+}
+/** Resolve from a project root via the PROJECT-DEFINITION IO path. */
+export function resolveProjectInvariants(projectRoot) {
+    const [data, err] = loadProjectDefinition(projectRoot);
+    if (data === null) {
+        return { invariants: EMPTY, source: "default", error: err };
+    }
+    return resolveProjectInvariantsFromData(data);
+}
+/** Inspector row for `task policy:show --field=projectInvariants`. */
+export function inspectProjectInvariants(data, projectRoot) {
+    const resolved = data !== null
+        ? resolveProjectInvariantsFromData(data)
+        : projectRoot !== undefined && projectRoot.length > 0
+            ? resolveProjectInvariants(projectRoot)
+            : { invariants: EMPTY, source: "default", error: null };
+    return {
+        name: FIELD_PROJECT_INVARIANTS,
+        current: resolved.invariants,
+        default: EMPTY,
+        source: resolved.source,
+    };
+}
+//# sourceMappingURL=project-invariants.js.map