@deftai/directive-core 0.104.0 → 0.105.0

package/dist/policy/sync-max-files.js

@@ -0,0 +1,192 @@
+/**
+ * Typed plan.policy.syncMaxFiles (#3390 / #3377 Wave 2).
+ *
+ * One integer. Unset is 400. `--max-files` overrides one run and does not
+ * write policy. Set 100 if SLizard is a required check. Do not probe
+ * reviewer APIs and do not encode vendor limits as code constants.
+ *
+ * File-count warn uses the shared #3388 detector. Count is
+ * `git diff --name-only origin/<dest>...origin/<source>`. No warn when
+ * the detector says this is not a sync. The #3391 verb consumes
+ * evaluateSyncMaxFilesWarn and the maxFiles one-run override.
+ */
+import { defaultGitRunner } from "../session/git.js";
+import { detectBranchSyncFromProject } from "./branch-sync.js";
+import { readPlanPolicy } from "./plan-extensions.js";
+import { loadProjectDefinition } from "./resolve.js";
+export const FIELD_SYNC_MAX_FILES = "plan.policy.syncMaxFiles";
+export const FIELD_SYNC_MAX_FILES_CLI_ALIAS = "syncMaxFiles";
+/** Unset threshold. Not a vendor limit. */
+export const DEFAULT_SYNC_MAX_FILES = 400;
+/**
+ * Operator docs for the threshold. Recommendation only — not a coded
+ * Greptile or SLizard constant.
+ */
+export const SYNC_MAX_FILES_DOCS = "Unset is 400. Set plan.policy.syncMaxFiles to 100 if SLizard is a required check.";
+function isValidMaxFiles(raw) {
+    return typeof raw === "number" && Number.isInteger(raw) && raw >= 0;
+}
+/** Parse `--max-files`. Invalid or absent values are ignored. */
+export function parseMaxFilesFlag(raw) {
+    if (!isValidMaxFiles(raw))
+        return null;
+    return raw;
+}
+/**
+ * Resolve the file-count threshold.
+ *
+ * `--max-files` (maxFiles) wins for this call only and is never written.
+ */
+export function resolveSyncMaxFiles(projectRoot, maxFiles) {
+    const flag = parseMaxFilesFlag(maxFiles);
+    if (flag !== null) {
+        return {
+            maxFiles: flag,
+            source: "flag",
+            provenance: "flag",
+            error: null,
+        };
+    }
+    if (projectRoot !== undefined && projectRoot !== null && projectRoot.length > 0) {
+        const [data, err] = loadProjectDefinition(projectRoot);
+        if (data !== null) {
+            const policyBlock = readPlanPolicy(data.plan);
+            if (typeof policyBlock === "object" &&
+                policyBlock !== null &&
+                !Array.isArray(policyBlock) &&
+                "syncMaxFiles" in policyBlock) {
+                const raw = policyBlock.syncMaxFiles;
+                if (isValidMaxFiles(raw)) {
+                    return {
+                        maxFiles: raw,
+                        source: "typed",
+                        provenance: "policy",
+                        error: null,
+                    };
+                }
+                return {
+                    maxFiles: DEFAULT_SYNC_MAX_FILES,
+                    source: "default-on-error",
+                    provenance: "default",
+                    error: `${FIELD_SYNC_MAX_FILES} must be a non-negative integer; got ${String(raw)}`,
+                };
+            }
+        }
+        else if (err !== null && err.length > 0) {
+            return {
+                maxFiles: DEFAULT_SYNC_MAX_FILES,
+                source: "default",
+                provenance: "default",
+                error: err,
+            };
+        }
+    }
+    return {
+        maxFiles: DEFAULT_SYNC_MAX_FILES,
+        source: "default",
+        provenance: "default",
+        error: null,
+    };
+}
+/** Inspector row for `task policy:show --field=syncMaxFiles`. */
+export function inspectSyncMaxFiles(_data, projectRoot) {
+    const resolved = resolveSyncMaxFiles(projectRoot);
+    return {
+        name: FIELD_SYNC_MAX_FILES,
+        current: resolved.maxFiles,
+        default: DEFAULT_SYNC_MAX_FILES,
+        source: resolved.source === "flag" ? "default" : resolved.source,
+    };
+}
+/** Count files in `origin/<dest>...origin/<source>`. */
+export function countSyncChangedFiles(options) {
+    const dest = options.dest.trim();
+    const source = options.source.trim();
+    if (dest.length === 0 || source.length === 0) {
+        return { count: null, error: "empty dest or source" };
+    }
+    const runGit = options.runGit ?? defaultGitRunner;
+    runGit(options.projectRoot, ["fetch", "--quiet", "origin", dest]);
+    const ranged = `origin/${dest}...origin/${source}`;
+    const diffed = runGit(options.projectRoot, ["diff", "--name-only", ranged]);
+    if (diffed.code !== 0) {
+        return { count: null, error: diffed.stderr || `git diff failed for ${ranged}` };
+    }
+    const files = diffed.stdout.split(/\r?\n/).filter((line) => line.trim().length > 0);
+    return { count: files.length, error: null };
+}
+export function formatSyncMaxFilesWarn(options) {
+    return (`file-count warn: ${options.count} files origin/${options.dest}...origin/${options.source} ` +
+        `exceeds syncMaxFiles=${options.threshold} (${options.provenance})`);
+}
+/**
+ * Warn when a detected sync exceeds syncMaxFiles.
+ *
+ * No warn when the shared detector says this is not a sync.
+ */
+export function evaluateSyncMaxFilesWarn(input) {
+    const runGit = input.runGit ?? defaultGitRunner;
+    const sync = input.sync ??
+        detectBranchSyncFromProject({
+            projectRoot: input.projectRoot,
+            prBase: input.prBase,
+            headSha: input.headSha,
+            runGit,
+        });
+    const resolved = resolveSyncMaxFiles(input.projectRoot, input.maxFiles);
+    const empty = {
+        warn: false,
+        reason: "not-sync",
+        count: null,
+        threshold: resolved.maxFiles,
+        provenance: resolved.provenance,
+        dest: sync.dest,
+        source: sync.source,
+        message: "",
+    };
+    if (!sync.isSync) {
+        return empty;
+    }
+    const counted = countSyncChangedFiles({
+        dest: sync.dest,
+        source: sync.source,
+        projectRoot: input.projectRoot,
+        runGit,
+    });
+    if (counted.count === null) {
+        return {
+            ...empty,
+            reason: "diff-failed",
+            message: counted.error ?? "git diff failed",
+        };
+    }
+    if (counted.count <= resolved.maxFiles) {
+        return {
+            warn: false,
+            reason: "within-limit",
+            count: counted.count,
+            threshold: resolved.maxFiles,
+            provenance: resolved.provenance,
+            dest: sync.dest,
+            source: sync.source,
+            message: "",
+        };
+    }
+    return {
+        warn: true,
+        reason: "exceeds",
+        count: counted.count,
+        threshold: resolved.maxFiles,
+        provenance: resolved.provenance,
+        dest: sync.dest,
+        source: sync.source,
+        message: formatSyncMaxFilesWarn({
+            count: counted.count,
+            threshold: resolved.maxFiles,
+            provenance: resolved.provenance,
+            dest: sync.dest,
+            source: sync.source,
+        }),
+    };
+}
+//# sourceMappingURL=sync-max-files.js.map

