@deftai/directive-core 0.103.0 → 0.105.0

package/dist/policy/branch-sync.js

@@ -0,0 +1,211 @@
+/**
+ * Shared branch-sync detector (#3388 / #3377 Wave 1).
+ *
+ * Dest = deliveryBranch. Source = typed baseBranch (unset equals dest → not a
+ * sync). Predicate: PR base is dest AND head is already on origin/<source>
+ * after fetch (tip or ancestor). Name-only and label-only exemptions are not
+ * implemented. origin/develop is never load-bearing identity.
+ *
+ * This module is the only is-this-a-sync source for later children (#3390/#3391)
+ * and for core-guard.
+ */
+import { defaultGitRunner, gitIsAncestor } from "../session/git.js";
+import { ORIGIN_DEVELOP_HINT } from "./base-branch.js";
+import { resolveGitDefaultDeliveryBranch } from "./delivery-branch.js";
+import { readPlanPolicy } from "./plan-extensions.js";
+/** Dest-ref blob used for dest/source. Never the PR working tree (#3388 P1). */
+export const BRANCH_SYNC_POLICY_BLOB = "xbrief/PROJECT-DEFINITION.xbrief.json";
+export const BRANCH_SYNC_EXEMPTION_PREFIX = "sync PR detected: all commits already guard-checked on";
+export function formatBranchSyncExemptionMessage(integrationBranch) {
+    return `${BRANCH_SYNC_EXEMPTION_PREFIX} ${integrationBranch}`;
+}
+function notSync(input, reason) {
+    return {
+        isSync: false,
+        dest: input.dest,
+        source: input.source,
+        sourceTyped: input.sourceTyped,
+        reason,
+        message: "",
+        developHint: input.developHint ?? null,
+    };
+}
+/**
+ * Evidence-based sync predicate (#3388 Q3). Fetch first. Do not trust PR
+ * branch names or labels.
+ */
+export function detectBranchSync(input) {
+    const dest = input.dest.trim();
+    const source = input.source.trim();
+    if (source.length === 0 || dest.length === 0 || source === dest) {
+        return notSync({ ...input, dest, source }, "source-equals-dest");
+    }
+    if (input.prBase.trim() !== dest) {
+        return notSync({ ...input, dest, source }, "base-is-not-dest");
+    }
+    const runGit = input.runGit ?? defaultGitRunner;
+    const fetched = runGit(input.projectRoot, ["fetch", "--quiet", "origin", source]);
+    if (fetched.code !== 0) {
+        return notSync({ ...input, dest, source }, "fetch-failed");
+    }
+    const onIntegration = gitIsAncestor(input.projectRoot, input.headSha, `origin/${source}`, runGit);
+    if (onIntegration !== true) {
+        return notSync({ ...input, dest, source }, "head-not-on-integration");
+    }
+    return {
+        isSync: true,
+        dest,
+        source,
+        sourceTyped: input.sourceTyped,
+        reason: "sync",
+        message: formatBranchSyncExemptionMessage(source),
+        developHint: input.developHint ?? null,
+    };
+}
+function parseTypedPolicyBranches(jsonText) {
+    try {
+        const data = JSON.parse(jsonText);
+        if (typeof data !== "object" || data === null || Array.isArray(data)) {
+            return { dest: null, source: null };
+        }
+        const policyBlock = readPlanPolicy(data.plan);
+        if (typeof policyBlock !== "object" || policyBlock === null || Array.isArray(policyBlock)) {
+            return { dest: null, source: null };
+        }
+        const rec = policyBlock;
+        const destRaw = rec.deliveryBranch;
+        const sourceRaw = rec.baseBranch;
+        return {
+            dest: typeof destRaw === "string" && destRaw.trim().length > 0 ? destRaw.trim() : null,
+            source: typeof sourceRaw === "string" && sourceRaw.trim().length > 0 ? sourceRaw.trim() : null,
+        };
+    }
+    catch {
+        return { dest: null, source: null };
+    }
+}
+/**
+ * Load dest/source from origin/<prBase>, not the PR checkout.
+ *
+ * A feature PR that rewrites working-tree baseBranch cannot become a sync.
+ */
+export function resolveSyncPolicyFromDestRef(options) {
+    const runGit = options.runGit ?? defaultGitRunner;
+    const prBase = options.prBase.trim();
+    const fetched = runGit(options.projectRoot, ["fetch", "--quiet", "origin", prBase]);
+    if (fetched.code !== 0) {
+        const dest = resolveGitDefaultDeliveryBranch(options.projectRoot, runGit);
+        const developHint = runGit(options.projectRoot, [
+            "show-ref",
+            "--verify",
+            "--quiet",
+            "refs/remotes/origin/develop",
+        ]).code === 0
+            ? ORIGIN_DEVELOP_HINT
+            : null;
+        return { dest, source: dest, sourceTyped: false, developHint };
+    }
+    const shown = runGit(options.projectRoot, [
+        "show",
+        `origin/${prBase}:${BRANCH_SYNC_POLICY_BLOB}`,
+    ]);
+    const parsed = shown.code === 0 && shown.stdout.length > 0
+        ? parseTypedPolicyBranches(shown.stdout)
+        : { dest: null, source: null };
+    const dest = parsed.dest ?? resolveGitDefaultDeliveryBranch(options.projectRoot, runGit);
+    const sourceTyped = parsed.source !== null;
+    const source = parsed.source ?? dest;
+    const developHint = sourceTyped ||
+        runGit(options.projectRoot, ["show-ref", "--verify", "--quiet", "refs/remotes/origin/develop"])
+            .code !== 0
+        ? null
+        : ORIGIN_DEVELOP_HINT;
+    return { dest, source, sourceTyped, developHint };
+}
+/** Load dest/source from dest-ref policy, then run {@link detectBranchSync}. */
+export function detectBranchSyncFromProject(options) {
+    const runGit = options.runGit ?? defaultGitRunner;
+    const policy = resolveSyncPolicyFromDestRef({
+        projectRoot: options.projectRoot,
+        prBase: options.prBase,
+        runGit,
+    });
+    return detectBranchSync({
+        dest: policy.dest,
+        source: policy.source,
+        sourceTyped: policy.sourceTyped,
+        prBase: options.prBase,
+        headSha: options.headSha,
+        projectRoot: options.projectRoot,
+        developHint: policy.developHint,
+        runGit,
+    });
+}
+/**
+ * Core-guard mix result after the shared sync predicate. Sync PRs pass
+ * loudly; mixed feature PRs still fail.
+ */
+export function applyCoreGuardWithBranchSync(classification, sync) {
+    if (!classification.wouldFail) {
+        return { wouldFail: false, loudMessage: null };
+    }
+    if (sync.isSync) {
+        return { wouldFail: false, loudMessage: formatBranchSyncExemptionMessage(sync.source) };
+    }
+    return { wouldFail: true, loudMessage: null };
+}
+/** Compact Python body for the deposited deft-core-guard (#3388). */
+export function coreGuardBranchSyncPythonBody() {
+    return [
+        "import json, subprocess, sys",
+        "head_sha, pr_base = sys.argv[1], sys.argv[2]",
+        "def git(*a):",
+        "    return subprocess.run(['git', *a], capture_output=True, text=True)",
+        "dest = source = None",
+        "if git('fetch', '--quiet', 'origin', pr_base).returncode != 0: sys.exit(1)",
+        `shown = git('show', 'origin/' + pr_base + ':${BRANCH_SYNC_POLICY_BLOB}')`,
+        "if shown.returncode == 0:",
+        "    try:",
+        "        plan = json.loads(shown.stdout).get('plan')",
+        "    except Exception:",
+        "        plan = None",
+        "    if isinstance(plan, dict):",
+        "        pol = plan.get('x-directive/policy') or plan.get('policy') or {}",
+        "        if isinstance(pol, dict):",
+        "            d, s = pol.get('deliveryBranch'), pol.get('baseBranch')",
+        "            if isinstance(d, str) and d.strip(): dest = d.strip()",
+        "            if isinstance(s, str) and s.strip(): source = s.strip()",
+        "if not dest:",
+        "    r = git('symbolic-ref', 'refs/remotes/origin/HEAD', '--short')",
+        "    if r.returncode == 0 and r.stdout.strip():",
+        "        dest = r.stdout.strip().split('/', 1)[-1]",
+        "    else:",
+        "        for n in ('main', 'master'):",
+        "            if git('show-ref', '--verify', '--quiet', 'refs/remotes/origin/' + n).returncode == 0:",
+        "                dest = n",
+        "                break",
+        "        if not dest:",
+        "            for n in ('main', 'master'):",
+        "                if git('show-ref', '--verify', '--quiet', 'refs/heads/' + n).returncode == 0:",
+        "                    dest = n",
+        "                    break",
+        "        if not dest: dest = 'master'",
+        "if not source: source = dest",
+        "if source == dest or pr_base != dest: sys.exit(1)",
+        "if git('fetch', '--quiet', 'origin', source).returncode != 0: sys.exit(1)",
+        "if git('merge-base', '--is-ancestor', head_sha, 'origin/' + source).returncode != 0: sys.exit(1)",
+        `print('${BRANCH_SYNC_EXEMPTION_PREFIX} ' + source)`,
+    ];
+}
+/** Indented `if` block: detector success exits 0 (loud print); else fall through. */
+export function renderCoreGuardBranchSyncIfBlock(indent) {
+    return [
+        `${indent}if python3 - "$HEAD_SHA" "$BASE_REF" <<'PY'`,
+        ...coreGuardBranchSyncPythonBody().map((line) => `${indent}${line}`),
+        `${indent}PY`,
+        `${indent}then`,
+        `${indent}  exit 0`,
+        `${indent}fi`,
+    ].join("\n");
+}
+//# sourceMappingURL=branch-sync.js.map

