@deftai/directive-core 0.104.0 → 0.105.0

package/dist/policy/base-branch.js

@@ -0,0 +1,114 @@
+/**
+ * Typed plan.policy.baseBranch (#3388).
+ *
+ * Integration-branch source for the shared branch-sync detector. Distinct from
+ * deliveryBranch (dest). Unset or invalid baseBranch resolves to dest so sync
+ * is a no-op. origin/develop is never identity; it may only emit a hint.
+ */
+import { defaultGitRunner } from "../session/git.js";
+import { DEFAULT_DELIVERY_BRANCH_FALLBACK, resolveDeliveryBranch } from "./delivery-branch.js";
+import { readPlanPolicy } from "./plan-extensions.js";
+import { loadProjectDefinition } from "./resolve.js";
+export const FIELD_BASE_BRANCH = "plan.policy.baseBranch";
+export const FIELD_BASE_BRANCH_CLI_ALIAS = "baseBranch";
+/** Nudge only — never used as dest or source identity (#3388 / #3377 Q1). */
+export const ORIGIN_DEVELOP_HINT = "origin/develop exists; set plan.policy.baseBranch if this repo uses an integration branch";
+function originRefExists(projectRoot, branch, runGit) {
+    const check = runGit(projectRoot, [
+        "show-ref",
+        "--verify",
+        "--quiet",
+        `refs/remotes/origin/${branch}`,
+    ]);
+    return check.code === 0;
+}
+function developHintIfEligible(projectRoot, typed, runGit) {
+    if (typed)
+        return null;
+    if (!originRefExists(projectRoot, "develop", runGit))
+        return null;
+    return ORIGIN_DEVELOP_HINT;
+}
+/**
+ * Resolve plan.policy.baseBranch (#3388).
+ *
+ * Unset or invalid values equal dest (deliveryBranch). origin/develop is never
+ * substituted as the source.
+ */
+export function resolveBaseBranch(projectRoot, runGit = defaultGitRunner) {
+    const dest = resolveDeliveryBranch(projectRoot, runGit).branch || DEFAULT_DELIVERY_BRANCH_FALLBACK;
+    const [data, err] = loadProjectDefinition(projectRoot);
+    if (data === null) {
+        return {
+            branch: dest,
+            dest,
+            source: "equals-dest",
+            typed: false,
+            error: err,
+            developHint: developHintIfEligible(projectRoot, false, runGit),
+        };
+    }
+    const plan = data.plan;
+    if (typeof plan !== "object" || plan === null || Array.isArray(plan)) {
+        return {
+            branch: dest,
+            dest,
+            source: "equals-dest",
+            typed: false,
+            error: "PROJECT-DEFINITION 'plan' is not an object",
+            developHint: developHintIfEligible(projectRoot, false, runGit),
+        };
+    }
+    const policyBlock = readPlanPolicy(plan);
+    if (typeof policyBlock === "object" &&
+        policyBlock !== null &&
+        !Array.isArray(policyBlock) &&
+        "baseBranch" in policyBlock) {
+        const raw = policyBlock.baseBranch;
+        if (typeof raw !== "string" || raw.trim().length === 0) {
+            return {
+                branch: dest,
+                dest,
+                source: "default-on-error",
+                typed: false,
+                error: `plan.policy.baseBranch must be a non-empty string; got ${typeof raw}`,
+                developHint: developHintIfEligible(projectRoot, false, runGit),
+            };
+        }
+        return {
+            branch: raw.trim(),
+            dest,
+            source: "typed",
+            typed: true,
+            error: null,
+            developHint: null,
+        };
+    }
+    return {
+        branch: dest,
+        dest,
+        source: "equals-dest",
+        typed: false,
+        error: null,
+        developHint: developHintIfEligible(projectRoot, false, runGit),
+    };
+}
+/** Inspector row for `task policy:show --field=baseBranch` (#3388). */
+export function inspectBaseBranch(_data, projectRoot) {
+    if (projectRoot === undefined || projectRoot.length === 0) {
+        return {
+            name: FIELD_BASE_BRANCH,
+            current: DEFAULT_DELIVERY_BRANCH_FALLBACK,
+            default: DEFAULT_DELIVERY_BRANCH_FALLBACK,
+            source: "equals-dest",
+        };
+    }
+    const resolved = resolveBaseBranch(projectRoot);
+    return {
+        name: FIELD_BASE_BRANCH,
+        current: resolved.branch,
+        default: resolved.dest,
+        source: resolved.source,
+    };
+}
+//# sourceMappingURL=base-branch.js.map

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

