@deftai/directive-core 0.75.0 → 0.76.0

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

@@ -1,5 +1,6 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join, resolve } from "node:path";
+import { getOpenPackageDefaultInstallTier, resolveOpenPackageTierSkills, } from "../packaging/openpackage-tiers.js";
 import { AGENTS_MANAGED_CLOSE } from "../platform/constants.js";
 import { resolveAgentsMdBudget, } from "../policy/agents-md-budget.js";
 import { measureSkillFrontmatter } from "./skill-frontmatter.js";
@@ -123,12 +124,23 @@ function resolveHarnessProfile(budget, projectRoot) {
     }
     return "none";
 }
-function resolveSkillFrontmatterTier(budget) {
+function resolveBootstrapSkillTier(budget, projectRoot) {
     const env = process.env.DEFT_AGENTS_MD_BUDGET_SKILL_TIER?.trim();
     if (env === "daily-core" || env === "all" || env === "none") {
         return env;
     }
-    return budget?.skillFrontmatterTier ?? "all";
+    if (budget?.skillFrontmatterTier !== undefined) {
+        return budget.skillFrontmatterTier;
+    }
+    try {
+        if (getOpenPackageDefaultInstallTier(projectRoot) === "daily-core") {
+            return "daily-core";
+        }
+    }
+    catch {
+        // No OpenPackage manifest at this project root — fall through.
+    }
+    return "all";
 }
 /** Measure managed + DD-3 skill frontmatter + bootstrap hooks. */
 export function measureBootstrapSurface(projectRoot, managedText, budget) {
@@ -137,11 +149,19 @@ export function measureBootstrapSurface(projectRoot, managedText, budget) {
         return managedResult;
     }
     const harnessProfile = resolveHarnessProfile(budget, projectRoot);
-    const tier = resolveSkillFrontmatterTier(budget);
+    const tier = resolveBootstrapSkillTier(budget, projectRoot);
+    let dailyCoreSkills;
+    try {
+        dailyCoreSkills = resolveOpenPackageTierSkills(projectRoot, "daily-core");
+    }
+    catch {
+        // Maintainer trees without packaging/openpackage fall back to hardcoded daily-core.
+    }
     const skillFrontmatter = measureSkillFrontmatter(projectRoot, {
         harnessProfile,
         tier,
         bytesPerToken: ABSOLUTE_BYTES_PER_TOKEN_ESTIMATE,
+        dailyCoreSkills,
     });
     const totalBytes = managedResult.bytes + skillFrontmatter.bytes + BOOTSTRAP_HOOK_BYTES;
     return {

package/dist/agents-md-budget/skill-frontmatter.d.ts

@@ -27,6 +27,8 @@ export interface MeasureSkillFrontmatterOptions {
     readonly tier?: SkillFrontmatterTier;
     readonly harnessProfile?: HarnessProfile;
     readonly bytesPerToken?: number;
+    /** Override daily-core skill names (from OpenPackage resolveTierSkills). */
+    readonly dailyCoreSkills?: readonly string[];
 }
 /** Measure harness-injected skill frontmatter bytes for the configured profile/tier. */
 export declare function measureSkillFrontmatter(projectRoot: string, options?: MeasureSkillFrontmatterOptions): SkillFrontmatterMeasure;

package/dist/agents-md-budget/skill-frontmatter.js

@@ -61,14 +61,14 @@ function listSkillDirs(skillsRoot) {
         .map((entry) => entry.name)
         .sort();
 }
-function skillMatchesTier(skillName, tier) {
+function skillInSelectedTier(skillName, tier, dailyCore) {
     if (tier === "none") {
         return false;
     }
     if (tier === "all") {
         return true;
     }
-    return DAILY_CORE_SET.has(skillName);
+    return dailyCore.has(skillName);
 }
 /** Measure harness-injected skill frontmatter bytes for the configured profile/tier. */
 export function measureSkillFrontmatter(projectRoot, options = {}) {
@@ -76,6 +76,7 @@ export function measureSkillFrontmatter(projectRoot, options = {}) {
     const tier = options.tier ?? "all";
     const bytesPerToken = options.bytesPerToken ?? 4;
     const skillsRoot = options.skillsRoot ?? defaultSkillsRoot(projectRoot);
+    const dailyCore = options.dailyCoreSkills !== undefined ? new Set(options.dailyCoreSkills) : DAILY_CORE_SET;
     if (harnessProfile === "none" || tier === "none") {
         return {
             bytes: 0,
@@ -88,7 +89,7 @@ export function measureSkillFrontmatter(projectRoot, options = {}) {
     }
     const entries = [];
     for (const skillName of listSkillDirs(skillsRoot)) {
-        if (!skillMatchesTier(skillName, tier)) {
+        if (!skillInSelectedTier(skillName, tier, dailyCore)) {
             continue;
         }
         const skillPath = join(skillsRoot, skillName, "SKILL.md");

package/dist/cache/operations.d.ts

@@ -1,7 +1,9 @@
+import { ProjectionContainmentError } from "../fs/projection-containment.js";
 import { type CacheCaps, type EntryUsage } from "./quota.js";
 import { SCANNER_VERSION } from "./scanner.js";
 import { type Clock } from "./time.js";
 import type { CacheGetOptions, CachePutOptions, GetResult, PutResult } from "./types.js";
+export { ProjectionContainmentError as CacheContainmentError };
 /** Write a cache entry (mirrors `cache.cache_put`). */
 export declare function cachePut(source: string, key: string, raw: Record<string, unknown>, options?: CachePutOptions): PutResult;
 /** Read a cache entry (mirrors `cache.cache_get`). */

package/dist/cache/operations.js

@@ -1,5 +1,6 @@
 import { existsSync, readdirSync, readFileSync, unlinkSync } from "node:fs";
-import { join } from "node:path";
+import { dirname, join, resolve } from "node:path";
+import { assertProjectionContained, ProjectionContainmentError, } from "../fs/projection-containment.js";
 import { pyRepr } from "../scm/py-format.js";
 import { ALLOWED_SOURCES, REPO_RE, SOURCE_TTL_SECONDS } from "./constants.js";
 import { CacheCapBreachedError, CacheError, CacheNotFoundError, CacheValidationError, } from "./errors.js";
@@ -10,6 +11,15 @@ import { enforceCaps, predictEvictionSet, resolveCaps, } from "./quota.js";
 import { flagsForMeta, SCANNER_VERSION, scan } from "./scanner.js";
 import { addSeconds, parseIso, systemClock, utcIso } from "./time.js";
 import { validateMeta } from "./validate.js";
+export { ProjectionContainmentError as CacheContainmentError };
+/** Refuse symlink-escaping `.deft-cache` before mkdir/read/write (#2470). */
+function assertWritableCachePath(cacheRoot, ...segments) {
+    const cacheAbs = resolve(cacheRoot);
+    const projectDir = dirname(cacheAbs);
+    const target = segments.length > 0 ? join(cacheAbs, ...segments) : cacheAbs;
+    assertProjectionContained(projectDir, target);
+    return target;
+}
 function renderContent(source, raw) {
     if (source === "github-issue") {
         const number = raw.number;
@@ -82,6 +92,7 @@ export function cachePut(source, key, raw, options = {}) {
     }
     const expires = addSeconds(fetched, ttl);
     const cacheRoot = options.cacheRoot ?? ".deft-cache";
+    assertWritableCachePath(cacheRoot);
     const edir = entryDir(source, key, cacheRoot);
     const rawText = pythonJsonDump(raw);
     const rawSize = Buffer.byteLength(rawText, "utf8");
@@ -182,6 +193,7 @@ export function cachePut(source, key, raw, options = {}) {
 export function cacheGet(source, key, options = {}) {
     const clock = options.clock ?? systemClock;
     const cacheRoot = options.cacheRoot ?? ".deft-cache";
+    assertWritableCachePath(cacheRoot);
     const allowStale = options.allowStale ?? true;
     const edir = entryDir(source, key, cacheRoot);
     const metaRelPath = `${source}/${key}/meta.json`;
@@ -220,6 +232,7 @@ export function cacheInvalidate(source, key, options = {}) {
     const clock = options.clock ?? systemClock;
     validateKey(source, key);
     const cacheRoot = options.cacheRoot ?? ".deft-cache";
+    assertWritableCachePath(cacheRoot);
     const edir = entryDir(source, key, cacheRoot);
     const existed = existsSync(edir);
     if (existed)
@@ -252,6 +265,7 @@ export function cachePrune(options = {}) {
         throw new CacheError(`--older-than-days must be >= 0 (got ${JSON.stringify(olderThanDays)})`);
     }
     const cacheRoot = options.cacheRoot ?? ".deft-cache";
+    assertWritableCachePath(cacheRoot);
     if (!existsSync(cacheRoot))
         return [];
     const cutoff = addSeconds(clock.now(), -olderThanDays * 24 * 60 * 60);
@@ -313,6 +327,7 @@ function collectMetaPathsUnder(srcRoot) {
 export function cachePruneToCap(options = {}) {
     const clock = options.clock ?? systemClock;
     const cacheRoot = options.cacheRoot ?? ".deft-cache";
+    assertWritableCachePath(cacheRoot);
     const resolved = options.caps ?? resolveCaps();
     if (!resolved.maxBytes && !resolved.maxEntries)
         return [];

package/dist/init-deposit/scaffold.js

@@ -10,12 +10,19 @@ import { mkdir, readdir, rm, stat, writeFile } from "node:fs/promises";
 import { platform } from "node:os";
 import { dirname, join, relative } from "node:path";
 import { copyTree } from "../deposit/copy-tree.js";
+import { assertProjectionContained, ProjectionContainmentError, } from "../fs/projection-containment.js";
 import { agentsRefreshPlan } from "../platform/agents-md.js";
 import { MIGRATED_ARTIFACT_DIR } from "../xbrief-migrate/constants.js";
 import { CANONICAL_INSTALL_ROOT } from "./constants.js";
 import { installerManagedGuardEre } from "./hygiene.js";
 export { CANONICAL_INSTALL_ROOT };
 export const CORE_GLOB = ".deft/core/**";
+/** Refuse init/update projection writes that escape via repo-controlled symlinks (#2446). */
+function projectionTarget(projectDir, ...relSegments) {
+    const target = join(projectDir, ...relSegments);
+    assertProjectionContained(projectDir, target);
+    return target;
+}
 const CODEQL_CONFIG_REL = ".github/codeql/codeql-config.yml";
 const CORE_GUARD_WORKFLOW_REL = ".github/workflows/deft-core-guard.yml";
 const FRAMEWORK_SELF_TEST_REL = ".deft/core/tests";
@@ -232,7 +239,7 @@ export const PIN_DEPENDENCY_NAME = "@deftai/directive";
  */
 export function ensurePackageJsonPin(projectDir, version, io) {
     const pinVersion = version.trim().replace(/^v/i, "");
-    const path = join(projectDir, "package.json");
+    const path = projectionTarget(projectDir, "package.json");
     const existed = existsSync(path);
     let pkg = {};
     if (existed) {
@@ -284,7 +291,7 @@ export function writeAgentsMd(projectDir, deftDir, io) {
     if (typeof newContent !== "string") {
         throw new Error("AGENTS.md render produced no content");
     }
-    const path = join(projectDir, "AGENTS.md");
+    const path = projectionTarget(projectDir, "AGENTS.md");
     writeFileSync(path, newContent, "utf8");
     if (state === "absent") {
         io.printf("AGENTS.md created.\n");
@@ -294,9 +301,9 @@ export function writeAgentsMd(projectDir, deftDir, io) {
     }
     return true;
 }
-async function ensureVbriefLifecycleDirs(consumerVbrief) {
+async function ensureVbriefLifecycleDirs(projectDir) {
     for (const sub of VBRIEF_LIFECYCLE_DIRS) {
-        const dir = join(consumerVbrief, sub);
+        const dir = projectionTarget(projectDir, MIGRATED_ARTIFACT_DIR, sub);
         await mkdir(dir, { recursive: true, mode: 0o755 });
         const gitkeep = join(dir, ".gitkeep");
         try {
@@ -323,9 +330,9 @@ function vbriefLifecycleDirsPresent(consumerVbrief) {
     });
 }
 export async function writeConsumerVbrief(projectDir, deftDir, io) {
-    const consumerVbrief = join(projectDir, MIGRATED_ARTIFACT_DIR);
-    const schemasDst = join(consumerVbrief, "schemas");
-    const vbriefMdDst = join(consumerVbrief, "vbrief.md");
+    const consumerVbrief = projectionTarget(projectDir, MIGRATED_ARTIFACT_DIR);
+    const schemasDst = projectionTarget(projectDir, MIGRATED_ARTIFACT_DIR, "schemas");
+    const vbriefMdDst = projectionTarget(projectDir, MIGRATED_ARTIFACT_DIR, "vbrief.md");
     const schemasPresent = existsSync(schemasDst) && statSync(schemasDst).isDirectory();
     const vbriefMdPresent = existsSync(vbriefMdDst) && statSync(vbriefMdDst).isFile();
     const lifecyclePresent = vbriefLifecycleDirsPresent(consumerVbrief);
@@ -352,20 +359,21 @@ export async function writeConsumerVbrief(projectDir, deftDir, io) {
             writeFileSync(vbriefMdDst, VBRIEF_README_BODY, "utf8");
         }
     }
-    await ensureVbriefLifecycleDirs(consumerVbrief);
+    await ensureVbriefLifecycleDirs(projectDir);
     io.printf("vbrief/ deposited at project root (schemas + vbrief.md + lifecycle dirs).\n");
     return true;
 }
 export function writeAgentsSkills(projectDir, io) {
+    projectionTarget(projectDir, ".agents");
     const allExist = AGENTS_SKILLS.every((skill) => existsSync(join(projectDir, ".agents", "skills", skill.dir, "SKILL.md")));
     if (allExist) {
         io.printf(".agents/skills/ already present — skipping.\n");
         return false;
     }
     for (const skill of AGENTS_SKILLS) {
-        const dir = join(projectDir, ".agents", "skills", skill.dir);
+        const dir = projectionTarget(projectDir, ".agents", "skills", skill.dir);
         mkdirSync(dir, { recursive: true });
-        const path = join(dir, "SKILL.md");
+        const path = projectionTarget(projectDir, ".agents", "skills", skill.dir, "SKILL.md");
         if (existsSync(path))
             continue;
         writeFileSync(path, skill.content, "utf8");
@@ -412,7 +420,7 @@ function insertDeftIncludeAfterIncludesLine(content) {
     return { content, ok: false };
 }
 export function ensureTaskfile(projectDir, io) {
-    const path = join(projectDir, "Taskfile.yml");
+    const path = projectionTarget(projectDir, "Taskfile.yml");
     let existing = "";
     if (existsSync(path)) {
         existing = readFileSync(path, "utf8");
@@ -466,7 +474,7 @@ export function writeConsumerGitHooks(projectDir, deftDir, io, seams = {}) {
         io.printf(`git hooks source ${srcDir} absent — skipping hook wiring.\n`);
         return false;
     }
-    const dstDir = join(projectDir, ".githooks");
+    const dstDir = projectionTarget(projectDir, ".githooks");
     mkdirSync(dstDir, { recursive: true });
     let filesDeposited = false;
     for (const name of [...HOOK_FILENAMES, ...HOOK_SUPPORT_FILENAMES]) {
@@ -474,7 +482,7 @@ export function writeConsumerGitHooks(projectDir, deftDir, io, seams = {}) {
         if (!existsSync(src))
             continue;
         const data = readFileSync(src);
-        const dst = join(dstDir, name);
+        const dst = projectionTarget(projectDir, ".githooks", name);
         const existing = existsSync(dst) ? readFileSync(dst) : null;
         const isHookScript = HOOK_FILENAMES.includes(name);
         if (!existing?.equals(data)) {
@@ -656,7 +664,7 @@ function coreGuardWorkflowContent() {
         '          echo "OK: no mixed framework + app changes."\n');
 }
 export function ensureGitattributes(projectDir, io) {
-    const path = join(projectDir, ".gitattributes");
+    const path = projectionTarget(projectDir, ".gitattributes");
     const existing = existsSync(path) ? readFileSync(path, "utf8") : "";
     const present = new Set(existing.split("\n").map((line) => line.trim()));
     const additions = CORE_GITATTRIBUTES_LINES.filter((line) => !present.has(line));
@@ -691,7 +699,7 @@ function appendGreptilePattern(patterns, glob) {
     return `${patterns}\n${glob}`;
 }
 export function ensureGreptileIgnore(projectDir, io) {
-    const path = join(projectDir, "greptile.json");
+    const path = projectionTarget(projectDir, "greptile.json");
     const fileExisted = existsSync(path);
     let raw = fileExisted ? readFileSync(path, "utf8") : "";
     if (!raw.trim())
@@ -766,7 +774,7 @@ function insertCodeqlPathsIgnore(content, glob) {
     return { content, ok: false };
 }
 export function ensureCodeqlPathsIgnore(projectDir, io) {
-    const path = join(projectDir, CODEQL_CONFIG_REL);
+    const path = projectionTarget(projectDir, CODEQL_CONFIG_REL);
     if (!existsSync(path)) {
         mkdirSync(dirname(path), { recursive: true });
         writeFileSync(path, codeqlConfigDefault(), "utf8");
@@ -787,7 +795,7 @@ export function ensureCodeqlPathsIgnore(projectDir, io) {
     return true;
 }
 export function ensureCoreGuardWorkflow(projectDir, io) {
-    const path = join(projectDir, CORE_GUARD_WORKFLOW_REL);
+    const path = projectionTarget(projectDir, CORE_GUARD_WORKFLOW_REL);
     const desired = coreGuardWorkflowContent();
     if (existsSync(path)) {
         const existing = readFileSync(path, "utf8");
@@ -866,6 +874,9 @@ export async function depositNeutralization(projectDir, io, options = {}) {
             await step();
         }
         catch (cause) {
+            if (cause instanceof ProjectionContainmentError) {
+                throw cause;
+            }
             io.printf(`Warning: neutralization step failed: ${String(cause)}\n`);
         }
     }

package/dist/intake/issue-ingest.js

@@ -8,7 +8,7 @@ import { resolveProjectRoot } from "../scope/project-context.js";
 import { resolveProjectRepo } from "../slice/project-context.js";
 import { slugify, TODAY } from "../vbrief-build/build.js";
 import { EMITTED_VBRIEF_VERSION } from "../vbrief-build/constants.js";
-import { LEGACY_ARTIFACT_SUFFIX, LEGACY_INFO_ROOT_KEY, LEGACY_VBRIEF_VERSION, MIGRATED_ARTIFACT_DIR, MIGRATED_ARTIFACT_SUFFIX, MIGRATED_INFO_ROOT_KEY, VBRIEF_VERSION, } from "../xbrief-migrate/constants.js";
+import { LEGACY_ARTIFACT_SUFFIX, LEGACY_INFO_ROOT_KEY, MIGRATED_ARTIFACT_DIR, MIGRATED_ARTIFACT_SUFFIX, MIGRATED_INFO_ROOT_KEY, VBRIEF_VERSION, } from "../xbrief-migrate/constants.js";
 import { findAcHeading, parseCheckboxItems, parseListItems, sliceAcSection, stripCodeBlocks, stripFencedCodeBlocks, } from "./markdown-scanners.js";
 import { detectRepo, extractReferencesFromVbrief, fetchOpenIssues, GITHUB_ISSUE_REF_TYPES, LIFECYCLE_FOLDERS, parseIssueNumber, } from "./reconcile-issues.js";
 export const INGEST_STATUSES = ["proposed", "pending", "active"];
@@ -78,7 +78,7 @@ function resolveIngestEmissionLayout(vbriefDir) {
         return {
             artifactSuffix: LEGACY_ARTIFACT_SUFFIX,
             infoRootKey: LEGACY_INFO_ROOT_KEY,
-            infoVersion: LEGACY_VBRIEF_VERSION,
+            infoVersion: EMITTED_VBRIEF_VERSION,
         };
     }
     return {
@@ -300,11 +300,25 @@ export function issueCommentThread(issue) {
 export function issueCommentsAlreadyFetched(issue) {
     return Object.hasOwn(issue, ISSUE_COMMENT_THREAD_KEY);
 }
+/**
+ * Run quarantine `scan()` on untrusted ingest text (#2447). Fail closed on a
+ * credential hard-fail; return the fenced/quarantined transform for soft signals.
+ */
+function scanUntrustedIngestText(issueNumber, text) {
+    const scanResult = scan(text);
+    const hardFails = scanResult.flags.filter((f) => f.severity === "hard-fail");
+    if (hardFails.length > 0) {
+        throw new ScannerHardFailError(issueNumber, scanResult.flags);
+    }
+    return scanResult.transformed_content;
+}
 export function buildIssueVbrief(issue, status, repoUrl, options = {}) {
     const number = Number(issue.number);
-    const title = (typeof issue.title === "string" && issue.title.length > 0
+    const titleRaw = (typeof issue.title === "string" && issue.title.length > 0
         ? issue.title
         : `Issue #${number}`) || `Issue #${number}`;
+    // #2447: quarantine-scan issue title before it lands in agent-authoritative fields.
+    const title = scanUntrustedIngestText(number, titleRaw);
     const url = (typeof issue.url === "string" && issue.url.length > 0 ? issue.url : "") ||
         (repoUrl.length > 0 ? `${repoUrl}/issues/${number}` : "");
     const bodyRaw = issue.body;
@@ -345,7 +359,12 @@ export function buildIssueVbrief(issue, status, repoUrl, options = {}) {
     if (labelNames.length > 0) {
         narratives.Labels = labelNames.join(", ");
     }
-    const planItems = bodyStr.length > 0 ? extractPlanItems(bodyStr) : [];
+    const planItemsRaw = bodyStr.length > 0 ? extractPlanItems(bodyStr) : [];
+    // #2447: scan each derived plan-item title (empty-body issues still scan title above).
+    const planItems = planItemsRaw.map((item) => ({
+        ...item,
+        title: scanUntrustedIngestText(number, String(item.title ?? "")),
+    }));
     const plan = {
         title,
         status: planStatus,

package/dist/packaging/openpackage-tiers.d.ts

@@ -0,0 +1,12 @@
+export type OpenPackageTierName = "daily-core" | "standard" | "advanced";
+export interface OpenPackageTierManifest {
+    readonly defaultInstallTier: OpenPackageTierName;
+    readonly tiers: Record<OpenPackageTierName, {
+        skills: string[];
+    }>;
+}
+/** Default OpenPackage install tier from deft-tiers.json (#2494). */
+export declare function getOpenPackageDefaultInstallTier(repoRoot: string): OpenPackageTierName;
+/** Skill names for an OpenPackage tier selection (`all` = every mapped skill). */
+export declare function resolveOpenPackageTierSkills(repoRoot: string, tier: OpenPackageTierName | "all"): string[];
+//# sourceMappingURL=openpackage-tiers.d.ts.map

package/dist/packaging/openpackage-tiers.js

@@ -0,0 +1,42 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+const TIER_NAMES = ["daily-core", "standard", "advanced"];
+function isOpenPackageTierName(value) {
+    return TIER_NAMES.includes(value);
+}
+function loadOpenPackageTierManifest(repoRoot) {
+    const path = join(repoRoot, "packaging", "openpackage", "deft-tiers.json");
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (parsed === null || typeof parsed !== "object" || !parsed.tiers) {
+        throw new Error("deft-tiers.json must be an object with a tiers field");
+    }
+    for (const tier of TIER_NAMES) {
+        const block = parsed.tiers[tier];
+        if (!block || !Array.isArray(block.skills)) {
+            throw new Error(`deft-tiers.json missing tiers.${tier}.skills`);
+        }
+    }
+    const defaultInstallTier = parsed.defaultInstallTier ?? "daily-core";
+    if (!isOpenPackageTierName(defaultInstallTier)) {
+        throw new Error(`deft-tiers.json defaultInstallTier must be one of ${TIER_NAMES.join(", ")}; got ${defaultInstallTier}`);
+    }
+    return {
+        defaultInstallTier,
+        tiers: parsed.tiers,
+    };
+}
+function resolveTierSkills(manifest, tier) {
+    if (tier === "all") {
+        return [...new Set(TIER_NAMES.flatMap((name) => manifest.tiers[name].skills))];
+    }
+    return [...manifest.tiers[tier].skills];
+}
+/** Default OpenPackage install tier from deft-tiers.json (#2494). */
+export function getOpenPackageDefaultInstallTier(repoRoot) {
+    return loadOpenPackageTierManifest(repoRoot).defaultInstallTier;
+}
+/** Skill names for an OpenPackage tier selection (`all` = every mapped skill). */
+export function resolveOpenPackageTierSkills(repoRoot, tier) {
+    return resolveTierSkills(loadOpenPackageTierManifest(repoRoot), tier);
+}
+//# sourceMappingURL=openpackage-tiers.js.map

package/dist/preflight/evaluate.d.ts

@@ -2,8 +2,11 @@
 export declare const ACTIVE_FOLDER = "active";
 /** Canonical eligibility status — only `running` signals an active handoff. */
 export declare const ELIGIBLE_STATUS = "running";
-/** Actionable redirect appended to every reject path (#810). */
-export declare const ACTIVATE_HINT = "Run `task vbrief:activate {path}` before spawning an implementation agent.";
+/** Actionable redirect appended to every reject path (#810 / #2449). */
+export declare const ACTIVATE_HINT = "Run `task scope:activate -- {path}` (or legacy `task vbrief:activate -- {path}`) before spawning an implementation agent.";
+/** Lifecycle folder names eligible for implementation (#810). */
+export declare const ELIGIBLE_LIFECYCLE_DIRS: readonly ["xbrief/active", "vbrief/active"];
+export declare const PREFLIGHT_USAGE_HINT = "Expected: `task xbrief:preflight -- xbrief/active/<story>.xbrief.json` (legacy: `task vbrief:preflight -- <path>`).";
 /** Result of a vBRIEF preflight evaluation; mirrors the Python `evaluate` tuple. */
 export interface EvaluateResult {
     readonly exitCode: 0 | 1;

package/dist/preflight/evaluate.js

@@ -4,14 +4,17 @@ import { basename, dirname } from "node:path";
 export const ACTIVE_FOLDER = "active";
 /** Canonical eligibility status — only `running` signals an active handoff. */
 export const ELIGIBLE_STATUS = "running";
-/** Actionable redirect appended to every reject path (#810). */
-export const ACTIVATE_HINT = "Run `task vbrief:activate {path}` before spawning an implementation agent.";
+/** Actionable redirect appended to every reject path (#810 / #2449). */
+export const ACTIVATE_HINT = "Run `task scope:activate -- {path}` (or legacy `task vbrief:activate -- {path}`) before spawning an implementation agent.";
+/** Lifecycle folder names eligible for implementation (#810). */
+export const ELIGIBLE_LIFECYCLE_DIRS = ["xbrief/active", "vbrief/active"];
+export const PREFLIGHT_USAGE_HINT = "Expected: `task xbrief:preflight -- xbrief/active/<story>.xbrief.json` (legacy: `task vbrief:preflight -- <path>`).";
 /** Substitute `{path}` without `$`-pattern expansion in user paths (#1721). */
 export function formatActivateHint(path) {
     return ACTIVATE_HINT.replace("{path}", () => path);
 }
 function buildReject(path, reason) {
-    return `${reason}\n  ${formatActivateHint(path)}`;
+    return `${reason}\n  ${PREFLIGHT_USAGE_HINT}\n  ${formatActivateHint(path)}`;
 }
 /** Map Node `JSON.parse` errors to CPython `json.JSONDecodeError.msg` for parity (#1721). */
 function nodeJsonErrorToPythonMsg(nodeMessage) {
@@ -91,10 +94,12 @@ export function evaluate(vbriefPath) {
         };
     }
     const folder = basename(dirname(vbriefPath));
+    const parent = basename(dirname(dirname(vbriefPath)));
+    const lifecycleDir = `${parent}/${folder}`;
     if (folder !== ACTIVE_FOLDER) {
         return {
             exitCode: 1,
-            message: buildReject(path, `vBRIEF is in ${folder}/ -- only vbrief/active/ is eligible for implementation.`),
+            message: buildReject(path, `xBRIEF is in ${lifecycleDir}/ -- only xbrief/active/ (or legacy vbrief/active/) is eligible for implementation.`),
         };
     }
     const record = payload;

package/dist/preflight/index.d.ts

@@ -1,3 +1,3 @@
 export type { EvaluateResult } from "./evaluate.js";
-export { ACTIVATE_HINT, ACTIVE_FOLDER, ELIGIBLE_STATUS, emitJson, evaluate, formatActivateHint, } from "./evaluate.js";
+export { ACTIVATE_HINT, ACTIVE_FOLDER, ELIGIBLE_LIFECYCLE_DIRS, ELIGIBLE_STATUS, emitJson, evaluate, formatActivateHint, PREFLIGHT_USAGE_HINT, } from "./evaluate.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/preflight/index.js

@@ -1,2 +1,2 @@
-export { ACTIVATE_HINT, ACTIVE_FOLDER, ELIGIBLE_STATUS, emitJson, evaluate, formatActivateHint, } from "./evaluate.js";
+export { ACTIVATE_HINT, ACTIVE_FOLDER, ELIGIBLE_LIFECYCLE_DIRS, ELIGIBLE_STATUS, emitJson, evaluate, formatActivateHint, PREFLIGHT_USAGE_HINT, } from "./evaluate.js";
 //# sourceMappingURL=index.js.map

package/dist/release/pipeline-fixture.d.ts

@@ -0,0 +1,3 @@
+/** Seed a real on-disk project root for pipeline write-path tests (#2470). */
+export declare function seedReleaseProjectDir(changelog?: string): string;
+//# sourceMappingURL=pipeline-fixture.d.ts.map

package/dist/release/pipeline-fixture.js

@@ -0,0 +1,11 @@
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+/** Seed a real on-disk project root for pipeline write-path tests (#2470). */
+export function seedReleaseProjectDir(changelog = `## [Unreleased]\n\n### Added\n- x\n`) {
+    const dir = mkdtempSync(join(tmpdir(), "release-proj-"));
+    writeFileSync(join(dir, "CHANGELOG.md"), changelog, "utf8");
+    writeFileSync(join(dir, "ROADMAP.md"), "# Roadmap\n", "utf8");
+    return dir;
+}
+//# sourceMappingURL=pipeline-fixture.js.map

package/dist/release/pipeline.js

@@ -1,5 +1,6 @@
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { assertProjectionContained } from "../fs/projection-containment.js";
 import { prependUpgradeBanner, promoteChangelog, sectionForVersion } from "./changelog.js";
 import { EXIT_CONFIG_ERROR, EXIT_OK, EXIT_VIOLATION, RELEASE_ARTIFACTS, TOTAL_STEPS, VERIFY_DRAFT_INTERVAL_SECONDS, VERIFY_DRAFT_MAX_ATTEMPTS, } from "./constants.js";
 import { checkTagAvailable, createGithubRelease, readTextFile, verifyReleaseDraft } from "./gh.js";
@@ -16,6 +17,7 @@ export function runPipeline(config, seams = {}) {
     const version = config.version;
     const today = (seams.todayIso ?? todayIso)();
     const changelogPath = join(projectRoot, "CHANGELOG.md");
+    const roadmapPath = join(projectRoot, "ROADMAP.md");
     const readFile = seams.readFile ?? ((p) => readFileSync(p, "utf8"));
     const writeFile = seams.writeFile ?? ((p, c) => writeFileSync(p, c, "utf8"));
     const fileExists = seams.fileExists ?? ((p) => existsSync(p));
@@ -149,6 +151,7 @@ export function runPipeline(config, seams = {}) {
         emit(6, label, `DRYRUN (would rewrite CHANGELOG.md: ## [Unreleased] -> ## [${version}] - ${today}; new compare link added;${summaryNote})`);
     }
     else {
+        assertProjectionContained(projectRoot, changelogPath);
         writeFile(changelogPath, promotedChangelog);
         emit(6, label, `OK (## [${version}] - ${today};${summaryNote})`);
     }
@@ -158,6 +161,7 @@ export function runPipeline(config, seams = {}) {
         emit(7, label, "DRYRUN (would run task roadmap:render)");
     }
     else {
+        assertProjectionContained(projectRoot, roadmapPath);
         const [ok, reason] = refreshRoadmapFn(projectRoot);
         if (ok) {
             emit(7, label, `OK (${reason})`);

package/dist/scope/transition.js

@@ -1,6 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, renameSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { InstrumentedVbriefCrud, persistCrudMetrics } from "../eval/crud-telemetry.js";
+import { assertProjectionContained, ProjectionContainmentError, } from "../fs/projection-containment.js";
 import { hasArtifactSuffix } from "../layout/resolve.js";
 import { append, canonicalLogPath, newDecisionId } from "./audit-log.js";
 import { stampCompletionMetadata } from "./capacity-stamp.js";
@@ -76,11 +77,25 @@ export function runTransition(action, filePath, now = new Date()) {
             message: `No-op: ${basename} is already in ${currentFolder}/ (status: ${currentStatus})`,
         };
     }
+    const vbriefRoot = dirname(dirname(resolvedPath));
+    const projectRoot = dirname(vbriefRoot);
+    if (targetFolder !== null) {
+        const destDir = join(vbriefRoot, targetFolder);
+        try {
+            // #2447: refuse lifecycle moves when the destination folder escapes the checkout.
+            // Run before mutating the source file so a refusal leaves lifecycle state intact.
+            assertProjectionContained(projectRoot, destDir);
+        }
+        catch (err) {
+            if (err instanceof ProjectionContainmentError) {
+                return { ok: false, message: err.message };
+            }
+            throw err;
+        }
+    }
     const nowIso = utcNowIso(now);
     planObj.status = targetStatus;
     planObj.updated = nowIso;
-    const vbriefRoot = dirname(dirname(resolvedPath));
-    const projectRoot = dirname(vbriefRoot);
     if (act === "complete") {
         stampCompletionMetadata(planObj, projectRoot, nowIso);
     }

package/dist/scope/vbrief-ref.d.ts

@@ -1,4 +1,10 @@
+import { ProjectionContainmentError } from "../fs/projection-containment.js";
 import { type ResolveLifecycleArtifactRefOptions } from "../layout/lifecycle-ref.js";
+export { ProjectionContainmentError as LifecycleRefContainmentError };
+/** Reject absolute or `..`-escaping lifecycle refs before path resolution (#2470). */
+export declare function rejectEscapingLifecycleRel(rel: string): void;
+/** Assert a resolved lifecycle artifact path stays under the lifecycle root (#2470). */
+export declare function assertLifecycleArtifactContained(lifecycleRoot: string, resolvedPath: string): void;
 /** Resolve a vBRIEF reference URI to an absolute path, or null. */
 export declare function resolveVbriefRef(uri: unknown, vbriefDir: string, options?: ResolveLifecycleArtifactRefOptions): string | null;
 /** Collect planRef values from the plan root and top-level items. */

package/dist/scope/vbrief-ref.js

@@ -1,7 +1,23 @@
-import { resolve, sep } from "node:path";
+import { isAbsolute, resolve, sep } from "node:path";
 import { referenceTypeMatches } from "@deftai/directive-types";
+import { assertProjectionContained, ProjectionContainmentError, } from "../fs/projection-containment.js";
 import { resolveLifecycleArtifactRef, } from "../layout/lifecycle-ref.js";
 import { hasArtifactSuffix, stripArtifactSuffix } from "../layout/resolve.js";
+export { ProjectionContainmentError as LifecycleRefContainmentError };
+/** Reject absolute or `..`-escaping lifecycle refs before path resolution (#2470). */
+export function rejectEscapingLifecycleRel(rel) {
+    if (isAbsolute(rel)) {
+        throw new ProjectionContainmentError(`lifecycle ref refused: absolute path ${rel} is not allowed under the lifecycle root`, { projectDir: "", targetPath: rel, offendingPath: rel });
+    }
+    const segments = rel.split(/[/\\]+/).filter((segment) => segment.length > 0);
+    if (segments.includes("..")) {
+        throw new ProjectionContainmentError(`lifecycle ref refused: path ${rel} contains parent traversal (..)`, { projectDir: "", targetPath: rel, offendingPath: rel });
+    }
+}
+/** Assert a resolved lifecycle artifact path stays under the lifecycle root (#2470). */
+export function assertLifecycleArtifactContained(lifecycleRoot, resolvedPath) {
+    assertProjectionContained(lifecycleRoot, resolvedPath);
+}
 /** Resolve a vBRIEF reference URI to an absolute path, or null. */
 export function resolveVbriefRef(uri, vbriefDir, options = {}) {
     if (typeof uri !== "string" || uri.length === 0) {
@@ -17,7 +33,10 @@ export function resolveVbriefRef(uri, vbriefDir, options = {}) {
     else {
         rel = uri;
     }
-    return resolveLifecycleArtifactRef(rel, vbriefDir, options);
+    rejectEscapingLifecycleRel(rel);
+    const resolved = resolveLifecycleArtifactRef(rel, vbriefDir, options);
+    assertLifecycleArtifactContained(vbriefDir, resolved);
+    return resolved;
 }
 /** Collect planRef values from the plan root and top-level items. */
 export function collectPlanRefs(plan) {