package/dist/pr-monitor/absent-required.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Consume #3234 `ci_absent_required` from a readiness payload.
+ * Returns missing context names, or null when the poll is not absent-required.
+ * Pending required check-runs are a wait, not an absence.
+ */
+export declare function readAbsentRequiredContexts(payload: Record<string, unknown>): readonly string[] | null;
+/** True once consecutive absent polls have passed the first-poll grace window. */
+export declare function shouldEscalateAbsentRequired(consecutivePolls: number, gracePolls?: number): boolean;
+/** Distinct exit naming that lists the missing required contexts. */
+export declare function formatAbsentRequiredMessage(contexts: readonly string[]): string;
+//# sourceMappingURL=absent-required.d.ts.map

package/dist/pr-monitor/absent-required.js

@@ -0,0 +1,61 @@
+import { ABSENT_REQUIRED_GRACE_POLLS } from "./constants.js";
+function asRecord(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    return value;
+}
+function ciFromPayload(payload) {
+    const partial = asRecord(payload.partial_data);
+    if (partial === null) {
+        return null;
+    }
+    return asRecord(partial.ci);
+}
+function stringList(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter((item) => typeof item === "string");
+}
+/**
+ * Consume #3234 `ci_absent_required` from a readiness payload.
+ * Returns missing context names, or null when the poll is not absent-required.
+ * Pending required check-runs are a wait, not an absence.
+ */
+export function readAbsentRequiredContexts(payload) {
+    const ci = ciFromPayload(payload);
+    if (ci !== null) {
+        const pending = stringList(ci.pending_required);
+        if (pending.length > 0) {
+            return null;
+        }
+        const readyState = ci.ready_state;
+        if (readyState === "not_ready_yet") {
+            return null;
+        }
+        if (readyState === "ci_absent_required") {
+            return stringList(ci.absent_required);
+        }
+        // Structured CI present but not absent-required (e.g. ci_failures).
+        // Do not let failure-text mention of ci_absent_required override it.
+        return null;
+    }
+    const failures = Array.isArray(payload.failures) ? payload.failures.map(String) : [];
+    if (failures.some((failure) => failure.includes("ci_absent_required"))) {
+        return [];
+    }
+    return null;
+}
+/** True once consecutive absent polls have passed the first-poll grace window. */
+export function shouldEscalateAbsentRequired(consecutivePolls, gracePolls = ABSENT_REQUIRED_GRACE_POLLS) {
+    return consecutivePolls > gracePolls;
+}
+/** Distinct exit naming that lists the missing required contexts. */
+export function formatAbsentRequiredMessage(contexts) {
+    if (contexts.length === 0) {
+        return "ABSENT-REQUIRED: required status-check context never appeared";
+    }
+    return `ABSENT-REQUIRED: ${contexts.join(", ")}`;
+}
+//# sourceMappingURL=absent-required.js.map

