@deftai/directive-core 0.69.0 → 0.71.0

package/dist/triage/bootstrap/gitignore.js

@@ -1,6 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, relative } from "node:path";
-import { resolveEvalPath } from "../../layout/resolve.js";
+import { resolveLifecycleLayout } from "../../layout/resolve.js";
+import { resolveCandidatesLogPath, resolveTriageCachePath, TRIAGE_CACHE_DIR_NAME, triageCacheRelPath, } from "../cache-path.js";
 /** POSIX-style display path for `absPath` relative to `projectRoot` (#2109). */
 function evalRelDisplay(projectRoot, absPath) {
     return relative(projectRoot, absPath).split(/[\\/]/).join("/");
@@ -10,21 +11,41 @@ export const GITIGNORE_DEFT_RUNTIME_SENTINELS = [
     ".deft/ritual-state.json",
     ".deft/last-session.json",
 ];
+/** Legacy static vbrief paths kept for tests referencing the pre-#1703 constant shape. */
 export const GITIGNORE_EVAL_ENTRIES = [
-    "vbrief/.eval/candidates.jsonl",
-    "vbrief/.eval/summary-history.jsonl",
-    "vbrief/.eval/scope-lifecycle.jsonl",
-    "vbrief/.eval/decompositions/",
-    "vbrief/.eval/doctor-state.json",
+    "vbrief/.triage-cache/candidates.jsonl",
+    "vbrief/.triage-cache/summary-history.jsonl",
+    "vbrief/.triage-cache/scope-lifecycle.jsonl",
+    "vbrief/.triage-cache/decompositions/",
+    "vbrief/.triage-cache/doctor-state.json",
+];
+/** Layout-aware gitignore lines for triage working-set files (#1703). */
+export function gitignoreTriageCacheEntries(projectRoot) {
+    const decomp = triageCacheRelPath(projectRoot, "decompositions");
+    return [
+        triageCacheRelPath(projectRoot, "candidates.jsonl"),
+        triageCacheRelPath(projectRoot, "summary-history.jsonl"),
+        triageCacheRelPath(projectRoot, "scope-lifecycle.jsonl"),
+        decomp.endsWith("/") ? decomp : `${decomp}/`,
+        triageCacheRelPath(projectRoot, "doctor-state.json"),
+    ];
+}
+export function gitattributesTriageCacheGlob(projectRoot) {
+    const layout = resolveLifecycleLayout(projectRoot);
+    return `${layout.artifactDir}/${TRIAGE_CACHE_DIR_NAME}/*.jsonl`;
+}
+export const GITATTRIBUTES_EVAL_RULE = "vbrief/.triage-cache/*.jsonl  merge=union";
+export const FORBIDDEN_BLANKET_EVAL_LINES = [
+    "vbrief/.triage-cache/",
+    "vbrief/.triage-cache",
+    "vbrief/.triage-cache/",
+    "vbrief/.eval",
 ];
-export const GITATTRIBUTES_EVAL_RULE = "vbrief/.eval/*.jsonl  merge=union";
-export const FORBIDDEN_BLANKET_EVAL_LINES = ["vbrief/.eval/", "vbrief/.eval"];
-const GITATTRIBUTES_EVAL_GLOB = "vbrief/.eval/*.jsonl";
 const DEFT_CACHE_RATIONALE = "\n# Triage v1 local content cache (#845, #883). Mirrors upstream\n" +
     "# issues into .deft-cache/github-issue/<owner>/<repo>/<N>/. See\n" +
     "# docs/privacy-nfr.md for the gitignore-default + opt-in-commit-cache\n" +
     "# contract. Comment this line out to opt in to committing the cache.\n";
-const EVAL_ENTRIES_RATIONALE = "\n# vbrief/.eval/ tracking governance (#1144, N4 of #1119).\n" +
+const EVAL_ENTRIES_RATIONALE = "\n# vbrief/.triage-cache/ tracking governance (#1144, N4 of #1119).\n" +
     "# Hybrid policy from the Current Shape comment on #1144:\n" +
     "#   - candidates.jsonl       -> gitignored (operator-private triage\n" +
     "#                               decisions; re-derive via\n" +
@@ -50,15 +71,15 @@ const EVAL_ENTRIES_RATIONALE = "\n# vbrief/.eval/ tracking governance (#1144, N4
     "#   - slices.jsonl           -> TRACKED (team-shared cohort records\n" +
     "#                               produced by slicing skills; see\n" +
     "#                               #1132 / D13).\n" +
-    "# See vbrief/.eval/README.md for the full policy + merge=union\n" +
+    "# See vbrief/.triage-cache/README.md for the full policy + merge=union\n" +
     "# rebase note.\n";
-const GITATTRIBUTES_EVAL_RATIONALE = "\n# Append-only JSON-lines logs under vbrief/.eval/ use the union merge driver\n" +
+const GITATTRIBUTES_EVAL_RATIONALE = "\n# Append-only JSON-lines logs under vbrief/.triage-cache/ use the union merge driver\n" +
     "# (#1144, N4 of #1119). Both branches' appended lines are concatenated on\n" +
     "# auto-merge so single-operator rebases of two append branches resolve\n" +
     "# without manual conflict surgery. Note: merge=union does NOT dedupe; see\n" +
-    "# vbrief/.eval/README.md for the operator-facing semantics.\n";
-const EVAL_ENTRIES_RATIONALE_SENTINEL = "# vbrief/.eval/ tracking governance (#1144, N4 of #1119).";
-export const EVAL_README_BODY = `# \`vbrief/.eval/\` -- triage + slicing evaluation artefacts
+    "# vbrief/.triage-cache/README.md for the operator-facing semantics.\n";
+const EVAL_ENTRIES_RATIONALE_SENTINEL = "# vbrief/.triage-cache/ tracking governance (#1144, N4 of #1119).";
+export const EVAL_README_BODY = `# \`vbrief/.triage-cache/\` -- triage working-set artefacts
 
 This directory holds the append-only JSON-lines logs that the triage and
 slicing skills emit. The framework governs which files in here are tracked
@@ -75,9 +96,9 @@ by git versus gitignored using a **hybrid policy** (#1144, child of #1119).
 | \`decompositions/\` | No -- **gitignored** | Temporary story-decomposition proposal drafts. These JSON drafts are local scratch artifacts, not vBRIEFs; generated child story vBRIEFs are created by \`task scope:decompose\` in lifecycle folders, defaulting to \`vbrief/pending/\`. |
 | \`doctor-state.json\` | No -- **gitignored** | Per-machine \`task doctor\` throttle state (last exit code + timestamps) persisted to gate the 24h/4h re-probe window (#1308 / #1464). Local to each clone; never committed. |
 
-The gitignore lines live in the repo-root \`.gitignore\` (\`vbrief/.eval/candidates.jsonl\`,
-\`vbrief/.eval/summary-history.jsonl\`, \`vbrief/.eval/scope-lifecycle.jsonl\`,
-\`vbrief/.eval/decompositions/\`, and \`vbrief/.eval/doctor-state.json\`). All paths
+The gitignore lines live in the repo-root \`.gitignore\` (\`vbrief/.triage-cache/candidates.jsonl\`,
+\`vbrief/.triage-cache/summary-history.jsonl\`, \`vbrief/.triage-cache/scope-lifecycle.jsonl\`,
+\`vbrief/.triage-cache/decompositions/\`, and \`vbrief/.triage-cache/doctor-state.json\`). All paths
 not listed above remain committed by default.
 
 ## Fresh-clone regeneration
@@ -90,7 +111,7 @@ task triage:bootstrap
 \`\`\`
 
 The bootstrap path detects the missing file, runs the auto-classifier, and
-writes a fresh \`vbrief/.eval/candidates.jsonl\`. It does NOT touch the tracked
+writes a fresh \`vbrief/.triage-cache/candidates.jsonl\`. It does NOT touch the tracked
 \`slices.jsonl\`; cohort records remain a team-shared resource.
 
 ## \`merge=union\` policy for \`*.jsonl\`
@@ -98,7 +119,7 @@ writes a fresh \`vbrief/.eval/candidates.jsonl\`. It does NOT touch the tracked
 The repo-root \`.gitattributes\` declares:
 
 \`\`\`
-vbrief/.eval/*.jsonl  merge=union
+vbrief/.triage-cache/*.jsonl  merge=union
 \`\`\`
 
 The \`union\` merge driver concatenates both sides' appended lines on
@@ -217,10 +238,10 @@ export function stepEnsureGitignoreEntry(projectRoot) {
 function formatBlanketWarning(blanketPresent) {
     if (!blanketPresent)
         return "";
-    return (" WARNING: stale blanket vbrief/.eval/ line detected in .gitignore -- " +
+    return (" WARNING: stale blanket vbrief/.triage-cache/ line detected in .gitignore -- " +
         "remove it manually (it hides tracked slices.jsonl from git per #1251)");
 }
-function gitattributesHasEvalMergeUnion(body) {
+function gitattributesHasEvalMergeUnion(body, glob) {
     for (const raw of body.split("\n")) {
         const stripped = raw.trim();
         if (stripped.length === 0 || stripped.startsWith("#"))
@@ -228,14 +249,14 @@ function gitattributesHasEvalMergeUnion(body) {
         const parts = stripped.split(/\s+/);
         if (parts.length === 0)
             continue;
-        if (parts[0] !== GITATTRIBUTES_EVAL_GLOB)
+        if (parts[0] !== glob)
             continue;
         if (parts.slice(1).includes("merge=union"))
             return true;
     }
     return false;
 }
-function ensureGitignoreSelectiveEntries(gitignorePath, stepName) {
+function ensureGitignoreSelectiveEntries(gitignorePath, stepName, entries) {
     let existing;
     try {
         existing = readFileSync(gitignorePath, { encoding: "utf8" });
@@ -249,7 +270,7 @@ function ensureGitignoreSelectiveEntries(gitignorePath, stepName) {
         .filter((stripped) => stripped.length > 0));
     const blanketPresent = FORBIDDEN_BLANKET_EVAL_LINES.some((forbidden) => existingLines.has(forbidden));
     const rationaleAlreadyPresent = existing.includes(EVAL_ENTRIES_RATIONALE_SENTINEL);
-    const missing = GITIGNORE_EVAL_ENTRIES.filter((entry) => !existingLines.has(entry));
+    const missing = entries.filter((entry) => !existingLines.has(entry));
     const blanketWarning = formatBlanketWarning(blanketPresent);
     if (missing.length === 0) {
         return stepOutcome(stepName, true, `all #1144 selective entries already in .gitignore (no-op)${blanketWarning}`, {
@@ -277,7 +298,7 @@ function ensureGitignoreSelectiveEntries(gitignorePath, stepName) {
         rationale_already_present: rationaleAlreadyPresent,
     });
 }