@@ -0,0 +1,80 @@
+/**
+ * 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 { type GitRunner } from "../session/git.js";
+/** Dest-ref blob used for dest/source. Never the PR working tree (#3388 P1). */
+export declare const BRANCH_SYNC_POLICY_BLOB = "xbrief/PROJECT-DEFINITION.xbrief.json";
+export declare const BRANCH_SYNC_EXEMPTION_PREFIX = "sync PR detected: all commits already guard-checked on";
+export type BranchSyncReason = "source-equals-dest" | "base-is-not-dest" | "fetch-failed" | "head-not-on-integration" | "sync";
+export interface BranchSyncDetection {
+    readonly isSync: boolean;
+    readonly dest: string;
+    readonly source: string;
+    readonly sourceTyped: boolean;
+    readonly reason: BranchSyncReason;
+    readonly message: string;
+    readonly developHint: string | null;
+}
+export interface DetectBranchSyncInput {
+    readonly dest: string;
+    readonly source: string;
+    readonly sourceTyped: boolean;
+    readonly prBase: string;
+    readonly headSha: string;
+    readonly projectRoot: string;
+    readonly developHint?: string | null;
+    readonly runGit?: GitRunner;
+}
+export declare function formatBranchSyncExemptionMessage(integrationBranch: string): string;
+/**
+ * Evidence-based sync predicate (#3388 Q3). Fetch first. Do not trust PR
+ * branch names or labels.
+ */
+export declare function detectBranchSync(input: DetectBranchSyncInput): BranchSyncDetection;
+export interface DestRefSyncPolicy {
+    readonly dest: string;
+    readonly source: string;
+    readonly sourceTyped: boolean;
+    readonly developHint: string | null;
+}
+/**
+ * Load dest/source from origin/<prBase>, not the PR checkout.
+ *
+ * A feature PR that rewrites working-tree baseBranch cannot become a sync.
+ */
+export declare function resolveSyncPolicyFromDestRef(options: {
+    readonly projectRoot: string;
+    readonly prBase: string;
+    readonly runGit?: GitRunner;
+}): DestRefSyncPolicy;
+/** Load dest/source from dest-ref policy, then run {@link detectBranchSync}. */
+export declare function detectBranchSyncFromProject(options: {
+    readonly projectRoot: string;
+    readonly prBase: string;
+    readonly headSha: string;
+    readonly runGit?: GitRunner;
+}): BranchSyncDetection;
+export interface CoreGuardSyncExemption {
+    readonly wouldFail: boolean;
+    readonly loudMessage: string | null;
+}
+/**
+ * Core-guard mix result after the shared sync predicate. Sync PRs pass
+ * loudly; mixed feature PRs still fail.
+ */
+export declare function applyCoreGuardWithBranchSync(classification: {
+    readonly wouldFail: boolean;
+}, sync: BranchSyncDetection): CoreGuardSyncExemption;
+/** Compact Python body for the deposited deft-core-guard (#3388). */
+export declare function coreGuardBranchSyncPythonBody(): readonly string[];
+/** Indented `if` block: detector success exits 0 (loud print); else fall through. */
+export declare function renderCoreGuardBranchSyncIfBlock(indent: string): string;
+//# sourceMappingURL=branch-sync.d.ts.map

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