package/dist/pr-monitor/constants.d.ts

@@ -3,6 +3,13 @@ export declare const EXIT_CLEAN = 0;
 export declare const EXIT_CAP_REACHED = 1;
 export declare const EXIT_CONFIG_ERROR = 2;
 export declare const EXIT_PR_TERMINAL = 3;
+/** Sustained required-context absence (#3389). Distinct from CAP-REACHED. */
+export declare const EXIT_ABSENT_REQUIRED = 4;
+/**
+ * First-poll absence is normal (check-runs take time after a head push).
+ * Escalate on the next consecutive `ci_absent_required` poll (#3389).
+ */
+export declare const ABSENT_REQUIRED_GRACE_POLLS = 1;
 /** Adaptive cadence (seconds, repeats). Last repeat is a soft ceiling. */
 export declare const DEFAULT_CADENCE: ReadonlyArray<readonly [number, number]>;
 //# sourceMappingURL=constants.d.ts.map

package/dist/pr-monitor/constants.js

@@ -3,6 +3,13 @@ export const EXIT_CLEAN = 0;
 export const EXIT_CAP_REACHED = 1;
 export const EXIT_CONFIG_ERROR = 2;
 export const EXIT_PR_TERMINAL = 3;
+/** Sustained required-context absence (#3389). Distinct from CAP-REACHED. */
+export const EXIT_ABSENT_REQUIRED = 4;
+/**
+ * First-poll absence is normal (check-runs take time after a head push).
+ * Escalate on the next consecutive `ci_absent_required` poll (#3389).
+ */
+export const ABSENT_REQUIRED_GRACE_POLLS = 1;
 /** Adaptive cadence (seconds, repeats). Last repeat is a soft ceiling. */
 export const DEFAULT_CADENCE = [
     [60, 3],

package/dist/pr-monitor/index.d.ts

@@ -1,5 +1,6 @@
+export { formatAbsentRequiredMessage, readAbsentRequiredContexts, shouldEscalateAbsentRequired, } from "./absent-required.js";
 export { cadenceIntervalAfterPoll, cadenceIntervals } from "./cadence.js";
-export { DEFAULT_CADENCE, EXIT_CAP_REACHED, EXIT_CLEAN, EXIT_CONFIG_ERROR, EXIT_PR_TERMINAL, } from "./constants.js";
+export { ABSENT_REQUIRED_GRACE_POLLS, DEFAULT_CADENCE, EXIT_ABSENT_REQUIRED, EXIT_CAP_REACHED, EXIT_CLEAN, EXIT_CONFIG_ERROR, EXIT_PR_TERMINAL, } from "./constants.js";
 export { cmdPrMonitor, parseMonitorArgs, runMonitor } from "./main.js";
 export { formatPollStatus, isTerminalPrState, mergeStateFromPayload, monitor, summaryLabelForExit, } from "./monitor.js";
 export { callReadiness } from "./readiness.js";

package/dist/pr-monitor/index.js

@@ -1,5 +1,6 @@
+export { formatAbsentRequiredMessage, readAbsentRequiredContexts, shouldEscalateAbsentRequired, } from "./absent-required.js";
 export { cadenceIntervalAfterPoll, cadenceIntervals } from "./cadence.js";
-export { DEFAULT_CADENCE, EXIT_CAP_REACHED, EXIT_CLEAN, EXIT_CONFIG_ERROR, EXIT_PR_TERMINAL, } from "./constants.js";
+export { ABSENT_REQUIRED_GRACE_POLLS, DEFAULT_CADENCE, EXIT_ABSENT_REQUIRED, EXIT_CAP_REACHED, EXIT_CLEAN, EXIT_CONFIG_ERROR, EXIT_PR_TERMINAL, } from "./constants.js";
 export { cmdPrMonitor, parseMonitorArgs, runMonitor } from "./main.js";
 export { formatPollStatus, isTerminalPrState, mergeStateFromPayload, monitor, summaryLabelForExit, } from "./monitor.js";
 export { callReadiness } from "./readiness.js";

package/dist/pr-monitor/main.js

@@ -183,6 +183,10 @@ export function runMonitor(argv, options = {}) {
         if (typeof err === "string" && err.length > 0) {
             lines.push(`  error: ${err}`);
         }
+        const missingRaw = payload.monitor_absent_required;
+        if (Array.isArray(missingRaw) && missingRaw.length > 0) {
+            lines.push(`  missing: ${missingRaw.map(String).join(", ")}`);
+        }
         const failuresRaw = payload.failures;
         if (Array.isArray(failuresRaw)) {
             failuresRaw.forEach((fail, index) => {

package/dist/pr-monitor/monitor.js

@@ -1,5 +1,6 @@
+import { formatAbsentRequiredMessage, readAbsentRequiredContexts, shouldEscalateAbsentRequired, } from "./absent-required.js";
 import { cadenceIntervalAfterPoll, cadenceIntervals } from "./cadence.js";
-import { DEFAULT_CADENCE, EXIT_CAP_REACHED, EXIT_CLEAN, EXIT_CONFIG_ERROR, EXIT_PR_TERMINAL, } from "./constants.js";
+import { DEFAULT_CADENCE, EXIT_ABSENT_REQUIRED, EXIT_CAP_REACHED, EXIT_CLEAN, EXIT_CONFIG_ERROR, EXIT_PR_TERMINAL, } from "./constants.js";
 import { callReadiness } from "./readiness.js";
 const systemMonotonicClock = {
     now() {
@@ -141,6 +142,7 @@ export function monitor(prNumber, repo, options = {}) {
     let lastPayload = {};
     let lastExit = EXIT_CAP_REACHED;
     let priorCadenceSeconds = cadenceIntervalAfterPoll(1, cadence);
+    let consecutiveAbsentRequired = 0;
     while (true) {
         pollIndex += 1;
         if (pollIndex > maxPolls) {
@@ -166,6 +168,25 @@ export function monitor(prNumber, repo, options = {}) {
         if (isTerminalPrState(lastPayload)) {
             return { exitCode: EXIT_PR_TERMINAL, payload: lastPayload, pollCount: pollIndex };
         }
+        const absentContexts = readAbsentRequiredContexts(lastPayload);
+        if (absentContexts !== null) {
+            consecutiveAbsentRequired += 1;
+            if (shouldEscalateAbsentRequired(consecutiveAbsentRequired)) {
+                const message = formatAbsentRequiredMessage(absentContexts);
+                process.stderr.write(`[monitor_pr] ${message}\n`);
+                return {
+                    exitCode: EXIT_ABSENT_REQUIRED,
+                    payload: {
+                        ...lastPayload,
+                        monitor_absent_required: [...absentContexts],
+                    },
+                    pollCount: pollIndex,
+                };
+            }
+        }
+        else {
+            consecutiveAbsentRequired = 0;
+        }
         const elapsedAfterPoll = clockFn.now() - startedAt;
         const remaining = capSeconds - elapsedAfterPoll;
         if (remaining <= 0) {
@@ -187,6 +208,8 @@ export const summaryLabelForExit = (exitCode) => {
             return "PR-TERMINAL";
         case EXIT_CONFIG_ERROR:
             return "CONFIG-ERROR";
+        case EXIT_ABSENT_REQUIRED:
+            return "ABSENT-REQUIRED";
         default:
             return "UNKNOWN";
     }

package/dist/pr-wait-mergeable/classify.js

@@ -9,11 +9,17 @@ export function classifyMonitorOutcome(monitorReturncode, monitorPayload) {
         if (monitorPayload.monitor_result === "CAP-REACHED") {
             return ["cap-reached", EXIT_TIMEOUT_OR_ESCALATION];
         }
+        if (monitorPayload.monitor_result === "ABSENT-REQUIRED") {
+            return ["absent-required", EXIT_TIMEOUT_OR_ESCALATION];
+        }
         return ["config-error", EXIT_CONFIG_ERROR];
     }
     if (monitorReturncode === 2) {
         return ["config-error", EXIT_CONFIG_ERROR];
     }
+    if (monitorReturncode === 4) {
+        return ["absent-required", EXIT_TIMEOUT_OR_ESCALATION];
+    }
     if (monitorReturncode === 3) {
         const readiness = typeof monitorPayload.readiness === "object" &&
             monitorPayload.readiness !== null &&

package/dist/preflight/evaluate.d.ts

@@ -23,6 +23,10 @@ export interface EvaluateOptions {
     readonly skipParentLineage?: boolean;
     /** Skip origin timestamp freshness (#3363). Default false. */
     readonly skipOriginFreshness?: boolean;
+    /** Skip project-invariant coverage (#3425). Default false. */
+    readonly skipProjectInvariants?: boolean;
+    /** Skip intended-placement size check (#3424). Default false. */
+    readonly skipIntendedPlacement?: boolean;
     /** Injected origin fetch for tests. Default: live `gh api` REST. */
     readonly fetchOriginUpdatedAt?: FetchOriginUpdatedAt;
 }

package/dist/preflight/evaluate.js

@@ -3,6 +3,8 @@ import { basename, dirname } from "node:path";
 import { evaluateIntentCeilingFromEnv } from "../policy/intent-ceiling.js";
 import { evaluateParentLineage, formatParentLineageLine, } from "../scope/parent-lineage.js";
 import { evaluateOriginFreshness, } from "../vbrief-reconcile/origin-freshness.js";
+import { evaluateIntendedPlacement, resolveProjectRootFromBrief } from "./intended-placement.js";
+import { evaluateProjectInvariantsGate, resolveProjectRootForInvariants, } from "./project-invariants-gate.js";
 /** Canonical eligibility folder — only vbrief/active/ may spawn implementation. */
 export const ACTIVE_FOLDER = "active";
 /** Canonical eligibility status — only `running` signals an active handoff. */
@@ -168,8 +170,37 @@ export function evaluate(vbriefPath, options = {}) {
             message: buildReject(path, originFreshness.message),
         };
     }
+    // #3425: fail closed when an applicable project invariant has no disposition.
+    const invariants = evaluateProjectInvariantsGate(record, {
+        projectRoot: resolveProjectRootForInvariants(path, options.projectRoot),
+        skip: options.skipProjectInvariants === true,
+    });
+    if (!invariants.ok) {
+        return {
+            exitCode: 1,
+            parentLineage: lineage,
+            message: buildReject(path, invariants.message),
+        };
+    }
+    // #3424: declared files vs review-trigger SoT. Missing field is grandfathered
+    // (warning). Inspect anomalies fail closed. Size alone is not a hard cap (#1488).
+    let placementWarning;
+    if (options.skipIntendedPlacement !== true) {
+        const projectRoot = resolveProjectRootFromBrief(path, options.projectRoot);
+        const placement = evaluateIntendedPlacement(planRecord, { projectRoot });
+        if (!placement.ok) {
+            return {
+                exitCode: 1,
+                parentLineage: lineage,
+                message: buildReject(path, placement.message),
+            };
+        }
+        if (placement.warning === true) {
+            placementWarning = placement.message;
+        }
+    }
     // Keep the historical OK line when lineage is N/A (backward-compatible tests / agents).
-    const message = lineage.applicable
+    let message = lineage.applicable
         ? `OK ${path} -- ready for implementation. parent lineage OK ` +
             `(${lineage.parent_requirement_ids.length} req IDs` +
             (lineage.negative_invariant_ids.length > 0
@@ -177,6 +208,9 @@ export function evaluate(vbriefPath, options = {}) {
                 : "") +
             `).`
         : `OK ${path} -- ready for implementation.`;
+    if (placementWarning !== undefined) {
+        message = `${message} ${placementWarning}`;
+    }
     return {
         exitCode: 0,
         parentLineage: lineage,

package/dist/preflight/index.d.ts

@@ -1,3 +1,7 @@
 export type { EvaluateOptions, EvaluateResult } from "./evaluate.js";
 export { ACTIVATE_HINT, ACTIVE_FOLDER, ELIGIBLE_LIFECYCLE_DIRS, ELIGIBLE_STATUS, emitJson, evaluate, formatActivateHint, PREFLIGHT_USAGE_HINT, } from "./evaluate.js";
+export type { IntendedPlacement, IntendedPlacementResult, ParsedIntendedPlacement, } from "./intended-placement.js";
+export { emptyIntendedPlacement, evaluateIntendedPlacement, INTENDED_PLACEMENT_GRANDFATHER_HINT, INTENDED_PLACEMENT_MISSING_HINT, INTENDED_PLACEMENT_OVER_TRIGGER_HINT, INTENDED_PLACEMENT_SCHEMA, parseIntendedPlacement, readIntendedPlacement, stampIntendedPlacement, } from "./intended-placement.js";
+export type { ProjectInvariantsGateOptions, ProjectInvariantsGateResult, } from "./project-invariants-gate.js";
+export { evaluateProjectInvariantsGate, PROJECT_INVARIANT_REMEDIATION, resolveProjectRootForInvariants, } from "./project-invariants-gate.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/preflight/index.js

@@ -1,2 +1,4 @@
 export { ACTIVATE_HINT, ACTIVE_FOLDER, ELIGIBLE_LIFECYCLE_DIRS, ELIGIBLE_STATUS, emitJson, evaluate, formatActivateHint, PREFLIGHT_USAGE_HINT, } from "./evaluate.js";
+export { emptyIntendedPlacement, evaluateIntendedPlacement, INTENDED_PLACEMENT_GRANDFATHER_HINT, INTENDED_PLACEMENT_MISSING_HINT, INTENDED_PLACEMENT_OVER_TRIGGER_HINT, INTENDED_PLACEMENT_SCHEMA, parseIntendedPlacement, readIntendedPlacement, stampIntendedPlacement, } from "./intended-placement.js";
+export { evaluateProjectInvariantsGate, PROJECT_INVARIANT_REMEDIATION, resolveProjectRootForInvariants, } from "./project-invariants-gate.js";
 //# sourceMappingURL=index.js.map

package/dist/preflight/intended-placement.d.ts

@@ -0,0 +1,62 @@
+/**
+ * xBRIEF intended-placement field + preflight check (#3424).
+ *
+ * Preflight keys on declared files vs FILE_SIZE_REVIEW_TRIGGER_LINES.
+ * Size alone is not a hard cap (#1488).
+ *
+ * ## Error policy
+ * Every anomaly on a declared file fails closed (exit 1 + remediation hint).
+ * Never throw. Never silent-skip. The only skip is first-touch `lstat` ENOENT
+ * (planned-new file — nothing to measure). If `lstat` succeeded and a later
+ * operation fails, that is an inconsistency → exit 1.
+ *
+ * ## Threat model
+ * Preflight is a quality gate the agent runs against its own declared plan
+ * in its own worktree. A concurrent local process that can swap symlinks
+ * mid-check can trivially edit the vBRIEF itself. Adversarial-local-attacker
+ * TOCTOU is a **non-goal** beyond the fd discipline below. Windows symlink
+ * creation requires elevation.
+ *
+ * ## fd discipline
+ * `lstat` rejects symlink entries outright. Resolve + containment-check once.
+ * `openSync(abs, O_RDONLY | O_NOFOLLOW)` (plain `O_RDONLY` where `O_NOFOLLOW`
+ * is undefined, i.e. Windows). `fstatSync(fd)` confirms a regular file; read
+ * from that same fd.
+ */
+export declare const INTENDED_PLACEMENT_SCHEMA: "deft.scope.intended_placement.v1";
+export declare const INTENDED_PLACEMENT_MISSING_HINT = "Record plan.metadata.intended_placement with files[] and module_boundary before implementation.";
+export declare const INTENDED_PLACEMENT_OVER_TRIGGER_HINT = "Record plan.metadata.intended_placement.split_plan or cohesion_exemption. Size alone is not a fail-closed cap (#1488 / #3424).";
+export declare const INTENDED_PLACEMENT_GRANDFATHER_HINT = "Pre-#3424 brief: intended_placement is missing (warning). Ingest now stamps the field; record files[] before new work.";
+export interface IntendedPlacement {
+    readonly schema?: string;
+    readonly files: readonly string[];
+    readonly module_boundary?: string;
+    readonly split_plan?: string;
+    readonly cohesion_exemption?: string;
+}
+export interface IntendedPlacementResult {
+    readonly ok: boolean;
+    readonly message: string;
+    /** Grandfathered missing field — evaluate stays exit 0 and surfaces this. */
+    readonly warning?: boolean;
+}
+export type ParsedIntendedPlacement = {
+    kind: "missing";
+} | {
+    kind: "malformed";
+    message: string;
+} | {
+    kind: "ok";
+    placement: IntendedPlacement;
+};
+export declare function emptyIntendedPlacement(): IntendedPlacement;
+/** Stamp a skeleton intended_placement onto plan.metadata when absent (#3424). */
+export declare function stampIntendedPlacement(plan: Record<string, unknown>): void;
+export declare function parseIntendedPlacement(plan: Record<string, unknown>): ParsedIntendedPlacement;
+export declare function readIntendedPlacement(plan: Record<string, unknown>): IntendedPlacement | null;
+export declare function countFileLines(text: string): number;
+export declare function resolveProjectRootFromBrief(briefPath: string, explicitRoot?: string): string;
+export declare function evaluateIntendedPlacement(plan: Record<string, unknown>, options: {
+    projectRoot: string;
+}): IntendedPlacementResult;
+//# sourceMappingURL=intended-placement.d.ts.map