-function ensureGitattributesMergeUnion(gitattributesPath, stepName) {
+function ensureGitattributesMergeUnion(gitattributesPath, stepName, glob, ruleLine) {
     if (existsSync(gitattributesPath)) {
         let existing;
         try {
@@ -286,30 +307,36 @@ function ensureGitattributesMergeUnion(gitattributesPath, stepName) {
         catch (exc) {
             return stepOutcome(stepName, false, "could not read .gitattributes", { gitattributes_appended: false }, String(exc));
         }
-        if (gitattributesHasEvalMergeUnion(existing)) {
-            return stepOutcome(stepName, true, "vbrief/.eval/*.jsonl merge=union already in .gitattributes (no-op)", {
+        if (gitattributesHasEvalMergeUnion(existing, glob)) {
+            return stepOutcome(stepName, true, `${glob} merge=union already in .gitattributes (no-op)`, {
                 gitattributes_appended: false,
                 gitattributes_already_present: true,
             });
         }
         const suffix = existing.endsWith("\n") || existing === "" ? "" : "\n";
-        const newContent = `${existing + suffix + GITATTRIBUTES_EVAL_RATIONALE + GITATTRIBUTES_EVAL_RULE}\n`;
+        const newContent = `${existing + suffix + GITATTRIBUTES_EVAL_RATIONALE + ruleLine}\n`;
         try {
             writeFileSync(gitattributesPath, newContent, { encoding: "utf8" });
         }
         catch (exc) {
             return stepOutcome(stepName, false, "could not write .gitattributes", { gitattributes_appended: false }, String(exc));
         }
-        return stepOutcome(stepName, true, "appended vbrief/.eval/*.jsonl merge=union to .gitattributes", { gitattributes_appended: true, gitattributes_created: false });
+        return stepOutcome(stepName, true, `appended ${glob} merge=union to .gitattributes`, {
+            gitattributes_appended: true,
+            gitattributes_created: false,
+        });
     }
-    const newContent = `${GITATTRIBUTES_EVAL_RATIONALE + GITATTRIBUTES_EVAL_RULE}\n`;
+    const newContent = `${GITATTRIBUTES_EVAL_RATIONALE + ruleLine}\n`;
     try {
         writeFileSync(gitattributesPath, newContent, { encoding: "utf8" });
     }
     catch (exc) {
         return stepOutcome(stepName, false, "could not create .gitattributes", { gitattributes_appended: false }, String(exc));
     }
-    return stepOutcome(stepName, true, "created .gitattributes with vbrief/.eval/*.jsonl merge=union", { gitattributes_appended: true, gitattributes_created: true });
+    return stepOutcome(stepName, true, `created .gitattributes with ${glob} merge=union`, {
+        gitattributes_appended: true,
+        gitattributes_created: true,
+    });
 }
 function ensureEvalReadme(readmePath, readmeRel, stepName) {
     try {
@@ -339,17 +366,20 @@ export function stepEnsureGitignoreEvalEntries(projectRoot) {
     const gitattributesPath = `${projectRoot}/.gitattributes`;
     // Layout-aware (#2109): resolve the README under the active lifecycle `.eval`
     // dir (xbrief/ when migrated, else vbrief/) instead of a hardcoded vbrief/ path.
-    const readmePath = resolveEvalPath(projectRoot, "README.md");
+    const readmePath = resolveTriageCachePath(projectRoot, "README.md");
     const readmeRel = evalRelDisplay(projectRoot, readmePath);
+    const entries = gitignoreTriageCacheEntries(projectRoot);
+    const glob = gitattributesTriageCacheGlob(projectRoot);
+    const ruleLine = `${glob}  merge=union`;
     const stepName = "ensure_gitignore_eval_entries";
     const details = {};
-    const giResult = ensureGitignoreSelectiveEntries(gitignorePath, stepName);
+    const giResult = ensureGitignoreSelectiveEntries(gitignorePath, stepName, entries);
     if (!giResult.ok) {
         Object.assign(details, giResult.details);
         return stepOutcome(stepName, false, giResult.message, details, giResult.error ?? null);
     }
     Object.assign(details, giResult.details);
-    const gaResult = ensureGitattributesMergeUnion(gitattributesPath, stepName);
+    const gaResult = ensureGitattributesMergeUnion(gitattributesPath, stepName, glob, ruleLine);
     if (!gaResult.ok) {
         Object.assign(details, gaResult.details);
         return stepOutcome(stepName, false, gaResult.message, details, gaResult.error ?? null);
@@ -386,11 +416,11 @@ export function stepEnsureGitignoreEvalEntries(projectRoot) {
     message += formatBlanketWarning(Boolean(details.blanket_present));
     return stepOutcome(stepName, true, message, details);
 }
-/** Ensure `vbrief/.eval/candidates.jsonl` exists (#1240 option A). */
+/** Ensure `vbrief/.triage-cache/candidates.jsonl` exists (#1240 option A). */
 export function stepSeedCandidatesLog(projectRoot) {
     // Layout-aware (#2109): seed under the active lifecycle `.eval` dir (xbrief/
     // when migrated, else vbrief/) instead of a hardcoded vbrief/ path.
-    const auditPath = resolveEvalPath(projectRoot, "candidates.jsonl");
+    const auditPath = resolveCandidatesLogPath(projectRoot);
     const auditRel = evalRelDisplay(projectRoot, auditPath);
     const auditDir = dirname(auditPath);
     try {

package/dist/triage/bootstrap/index.d.ts

@@ -2,7 +2,7 @@ import type { BootstrapResult, CacheModule, RunBootstrapOptions, StepOutcome } f
 export * from "./gitignore.js";
 export * from "./types.js";
 export declare const CACHE_DIR_NAME = ".deft-cache";
-export declare const AUDIT_LOG_RELPATH = "vbrief/.eval/candidates.jsonl";
+export declare const AUDIT_LOG_RELPATH = "vbrief/.triage-cache/candidates.jsonl";
 export declare const BACKFILL_FOLDERS: readonly ["proposed", "pending", "active"];
 export declare const BOOTSTRAP_ACTOR = "agent:bootstrap";
 export declare const DEFAULT_FETCH_TIMEOUT_S = 3600;

package/dist/triage/bootstrap/index.js

@@ -3,14 +3,15 @@ import { randomUUID } from "node:crypto";
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { promisify } from "node:util";
-import { hasArtifactSuffix, resolveEvalPath, resolveLifecycleRoot } from "../../layout/resolve.js";
+import { hasArtifactSuffix, resolveLifecycleRoot } from "../../layout/resolve.js";
 import { SUBPROCESS_MAX_BUFFER } from "../../subprocess/max-buffer.js";
+import { resolveCandidatesLogPath } from "../cache-path.js";
 import { stepEnsureGitignoreEntry, stepEnsureGitignoreEvalEntries, stepSeedCandidatesLog, } from "./gitignore.js";
 import { PROGRESS_DEFAULT } from "./types.js";
 export * from "./gitignore.js";
 export * from "./types.js";
 export const CACHE_DIR_NAME = ".deft-cache";
-export const AUDIT_LOG_RELPATH = "vbrief/.eval/candidates.jsonl";
+export const AUDIT_LOG_RELPATH = "vbrief/.triage-cache/candidates.jsonl";
 export const BACKFILL_FOLDERS = ["proposed", "pending", "active"];
 export const BOOTSTRAP_ACTOR = "agent:bootstrap";
 export const DEFAULT_FETCH_TIMEOUT_S = 3600;
@@ -377,7 +378,7 @@ export function stepBackfillAuditLog(projectRoot, repo, options = {}) {
     if (!existsSync(vbriefRoot)) {
         return stepOutcome("backfill_audit_log", true, `skipped (no vbrief/ directory under ${projectRoot})`, { skipped: "no-vbrief" });
     }
-    const auditPath = resolveEvalPath(projectRoot, "candidates.jsonl");
+    const auditPath = resolveCandidatesLogPath(projectRoot);
     const alreadyLogged = existingAuditIssueNumbers(auditPath);
     const nowIso = options.nowIso ?? nowIsoDefault;
     const appendEntry = options.appendAuditEntry ?? appendAuditEntryDefault;

package/dist/triage/bulk/index.d.ts

@@ -88,12 +88,21 @@ export declare function excludeLogged(candidates: Iterable<IssuePayload>, option
 export declare function bulkAction(actionKey: string, repo: string, options?: BulkActionOptions): number;
 export declare function createFilesystemCacheModule(): CacheModule;
 export declare function createFilesystemCandidatesLogModule(logPath?: string): CandidatesLogModule;
+/**
+ * Native TypeScript bulk actions module (#2279).
+ *
+ * The bulk path defaults to this factory instead of {@link createPythonActionsModule}
+ * so `triage:bulk-*` never spawns a project-local `scripts/triage_actions.py`
+ * (an arbitrary-code-execution trust boundary a malicious checkout could plant).
+ * Each verb delegates to the already-native per-issue triage actions
+ * (`@deftai/directive-core/triage/actions`, #1725) bound to `createDefaultDeps(projectRoot)`.
+ */
+export declare function createNativeActionsModule(projectRoot: string): TriageActionsModule;
 export declare function createPythonActionsModule(scriptsDir: string): TriageActionsModule;
 export interface DefaultBulkDepsOptions {
     readonly cacheRoot?: string;
     readonly candidatesLogPath?: string;
-    readonly scriptsDir?: string;
-    readonly deftRoot?: string;
+    readonly projectRoot?: string;
 }
 export declare function bulkActionWithDefaults(actionKey: string, repo: string, options?: BulkActionOptions & DefaultBulkDepsOptions): number;
 //# sourceMappingURL=index.d.ts.map

package/dist/triage/bulk/index.js

@@ -1,7 +1,8 @@
 import { spawnSync } from "node:child_process";
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
-import { resolveEvalPath } from "../../layout/resolve.js";
+import { createDefaultDeps, accept as nativeAccept, deferAction as nativeDefer, needsAc as nativeNeedsAc, reject as nativeReject, } from "../actions/index.js";
+import { resolveCandidatesLogPath } from "../cache-path.js";
 export const ACTION_FN_NAMES = {
     accept: "accept",
     reject: "reject",
@@ -376,7 +377,7 @@ export function createFilesystemCacheModule() {
         CacheError,
     };
 }
-export function createFilesystemCandidatesLogModule(logPath = resolveEvalPath(process.cwd(), "candidates.jsonl")) {
+export function createFilesystemCandidatesLogModule(logPath = resolveCandidatesLogPath(process.cwd())) {
     return {
         readAll(options) {
             if (!existsSync(logPath)) {
@@ -402,6 +403,40 @@ export function createFilesystemCandidatesLogModule(logPath = resolveEvalPath(pr
         },
     };
 }
+/**
+ * Native TypeScript bulk actions module (#2279).
+ *
+ * The bulk path defaults to this factory instead of {@link createPythonActionsModule}
+ * so `triage:bulk-*` never spawns a project-local `scripts/triage_actions.py`
+ * (an arbitrary-code-execution trust boundary a malicious checkout could plant).
+ * Each verb delegates to the already-native per-issue triage actions
+ * (`@deftai/directive-core/triage/actions`, #1725) bound to `createDefaultDeps(projectRoot)`.
+ */
+export function createNativeActionsModule(projectRoot) {
+    const deps = createDefaultDeps(projectRoot);
+    return {
+        accept(n, repo) {
+            nativeAccept(n, repo, deps, { projectRoot });
+        },
+        reject(n, repo, ...args) {
+            let reason = "";
+            const first = args[0];
+            if (typeof first === "object" && first !== null && "reason" in first) {
+                reason = String(first.reason);
+            }
+            else if (typeof first === "string") {
+                reason = first;
+            }
+            nativeReject(n, repo, reason, deps, { projectRoot });
+        },
+        defer(n, repo) {
+            nativeDefer(n, repo, "bulk defer", deps, { projectRoot });
+        },
+        needs_ac(n, repo) {
+            nativeNeedsAc(n, repo, deps, { projectRoot });
+        },
+    };
+}
 export function createPythonActionsModule(scriptsDir) {
     const runAction = (cmd, issueNumber, repo, extra = []) => {
         const result = spawnSync("uv", [
@@ -442,14 +477,16 @@ export function createPythonActionsModule(scriptsDir) {
     };
 }
 export function bulkActionWithDefaults(actionKey, repo, options = {}) {
-    const deftRoot = options.deftRoot ?? process.cwd();
-    const scriptsDir = options.scriptsDir ?? join(deftRoot, "scripts");
+    // #2279: the bulk path no longer resolves a `scripts/` dir from DEFT_ROOT /
+    // the project cwd. It defaults to the native TypeScript actions module so a
+    // malicious project-local `scripts/triage_actions.py` can never be executed.
+    const projectRoot = options.projectRoot ?? process.cwd();
     return bulkAction(actionKey, repo, {
         ...options,
-        cacheRoot: options.cacheRoot ?? join(deftRoot, ".deft-cache"),
+        cacheRoot: options.cacheRoot ?? join(projectRoot, ".deft-cache"),
         cacheModule: options.cacheModule ?? createFilesystemCacheModule(),
         candidatesLogModule: options.candidatesLogModule ?? createFilesystemCandidatesLogModule(options.candidatesLogPath),
-        actionsModule: options.actionsModule ?? createPythonActionsModule(scriptsDir),
+        actionsModule: options.actionsModule ?? createNativeActionsModule(projectRoot),
     });
 }
 //# sourceMappingURL=index.js.map

package/dist/triage/cache-path.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Layout-aware triage working-set cache paths (#1703 namespace cleanup).
+ *
+ * Triage append-only logs and scratch dirs live under `.triage-cache/` so the
+ * `.eval/` namespace can be reclaimed for version-eval results (#1703 Tier 2).
+ */
+/** Directory name for the triage working-set cache (not version-eval results). */
+export declare const TRIAGE_CACHE_DIR_NAME = ".triage-cache";
+/** Legacy directory that previously held triage cache files before #1703. */
+export declare const LEGACY_TRIAGE_EVAL_DIR_NAME = ".eval";
+/** Known triage-cache file basenames migrated off the legacy `.eval/` tree. */
+export declare const TRIAGE_CACHE_FILE_NAMES: readonly ["candidates.jsonl", "summary-history.jsonl", "scope-lifecycle.jsonl", "subscription-history.jsonl", "slices.jsonl", "doctor-state.json", "README.md"];
+/** Known triage-cache directory names migrated off the legacy `.eval/` tree. */
+export declare const TRIAGE_CACHE_DIR_NAMES: readonly ["decompositions"];
+export interface TriageCacheMigrationResult {
+    readonly migratedFiles: readonly string[];
+    readonly skippedFiles: readonly string[];
+    readonly migratedDirs: readonly string[];
+}
+/** Absolute path to the layout-aware `.triage-cache/` directory. */
+export declare function resolveTriageCacheDir(projectRoot: string): string;
+/** POSIX-style path relative to project root (e.g. `xbrief/.triage-cache/foo`). */
+export declare function triageCacheRelPath(projectRoot: string, ...segments: string[]): string;
+/**
+ * Idempotently move triage working-set artefacts from legacy `.eval/` into
+ * `.triage-cache/` when the new location is absent.
+ */
+export declare function migrateLegacyTriageCacheFromEval(projectRoot: string): TriageCacheMigrationResult;
+/** Resolve a path under `.triage-cache/`, migrating legacy `.eval/` files first. */
+export declare function resolveTriageCachePath(projectRoot: string, ...segments: string[]): string;
+/** Display helper: project-root-relative POSIX path for logs and gitignore copy. */
+export declare function triageCacheDisplayPath(projectRoot: string, absPath: string): string;
+/** Back-compat display constant; resolution flows through `resolveTriageCachePath`. */
+export declare const TRIAGE_CANDIDATES_LOG_REL_PATH = "vbrief/.triage-cache/candidates.jsonl";
+/** Layout-aware candidates audit-log path. */
+export declare function resolveCandidatesLogPath(projectRoot: string): string;
+/** Ensure the triage cache directory exists (post-migration). */
+export declare function ensureTriageCacheDir(projectRoot: string): string;
+//# sourceMappingURL=cache-path.d.ts.map

package/dist/triage/cache-path.js

@@ -0,0 +1,98 @@
+/**
+ * Layout-aware triage working-set cache paths (#1703 namespace cleanup).
+ *
+ * Triage append-only logs and scratch dirs live under `.triage-cache/` so the
+ * `.eval/` namespace can be reclaimed for version-eval results (#1703 Tier 2).
+ */
+import { existsSync, mkdirSync, renameSync } from "node:fs";
+import { join, relative } from "node:path";
+import { resolveEvalDir, resolveLifecycleLayout, resolveLifecycleRoot } from "../layout/resolve.js";
+/** Directory name for the triage working-set cache (not version-eval results). */
+export const TRIAGE_CACHE_DIR_NAME = ".triage-cache";
+/** Legacy directory that previously held triage cache files before #1703. */
+export const LEGACY_TRIAGE_EVAL_DIR_NAME = ".eval";
+/** Known triage-cache file basenames migrated off the legacy `.eval/` tree. */
+export const TRIAGE_CACHE_FILE_NAMES = [
+    "candidates.jsonl",
+    "summary-history.jsonl",
+    "scope-lifecycle.jsonl",
+    "subscription-history.jsonl",
+    "slices.jsonl",
+    "doctor-state.json",
+    "README.md",
+];
+/** Known triage-cache directory names migrated off the legacy `.eval/` tree. */
+export const TRIAGE_CACHE_DIR_NAMES = ["decompositions"];
+/** Absolute path to the layout-aware `.triage-cache/` directory. */
+export function resolveTriageCacheDir(projectRoot) {
+    return join(resolveLifecycleRoot(projectRoot), TRIAGE_CACHE_DIR_NAME);
+}
+/** POSIX-style path relative to project root (e.g. `xbrief/.triage-cache/foo`). */
+export function triageCacheRelPath(projectRoot, ...segments) {
+    const layout = resolveLifecycleLayout(projectRoot);
+    return [layout.artifactDir, TRIAGE_CACHE_DIR_NAME, ...segments].join("/");
+}
+/**
+ * Idempotently move triage working-set artefacts from legacy `.eval/` into
+ * `.triage-cache/` when the new location is absent.
+ */
+export function migrateLegacyTriageCacheFromEval(projectRoot) {
+    const legacyDir = resolveEvalDir(projectRoot);
+    const targetDir = resolveTriageCacheDir(projectRoot);
+    const migratedFiles = [];
+    const skippedFiles = [];
+    const migratedDirs = [];
+    if (!existsSync(legacyDir)) {
+        return { migratedFiles, skippedFiles, migratedDirs };
+    }
+    mkdirSync(targetDir, { recursive: true });
+    for (const name of TRIAGE_CACHE_FILE_NAMES) {
+        const legacyPath = join(legacyDir, name);
+        const targetPath = join(targetDir, name);
+        if (!existsSync(legacyPath)) {
+            continue;
+        }
+        if (existsSync(targetPath)) {
+            skippedFiles.push(name);
+            continue;
+        }
+        renameSync(legacyPath, targetPath);
+        migratedFiles.push(name);
+    }
+    for (const name of TRIAGE_CACHE_DIR_NAMES) {
+        const legacyPath = join(legacyDir, name);
+        const targetPath = join(targetDir, name);
+        if (!existsSync(legacyPath)) {
+            continue;
+        }
+        if (existsSync(targetPath)) {
+            skippedFiles.push(`${name}/`);
+            continue;
+        }
+        renameSync(legacyPath, targetPath);
+        migratedDirs.push(name);
+    }
+    return { migratedFiles, skippedFiles, migratedDirs };
+}
+/** Resolve a path under `.triage-cache/`, migrating legacy `.eval/` files first. */
+export function resolveTriageCachePath(projectRoot, ...segments) {
+    migrateLegacyTriageCacheFromEval(projectRoot);
+    return join(resolveTriageCacheDir(projectRoot), ...segments);
+}
+/** Display helper: project-root-relative POSIX path for logs and gitignore copy. */
+export function triageCacheDisplayPath(projectRoot, absPath) {
+    return relative(projectRoot, absPath).split(/[\\/]/).join("/");
+}
+/** Back-compat display constant; resolution flows through `resolveTriageCachePath`. */
+export const TRIAGE_CANDIDATES_LOG_REL_PATH = "vbrief/.triage-cache/candidates.jsonl";
+/** Layout-aware candidates audit-log path. */
+export function resolveCandidatesLogPath(projectRoot) {
+    return resolveTriageCachePath(projectRoot, "candidates.jsonl");
+}
+/** Ensure the triage cache directory exists (post-migration). */
+export function ensureTriageCacheDir(projectRoot) {
+    const dir = resolveTriageCacheDir(projectRoot);
+    mkdirSync(dir, { recursive: true });
+    return dir;
+}
+//# sourceMappingURL=cache-path.js.map