@deftai/directive-core 0.74.0 → 0.75.0

package/dist/content-contracts/standards/_helpers.js

@@ -27,10 +27,12 @@ export function resolveContentPath(relPath) {
     return join(root, relPath);
 }
 export function readText(relPath) {
-    return readFileSync(resolveContentPath(relPath), { encoding: "utf8" });
+    return readFileSync(resolveContentPath(relPath), { encoding: "utf8" })
+        .replace(/\r\n/g, "\n")
+        .replace(/\r/g, "\n");
 }
 export function readAbs(absPath) {
-    return readFileSync(absPath, { encoding: "utf8" });
+    return readFileSync(absPath, { encoding: "utf8" }).replace(/\r\n/g, "\n").replace(/\r/g, "\n");
 }
 export function pathExists(relPath) {
     return existsSync(resolveContentPath(relPath));

package/dist/content-contracts/standards/_taskfile-helpers.d.ts

@@ -1,4 +1,6 @@
 export declare function taskYamlFiles(): string[];
+/** Normalize CRLF so Taskfile parsers do not treat lone `\r` lines as section exits (#2467). */
+export declare function normalizeYamlNewlines(text: string): string;
 export declare function iterTaskBlocks(text: string): Array<{
     name: string;
     start: number;

package/dist/content-contracts/standards/_taskfile-helpers.js

@@ -10,8 +10,12 @@ export function taskYamlFiles() {
         .map((f) => join(dir, f))
         .sort();
 }
+/** Normalize CRLF so Taskfile parsers do not treat lone `\r` lines as section exits (#2467). */
+export function normalizeYamlNewlines(text) {
+    return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
 export function iterTaskBlocks(text) {
-    const lines = text.split("\n");
+    const lines = normalizeYamlNewlines(text).split("\n");
     const taskPositions = [];
     let inTasksSection = false;
     for (let idx = 0; idx < lines.length; idx += 1) {
@@ -43,19 +47,21 @@ export function iterTaskBlocks(text) {
     return blocks;
 }
 export function blockBody(text, start, end) {
-    return text.split("\n").slice(start, end).join("\n");
+    return normalizeYamlNewlines(text).split("\n").slice(start, end).join("\n");
 }
 export function nonCommentLines(block) {
-    return block.split("\n").filter((ln) => !ln.trimStart().startsWith("#"));
+    return normalizeYamlNewlines(block)
+        .split("\n")
+        .filter((ln) => !ln.trimStart().startsWith("#"));
 }
 export function cachingKeyOnLine(line) {
     const m = line.match(CACHING_KEY);
     return m?.[1] ?? null;
 }
 export function readTaskfile(name) {
-    return readFileSync(join(repoRoot(), "tasks", name), { encoding: "utf8" });
+    return normalizeYamlNewlines(readFileSync(join(repoRoot(), "tasks", name), { encoding: "utf8" }));
 }
 export function readRoot(name) {
-    return readFileSync(join(repoRoot(), "tasks", "..", name), { encoding: "utf8" });
+    return normalizeYamlNewlines(readFileSync(join(repoRoot(), "tasks", "..", name), { encoding: "utf8" }));
 }
 //# sourceMappingURL=_taskfile-helpers.js.map

package/dist/doctor/doctor-state.js

@@ -1,4 +1,5 @@
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { resolveTriageCachePath } from "../triage/cache-path.js";
 import { CLEAN_WINDOW_HOURS, DIRTY_WINDOW_HOURS, ENV_STATE_PATH } from "./constants.js";
@@ -7,7 +8,7 @@ export function statePath(projectRoot) {
     const override = process.env[ENV_STATE_PATH]?.trim();
     if (override) {
         return override.startsWith("~")
-            ? join(process.env.HOME ?? projectRoot, override.slice(1))
+            ? join(homedir(), override.slice(1).replace(/^[\\/]/, ""))
             : override;
     }
     return resolveTriageCachePath(projectRoot, STATE_FILENAME);

package/dist/doctor/paths.js

@@ -1,4 +1,5 @@
 import { existsSync, readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { DEFT_REPO_POSITIVE_MARKERS } from "./constants.js";
@@ -8,7 +9,7 @@ export function resolvePath(pathStr, cwd = process.cwd()) {
         return cwd;
     }
     const expanded = pathStr.startsWith("~")
-        ? join(process.env.HOME ?? cwd, pathStr.slice(1))
+        ? join(homedir(), pathStr.slice(1).replace(/^[\\/]/, ""))
         : pathStr;
     return resolve(cwd, expanded);
 }

package/dist/eval-health-relocation/evaluate.d.ts

@@ -0,0 +1,71 @@
+import { type HealthReport } from "../eval/health.js";
+export type OutputStream = "stdout" | "stderr" | "none";
+/** Glob patterns that classify a change as epic #2369 rule-relocation (#2373). */
+export declare const RULE_RELOCATION_PATH_PATTERNS: readonly ["AGENTS.md", "content/templates/agents-entry.md", "content/skills/**/SKILL.md", "content/packs/**"];
+/** Committed no-regression baseline relative to `xbrief/.eval/`. */
+export declare const HEALTH_BASELINE_REL = "results/eval-health-baseline.json";
+/** Result of verify:eval-health-relocation; three-state exit contract. */
+export interface EvaluateResult {
+    readonly code: 0 | 1 | 2;
+    readonly message: string;
+    readonly stream: OutputStream;
+    /** True when the diff did not touch rule-relocation paths (gate skipped). */
+    readonly skipped?: boolean;
+}
+export interface EvaluateOptions {
+    readonly projectRoot?: string;
+    /** Git ref for `git diff --name-only` (CI / branch comparison). */
+    readonly baseRef?: string;
+    /** Use `git diff --cached --name-only` (pre-commit / staged). */
+    readonly staged?: boolean;
+    /** Explicit path list (tests / overrides). */
+    readonly paths?: readonly string[];
+    readonly quiet?: boolean;
+    /** Write the current eval:health report as the committed baseline. */
+    readonly seedBaseline?: boolean;
+    /** Test hook: override eval:health collection. */
+    readonly healthEvaluator?: (projectRoot: string) => HealthReport | null;
+}
+/** Validate a parsed baseline JSON object before use. */
+export declare function parseHealthBaseline(parsed: unknown): HealthReport | null;
+/** True when *path* matches a rule-relocation home. */
+export declare function isRuleRelocationPath(path: string): boolean;
+/** Classify a path list for rule-relocation coverage. */
+export declare function classifyRuleRelocationPaths(paths: readonly string[]): {
+    readonly isRelocation: boolean;
+    readonly matchedPaths: readonly string[];
+};
+/** Absolute path to the committed eval-health baseline snapshot. */
+export declare function healthBaselinePath(projectRoot: string): string;
+/** Read the committed baseline snapshot, if present. */
+export declare function readHealthBaseline(projectRoot: string): HealthReport | null;
+/** Persist a health report as the committed baseline (#2373 Wave 2 seed). */
+export declare function writeHealthBaseline(projectRoot: string, report: HealthReport): void;
+/** Collect changed paths from git (base ref or staged index). */
+export declare function collectChangedPaths(projectRoot: string, options: {
+    baseRef?: string;
+    staged?: boolean;
+}): string[] | {
+    error: string;
+};
+/**
+ * Detect eval:health regression against a committed baseline.
+ *
+ * Fail-closed rules (#2373):
+ * - score must not drop below baseline
+ * - gates that passed in the baseline must still pass
+ * - no new contradictory-gate ids beyond the baseline set
+ */
+export declare function detectHealthRegression(current: HealthReport, baseline: HealthReport): {
+    pass: boolean;
+    reasons: readonly string[];
+};
+/**
+ * Conditional fail-closed gate for epic #2369 rule-relocation PRs (#2373).
+ *
+ * Skips (exit 0) when the diff does not touch relocation homes. When relocation
+ * paths are present, requires eval:health no-regression against the committed
+ * baseline at `xbrief/.eval/results/eval-health-baseline.json`.
+ */
+export declare function evaluate(options?: EvaluateOptions): EvaluateResult;
+//# sourceMappingURL=evaluate.d.ts.map

package/dist/eval-health-relocation/evaluate.js

@@ -0,0 +1,252 @@
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { evaluateHealth } from "../eval/health.js";
+import { resolveEvalPath } from "../layout/resolve.js";
+import { matchAny } from "../orchestration/pathspec.js";
+/** Glob patterns that classify a change as epic #2369 rule-relocation (#2373). */
+export const RULE_RELOCATION_PATH_PATTERNS = [
+    "AGENTS.md",
+    "content/templates/agents-entry.md",
+    "content/skills/**/SKILL.md",
+    "content/packs/**",
+];
+/** Committed no-regression baseline relative to `xbrief/.eval/`. */
+export const HEALTH_BASELINE_REL = "results/eval-health-baseline.json";
+/** Validate a parsed baseline JSON object before use. */
+export function parseHealthBaseline(parsed) {
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return null;
+    }
+    const record = parsed;
+    if (typeof record.score !== "number" || !Array.isArray(record.gates)) {
+        return null;
+    }
+    if (!Array.isArray(record.contradictions)) {
+        return null;
+    }
+    return parsed;
+}
+/** True when *path* matches a rule-relocation home. */
+export function isRuleRelocationPath(path) {
+    return matchAny(RULE_RELOCATION_PATH_PATTERNS, path);
+}
+/** Classify a path list for rule-relocation coverage. */
+export function classifyRuleRelocationPaths(paths) {
+    const matchedPaths = paths.filter(isRuleRelocationPath);
+    return { isRelocation: matchedPaths.length > 0, matchedPaths };
+}
+/** Absolute path to the committed eval-health baseline snapshot. */
+export function healthBaselinePath(projectRoot) {
+    return resolveEvalPath(projectRoot, HEALTH_BASELINE_REL);
+}
+/** Read the committed baseline snapshot, if present. */
+export function readHealthBaseline(projectRoot) {
+    const path = healthBaselinePath(projectRoot);
+    if (!existsSync(path)) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf8"));
+        return parseHealthBaseline(parsed);
+    }
+    catch {
+        return null;
+    }
+}
+/** Persist a health report as the committed baseline (#2373 Wave 2 seed). */
+export function writeHealthBaseline(projectRoot, report) {
+    const path = healthBaselinePath(projectRoot);
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${JSON.stringify(report)}\n`, "utf8");
+}
+function gitNameOnlyDiff(projectRoot, args) {
+    try {
+        const stdout = execFileSync("git", ["-C", projectRoot, "diff", "--name-only", ...args], {
+            encoding: "utf8",
+            maxBuffer: 10 * 1024 * 1024,
+        });
+        return stdout
+            .split("\n")
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0);
+    }
+    catch (err) {
+        return { error: String(err) };
+    }
+}
+/** Collect changed paths from git (base ref or staged index). */
+export function collectChangedPaths(projectRoot, options) {
+    if (options.staged) {
+        return gitNameOnlyDiff(projectRoot, ["--cached"]);
+    }
+    if (options.baseRef !== undefined && options.baseRef.length > 0) {
+        return gitNameOnlyDiff(projectRoot, [options.baseRef, "HEAD"]);
+    }
+    return [];
+}
+/**
+ * Detect eval:health regression against a committed baseline.
+ *
+ * Fail-closed rules (#2373):
+ * - score must not drop below baseline
+ * - gates that passed in the baseline must still pass
+ * - no new contradictory-gate ids beyond the baseline set
+ */
+export function detectHealthRegression(current, baseline) {
+    const reasons = [];
+    if (current.score < baseline.score) {
+        reasons.push(`framework health score dropped ${baseline.score}->${current.score}`);
+    }
+    const baselineGates = new Map(baseline.gates.filter((gate) => !gate.skipped).map((gate) => [gate.id, gate]));
+    for (const [id, baseGate] of baselineGates) {
+        if (!baseGate.pass) {
+            continue;
+        }
+        const currentGate = current.gates.find((gate) => gate.id === id && !gate.skipped);
+        if (currentGate === undefined) {
+            reasons.push(`gate '${id}' missing from current eval:health report`);
+            continue;
+        }
+        if (!currentGate.pass) {
+            reasons.push(`gate '${id}' regressed (baseline pass -> current fail)`);
+        }
+    }
+    const baselineContradictionIds = new Set(baseline.contradictions.map((c) => c.id));
+    for (const contradiction of current.contradictions) {
+        if (!baselineContradictionIds.has(contradiction.id)) {
+            reasons.push(`new contradictory gate '${contradiction.id}'`);
+        }
+    }
+    return { pass: reasons.length === 0, reasons };
+}
+function formatSkipMessage(matchedPaths) {
+    return ("✓ verify:eval-health-relocation: no rule-relocation paths in diff " +
+        `(checked ${RULE_RELOCATION_PATH_PATTERNS.length} patterns; ` +
+        `diff had ${matchedPaths.length} relocation match${matchedPaths.length === 1 ? "" : "es"}).`);
+}
+function formatPassMessage(score, matchedPaths) {
+    return (`✓ verify:eval-health-relocation: eval:health no-regression OK ` +
+        `(score=${score}/100; relocation paths: ${matchedPaths.join(", ")}).`);
+}
+function formatRegressionMessage(reasons, matchedPaths, baseline, current) {
+    const detail = reasons.map((reason) => `   - ${reason}`).join("\n");
+    return ("❌ verify:eval-health-relocation: eval:health regression on rule-relocation PR " +
+        `(#2373 / epic #2369).\n` +
+        `   Baseline score: ${baseline.score}/100; current: ${current.score}/100.\n` +
+        `   Matched relocation paths: ${matchedPaths.join(", ")}\n` +
+        `${detail}\n` +
+        "   Remediation: restore gate pass states / score, or bump the committed baseline\n" +
+        `   at ${HEALTH_BASELINE_REL} only after a deliberate, reviewed health change.\n` +
+        "   Run `task eval:health` for the full gate breakdown.");
+}
+function runHealthEvaluator(projectRoot, healthEvaluator) {
+    if (healthEvaluator !== undefined) {
+        return healthEvaluator(projectRoot);
+    }
+    const healthResult = evaluateHealth({
+        projectRoot,
+        persist: false,
+        frameworkSource: true,
+    });
+    return healthResult.report;
+}
+/**
+ * Conditional fail-closed gate for epic #2369 rule-relocation PRs (#2373).
+ *
+ * Skips (exit 0) when the diff does not touch relocation homes. When relocation
+ * paths are present, requires eval:health no-regression against the committed
+ * baseline at `xbrief/.eval/results/eval-health-baseline.json`.
+ */
+export function evaluate(options = {}) {
+    const projectRoot = resolve(options.projectRoot ?? process.cwd());
+    const quiet = options.quiet ?? false;
+    if (options.seedBaseline) {
+        const report = runHealthEvaluator(projectRoot, options.healthEvaluator);
+        if (report === null) {
+            return {
+                code: 2,
+                message: "❌ verify:eval-health-relocation: eval:health returned no report.",
+                stream: "stderr",
+            };
+        }
+        writeHealthBaseline(projectRoot, report);
+        return {
+            code: 0,
+            message: `✓ verify:eval-health-relocation: seeded baseline at ${HEALTH_BASELINE_REL} ` +
+                `(score=${report.score}/100).`,
+            stream: "stdout",
+        };
+    }
+    let paths;
+    if (options.paths !== undefined) {
+        paths = [...options.paths];
+    }
+    else if (options.baseRef !== undefined || options.staged) {
+        const collected = collectChangedPaths(projectRoot, {
+            baseRef: options.baseRef,
+            staged: options.staged,
+        });
+        if ("error" in collected) {
+            return {
+                code: 2,
+                message: "❌ verify:eval-health-relocation: could not read git diff " +
+                    `(project_root=${projectRoot}): ${collected.error}`,
+                stream: "stderr",
+            };
+        }
+        paths = collected;
+    }
+    else {
+        return { code: 0, message: "", stream: "none", skipped: true };
+    }
+    const { isRelocation, matchedPaths } = classifyRuleRelocationPaths(paths);
+    if (!isRelocation) {
+        if (quiet) {
+            return { code: 0, message: "", stream: "none", skipped: true };
+        }
+        return {
+            code: 0,
+            message: formatSkipMessage(matchedPaths),
+            stream: "stdout",
+            skipped: true,
+        };
+    }
+    const current = runHealthEvaluator(projectRoot, options.healthEvaluator);
+    if (current === null) {
+        return {
+            code: 2,
+            message: "❌ verify:eval-health-relocation: eval:health returned no report.",
+            stream: "stderr",
+        };
+    }
+    const baseline = readHealthBaseline(projectRoot);
+    if (baseline === null) {
+        return {
+            code: 2,
+            message: "❌ verify:eval-health-relocation: missing committed baseline " +
+                `at ${HEALTH_BASELINE_REL}.\n` +
+                "   Seed once with: task verify:eval-health-relocation -- --seed-baseline\n" +
+                "   (after `task eval:health` is green on master). Baseline seeding is intentional\n" +
+                "   and does not weaken verify:agents-md-budget.",
+            stream: "stderr",
+        };
+    }
+    const regression = detectHealthRegression(current, baseline);
+    if (!regression.pass) {
+        return {
+            code: 1,
+            message: formatRegressionMessage(regression.reasons, matchedPaths, baseline, current),
+            stream: "stderr",
+        };
+    }
+    if (quiet) {
+        return { code: 0, message: "", stream: "none" };
+    }
+    return {
+        code: 0,
+        message: formatPassMessage(current.score, matchedPaths),
+        stream: "stdout",
+    };
+}
+//# sourceMappingURL=evaluate.js.map

package/dist/eval-health-relocation/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./evaluate.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/eval-health-relocation/index.js

@@ -0,0 +1,2 @@
+export * from "./evaluate.js";
+//# sourceMappingURL=index.js.map

package/dist/init-deposit/scaffold.js

@@ -457,7 +457,9 @@ export function ensureTaskfile(projectDir, io) {
     return true;
 }
 const HOOK_FILENAMES = ["pre-commit", "pre-push"];
+const HOOK_SUPPORT_FILENAMES = ["_deft-run.sh"];
 const HOOK_FILE_MODE = 0o755;
+const HOOK_SUPPORT_FILE_MODE = 0o644;
 export function writeConsumerGitHooks(projectDir, deftDir, io, seams = {}) {
     const srcDir = join(deftDir, ".githooks");
     if (!existsSync(srcDir) || !statSync(srcDir).isDirectory()) {
@@ -467,18 +469,20 @@ export function writeConsumerGitHooks(projectDir, deftDir, io, seams = {}) {
     const dstDir = join(projectDir, ".githooks");
     mkdirSync(dstDir, { recursive: true });
     let filesDeposited = false;
-    for (const name of HOOK_FILENAMES) {
+    for (const name of [...HOOK_FILENAMES, ...HOOK_SUPPORT_FILENAMES]) {
         const src = join(srcDir, name);
         if (!existsSync(src))
             continue;
         const data = readFileSync(src);
         const dst = join(dstDir, name);
         const existing = existsSync(dst) ? readFileSync(dst) : null;
+        const isHookScript = HOOK_FILENAMES.includes(name);
         if (!existing?.equals(data)) {
-            writeFileSync(dst, data, { mode: HOOK_FILE_MODE });
+            const mode = isHookScript ? HOOK_FILE_MODE : HOOK_SUPPORT_FILE_MODE;
+            writeFileSync(dst, data, { mode });
             filesDeposited = true;
         }
-        if (platform() !== "win32") {
+        if (platform() !== "win32" && isHookScript) {
             try {
                 const mode = statSync(dst).mode & 0o777;
                 if ((mode & 0o111) === 0) {

package/dist/intake/issue-emit.js

@@ -1,6 +1,6 @@
 import { globSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { join, relative, resolve } from "node:path";
+import { isAbsolute, join, relative, resolve } from "node:path";
 import { referenceTypeMatches } from "@deftai/directive-types";
 import { call } from "../scm/call.js";
 import { resolveProjectRoot } from "../scope/project-context.js";
@@ -217,7 +217,7 @@ export function expandPatterns(patterns, root = null) {
     const seen = new Set();
     const out = [];
     for (const pattern of patterns) {
-        const candidate = root !== null && !pattern.startsWith("/") ? join(root, pattern) : pattern;
+        const candidate = root !== null && !isAbsolute(pattern) ? join(root, pattern) : pattern;
         let matches = globSync(candidate).sort();
         if (matches.length === 0) {
             try {

package/dist/policy/agents-md-budget.d.ts

@@ -9,9 +9,32 @@
  * it is an explicit, reviewed diff to this typed field -- that diff IS the
  * "was this growth deliberate?" checkpoint.
  */
+export type HarnessProfile = "cursor" | "none";
+export type SkillFrontmatterTier = "daily-core" | "all" | "none";
 export interface AgentsMdBudget {
     readonly managedMaxLines: number;
     readonly unmanagedMaxLines: number;
+    /**
+     * Fail-closed UTF-8 byte ratchet for the managed section (#2452).
+     * Seeded at the current measured size so the gate ships green; growth past
+     * this ceiling fails. The <=8192 B north-star is reported separately.
+     */
+    readonly absoluteMaxBytes?: number;
+    /**
+     * Harness profile for DD-3 skill-frontmatter measurement (#2463).
+     * When unset, the gate auto-detects `cursor` when `content/skills/` exists.
+     */
+    readonly harnessProfile?: HarnessProfile;
+    /**
+     * Skill tier for DD-3 frontmatter caps (`daily-core` vs `all` vs `none`).
+     * Defaults to `all` for reporting when unset.
+     */
+    readonly skillFrontmatterTier?: SkillFrontmatterTier;
+    /**
+     * Optional fail-closed ratchet for DD-3 skill-frontmatter bytes (#2463).
+     * Advisory when unset; growth past this ceiling fails when set.
+     */
+    readonly skillFrontmatterMaxBytes?: number;
 }
 export type AgentsMdBudgetSource = "typed" | "unset" | "default-on-error";
 export interface AgentsMdBudgetResult {

package/dist/policy/agents-md-budget.js

@@ -39,6 +39,19 @@ function readRegion(block, key) {
     }
     return { value: raw, error: null };
 }
+function readOptionalRegion(block, key) {
+    if (!(key in block)) {
+        return { value: undefined, error: null };
+    }
+    const raw = block[key];
+    if (typeof raw !== "number" || !Number.isInteger(raw) || raw < 0) {
+        return {
+            value: undefined,
+            error: `plan.policy.agentsMdBudget.${key} must be a non-negative integer; got ${pythonTypeName(raw)} (${pythonRepr(raw)})`,
+        };
+    }
+    return { value: raw, error: null };
+}
 /** Resolve plan.policy.agentsMdBudget from PROJECT-DEFINITION (#645). */
 export function resolveAgentsMdBudget(projectRoot) {
     const [data, err] = loadProjectDefinition(projectRoot);
@@ -77,13 +90,71 @@ export function resolveAgentsMdBudget(projectRoot) {
     if (unmanaged.error !== null) {
         return { budget: null, source: "default-on-error", error: unmanaged.error };
     }
+    const absolute = readOptionalRegion(block, "absoluteMaxBytes");
+    if (absolute.error !== null) {
+        return { budget: null, source: "default-on-error", error: absolute.error };
+    }
+    const skillFrontmatterMax = readOptionalRegion(block, "skillFrontmatterMaxBytes");
+    if (skillFrontmatterMax.error !== null) {
+        return { budget: null, source: "default-on-error", error: skillFrontmatterMax.error };
+    }
+    const harnessProfile = readOptionalHarnessProfile(block, "harnessProfile");
+    if (harnessProfile.error !== null) {
+        return { budget: null, source: "default-on-error", error: harnessProfile.error };
+    }
+    const skillFrontmatterTier = readOptionalSkillTier(block, "skillFrontmatterTier");
+    if (skillFrontmatterTier.error !== null) {
+        return { budget: null, source: "default-on-error", error: skillFrontmatterTier.error };
+    }
+    const budget = {
+        managedMaxLines: managed.value,
+        unmanagedMaxLines: unmanaged.value,
+    };
+    const withOptional = {
+        ...budget,
+        ...(absolute.value !== undefined ? { absoluteMaxBytes: absolute.value } : {}),
+        ...(skillFrontmatterMax.value !== undefined
+            ? { skillFrontmatterMaxBytes: skillFrontmatterMax.value }
+            : {}),
+        ...(harnessProfile.value !== undefined ? { harnessProfile: harnessProfile.value } : {}),
+        ...(skillFrontmatterTier.value !== undefined
+            ? { skillFrontmatterTier: skillFrontmatterTier.value }
+            : {}),
+    };
     return {
-        budget: {
-            managedMaxLines: managed.value,
-            unmanagedMaxLines: unmanaged.value,
-        },
+        budget: withOptional,
         source: "typed",
         error: null,
     };
 }
+const HARNESS_PROFILES = new Set(["cursor", "none"]);
+const SKILL_FRONTMATTER_TIERS = new Set(["daily-core", "all", "none"]);
+function readOptionalHarnessProfile(block, key) {
+    if (!(key in block)) {
+        return { value: undefined, error: null };
+    }
+    const raw = block[key];
+    if (typeof raw !== "string" || !HARNESS_PROFILES.has(raw)) {
+        return {
+            value: undefined,
+            error: `plan.policy.agentsMdBudget.${key} must be one of ${[...HARNESS_PROFILES].join(", ")}; ` +
+                `got ${pythonTypeName(raw)} (${pythonRepr(raw)})`,
+        };
+    }
+    return { value: raw, error: null };
+}
+function readOptionalSkillTier(block, key) {
+    if (!(key in block)) {
+        return { value: undefined, error: null };
+    }
+    const raw = block[key];
+    if (typeof raw !== "string" || !SKILL_FRONTMATTER_TIERS.has(raw)) {
+        return {
+            value: undefined,
+            error: `plan.policy.agentsMdBudget.${key} must be one of ${[...SKILL_FRONTMATTER_TIERS].join(", ")}; ` +
+                `got ${pythonTypeName(raw)} (${pythonRepr(raw)})`,
+        };
+    }
+    return { value: raw, error: null };
+}
 //# sourceMappingURL=agents-md-budget.js.map

package/dist/release/spawn.js

@@ -1,12 +1,14 @@
 import { spawnSync } from "node:child_process";
 import { SUBPROCESS_MAX_BUFFER } from "../subprocess/max-buffer.js";
 export function defaultWhich(name) {
-    const result = spawnSync("which", [name], { encoding: "utf8" });
+    const locator = process.platform === "win32" ? "where" : "which";
+    const result = spawnSync(locator, [name], { encoding: "utf8" });
     if (result.status !== 0) {
         return null;
     }
-    const path = (result.stdout ?? "").trim();
-    return path || null;
+    // `where` on Windows may return multiple lines; take the first non-empty match.
+    const first = (result.stdout ?? "").split(/\r?\n/).find((line) => line.trim().length > 0);
+    return first ? first.trim() : null;
 }
 export function spawnText(cmd, args, options = {}) {
     const result = spawnSync(cmd, [...args], {

package/dist/scope/decompose.js

@@ -7,7 +7,7 @@
  * that draft, writes the child story vBRIEFs, and updates the parent scope references.
  */
 import { accessSync, constants, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { basename, dirname, isAbsolute, join, resolve } from "node:path";
+import { basename, dirname, isAbsolute, join, resolve, sep } from "node:path";
 import { referenceTypeMatches } from "@deftai/directive-types";
 import { hasArtifactSuffix, LEGACY_ARTIFACT_DIR, MIGRATED_ARTIFACT_DIR, resolveLifecycleRoot, } from "../layout/resolve.js";
 import { referenceWithDefaultTrust, slugify } from "../vbrief-build/build.js";
@@ -415,7 +415,7 @@ function vbriefDir(projectRoot) {
 function relToVbrief(vbriefDirPath, path) {
     const resolvedPath = resolve(path);
     const resolvedVbrief = resolve(vbriefDirPath);
-    if (resolvedPath.startsWith(`${resolvedVbrief}/`) || resolvedPath === resolvedVbrief) {
+    if (resolvedPath.startsWith(resolvedVbrief + sep) || resolvedPath === resolvedVbrief) {
         return resolvedPath.slice(resolvedVbrief.length + 1).replace(/\\/g, "/");
     }
     throw new DecompositionError(`${path}: path must be inside ${vbriefDirPath}`);
@@ -823,7 +823,8 @@ export function applyDecomposition(opts) {
     if (!LIFECYCLE_FOLDERS.has(outputFolderName)) {
         throw new DecompositionError("output_dir must be a vbrief lifecycle folder");
     }
-    if (!outputDir.startsWith(`${resolve(vbriefDirPath)}/`) && outputDir !== resolve(vbriefDirPath)) {
+    const resolvedVbriefDir = resolve(vbriefDirPath);
+    if (!outputDir.startsWith(resolvedVbriefDir + sep) && outputDir !== resolvedVbriefDir) {
         throw new DecompositionError("output_dir must be inside vbrief/");
     }
     if (outputFolderName === "active") {