package/dist/policy/ceremony-dial-escalation.js

@@ -77,6 +77,7 @@ export function emitCeremonyDialEscalationEvaluation(options) {
             projectRoot: options.projectRoot,
             sessionId: options.sessionId,
             env: options.env,
+            component: "ceremony-dial",
         });
         emitter.emitDialEscalationEvaluation({
             tier: options.evaluation.tier,

package/dist/policy/ceremony-dial.js

@@ -990,12 +990,6 @@ export function escalateCeremonyDial(projectRoot, options) {
             return;
         }
         try {
-            const audit = readCeremonyDialAudit(projectRoot);
-            const rawSid = audit.raw?.session_id;
-            const sid = options.sessionId ??
-                (typeof rawSid === "string" && rawSid.length > 0
-                    ? rawSid
-                    : `dial-${Date.now().toString(36)}`);
             const rank = {
                 minimal: 0,
                 rapid: 1,
@@ -1012,8 +1006,9 @@ export function escalateCeremonyDial(projectRoot, options) {
                 : baseReason;
             const emitter = new RunSummaryEmitter({
                 projectRoot,
-                sessionId: sid,
+                sessionId: options.sessionId,
                 env: options.env,
+                component: "ceremony-dial",
             });
             emitter.emitDialEscalationEvaluation({
                 tier: outcome === "escalated" ? options.to : from,
@@ -1065,16 +1060,11 @@ export function escalateCeremonyDial(projectRoot, options) {
     // #3282: event-driven dial_transition line (fail-open).
     if (options.emitRunSummary !== false) {
         try {
-            const audit = readCeremonyDialAudit(projectRoot);
-            const rawSid = audit.raw?.session_id;
-            const sid = options.sessionId ??
-                (typeof rawSid === "string" && rawSid.length > 0
-                    ? rawSid
-                    : `dial-${Date.now().toString(36)}`);
             const emitter = new RunSummaryEmitter({
                 projectRoot,
-                sessionId: sid,
+                sessionId: options.sessionId,
                 env: options.env,
+                component: "ceremony-dial",
             });
             emitter.emitDialTransition({
                 from,

package/dist/policy/delivery-branch.d.ts

@@ -1,9 +1,9 @@
 /**
  * Typed plan.policy.deliveryBranch (#3041).
  *
- * Distinct from swarm/PR `baseBranch` (integration target for PRs / finalize
- * sweep PRs). deliveryBranch is where shipped work must land for a delivered
- * completion disposition.
+ * Distinct from typed `plan.policy.baseBranch` (#3388), the integration-branch
+ * source for the shared branch-sync detector. deliveryBranch is dest: where
+ * shipped work must land for a delivered completion disposition.
  */
 import { type GitRunner } from "../session/git.js";
 export declare const FIELD_DELIVERY_BRANCH = "plan.policy.deliveryBranch";
@@ -16,6 +16,8 @@ export interface DeliveryBranchResult {
     readonly source: DeliveryBranchSource;
     readonly error: string | null;
 }
+/** Git-only dest when dest-ref policy has no typed deliveryBranch (#3388). */
+export declare function resolveGitDefaultDeliveryBranch(projectRoot: string, runGit?: GitRunner): string;
 /**
  * Resolve the project's delivery branch (#3041).
  *

package/dist/policy/delivery-branch.js

@@ -1,9 +1,9 @@
 /**
  * Typed plan.policy.deliveryBranch (#3041).
  *
- * Distinct from swarm/PR `baseBranch` (integration target for PRs / finalize
- * sweep PRs). deliveryBranch is where shipped work must land for a delivered
- * completion disposition.
+ * Distinct from typed `plan.policy.baseBranch` (#3388), the integration-branch
+ * source for the shared branch-sync detector. deliveryBranch is dest: where
+ * shipped work must land for a delivered completion disposition.
  */
 import { defaultGitRunner } from "../session/git.js";
 import { readPlanPolicy } from "./plan-extensions.js";
@@ -50,6 +50,10 @@ function defaultBranchCandidates(projectRoot, runGit) {
     }
     return candidates;
 }
+/** Git-only dest when dest-ref policy has no typed deliveryBranch (#3388). */
+export function resolveGitDefaultDeliveryBranch(projectRoot, runGit = defaultGitRunner) {
+    return defaultBranchCandidates(projectRoot, runGit)[0] ?? DEFAULT_DELIVERY_BRANCH_FALLBACK;
+}
 /**
  * Resolve the project's delivery branch (#3041).
  *

package/dist/policy/file-size-thresholds.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Single machine-readable source of truth for per-file size guidance (#3424).
+ *
+ * `coding.md` and companion prose MUST reference these exports. They are
+ * review / planning triggers, not a hard line cap (#1488).
+ */
+/** Preferred size for a focused file. */
+export declare const FILE_SIZE_IDEAL_LINES = 300;
+/** Recommended upper bound before a file should be treated as large. */
+export declare const FILE_SIZE_RECOMMENDED_LINES = 500;
+/**
+ * Review-trigger line count. A declared file at or above this size cannot
+ * pass preflight without a recorded split plan or cohesion exemption.
+ * Size alone is never a fail-closed reject.
+ */
+export declare const FILE_SIZE_REVIEW_TRIGGER_LINES = 1000;
+/** Canonical bundle so callers do not restate the three numbers. */
+export declare const FILE_SIZE_THRESHOLDS: {
+    readonly idealLines: 300;
+    readonly recommendedLines: 500;
+    readonly reviewTriggerLines: 1000;
+};
+export type FileSizeThresholds = typeof FILE_SIZE_THRESHOLDS;
+//# sourceMappingURL=file-size-thresholds.d.ts.map

package/dist/policy/file-size-thresholds.js

@@ -0,0 +1,23 @@
+/**
+ * Single machine-readable source of truth for per-file size guidance (#3424).
+ *
+ * `coding.md` and companion prose MUST reference these exports. They are
+ * review / planning triggers, not a hard line cap (#1488).
+ */
+/** Preferred size for a focused file. */
+export const FILE_SIZE_IDEAL_LINES = 300;
+/** Recommended upper bound before a file should be treated as large. */
+export const FILE_SIZE_RECOMMENDED_LINES = 500;
+/**
+ * Review-trigger line count. A declared file at or above this size cannot
+ * pass preflight without a recorded split plan or cohesion exemption.
+ * Size alone is never a fail-closed reject.
+ */
+export const FILE_SIZE_REVIEW_TRIGGER_LINES = 1000;
+/** Canonical bundle so callers do not restate the three numbers. */
+export const FILE_SIZE_THRESHOLDS = {
+    idealLines: FILE_SIZE_IDEAL_LINES,
+    recommendedLines: FILE_SIZE_RECOMMENDED_LINES,
+    reviewTriggerLines: FILE_SIZE_REVIEW_TRIGGER_LINES,
+};
+//# sourceMappingURL=file-size-thresholds.js.map

package/dist/policy/forge-outage-retry.d.ts

@@ -0,0 +1,47 @@
+/**
+ * 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.
+ */
+export declare const FIELD_FORGE_OUTAGE_RETRY_MINUTES = "plan.policy.forgeOutageRetryMinutes";
+export declare const FIELD_FORGE_OUTAGE_RETRY_MINUTES_CLI_ALIAS = "forgeOutageRetryMinutes";
+export declare const DEFAULT_FORGE_OUTAGE_RETRY_MINUTES = 30;
+export declare const MIN_FORGE_OUTAGE_RETRY_MINUTES = 5;
+export type ForgeOutageRetrySource = "user-md" | "typed" | "default" | "default-on-error";
+export interface ForgeOutageRetryResolved {
+    readonly minutes: number;
+    readonly source: ForgeOutageRetrySource;
+    readonly error: string | null;
+}
+export interface ForgeOutageRetryPolicyField {
+    readonly name: typeof FIELD_FORGE_OUTAGE_RETRY_MINUTES;
+    readonly current: number;
+    readonly default: number;
+    readonly source: string;
+}
+export interface ResolveForgeOutageRetryOptions {
+    readonly projectRoot?: string | null;
+    readonly env?: NodeJS.ProcessEnv;
+    readonly userMdText?: string | null;
+}
+/** Validate a raw integer-minutes value. */
+export declare function validateForgeOutageRetryMinutes(raw: unknown): string | null;
+/**
+ * Parse USER.md Personal forge-outage retry minutes.
+ *
+ * Accepts `forgeOutageRetryMinutes: 15` or `Forge outage retry: 15m`.
+ */
+export declare function parseForgeOutageRetryMinutesFromUserMd(text: string): number | null;
+/**
+ * Resolve forge-outage re-probe minutes (#3422).
+ *
+ * 1. Valid USER.md Personal value
+ * 2. Valid plan.policy.forgeOutageRetryMinutes
+ * 3. Framework default 30
+ */
+export declare function resolveForgeOutageRetryMinutes(options?: ResolveForgeOutageRetryOptions): ForgeOutageRetryResolved;
+/** Inspector row for `task policy:show --field=forgeOutageRetryMinutes`. */
+export declare function inspectForgeOutageRetryMinutes(_data: Record<string, unknown> | null, projectRoot?: string): ForgeOutageRetryPolicyField;
+//# sourceMappingURL=forge-outage-retry.d.ts.map

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";