@deftai/directive-core 0.71.1 → 0.73.0

package/dist/policy/value-feedback.d.ts

@@ -1,3 +1,4 @@
+import { type OrgAutoEnableOptions } from "./value-feedback-autoenable.js";
 /** Canonical registered policy field name (matches other FIELD_* dotted paths). */
 export declare const FIELD_VALUE_FEEDBACK = "plan.policy.valueFeedback";
 /** Short alias accepted by `policy:show --field=valueFeedback` (#1709). */
@@ -16,7 +17,7 @@ export interface ValueFeedbackConfig {
     readonly sessionLine: boolean;
     readonly upstreamPrompt: boolean;
 }
-export type ValueFeedbackSource = "typed" | "default" | "default-on-error";
+export type ValueFeedbackSource = "typed" | "org-auto" | "default" | "default-on-error";
 export interface ValueFeedbackResolved extends ValueFeedbackConfig {
     readonly source: ValueFeedbackSource;
     readonly error: string | null;
@@ -24,8 +25,20 @@ export interface ValueFeedbackResolved extends ValueFeedbackConfig {
 export declare const VALUE_FEEDBACK_CAPABILITY_COST_DISCLOSURE: string;
 /** Validate a `plan.policy.valueFeedback` payload. */
 export declare function validateValueFeedback(value: unknown): string[];
-/** Resolve `plan.policy.valueFeedback` from PROJECT-DEFINITION (#1709). */
-export declare function resolveValueFeedback(projectRoot: string): ValueFeedbackResolved;
+export interface ResolveValueFeedbackOptions {
+    /** Test seam for origin-org auto-enable resolution (#2376). */
+    readonly autoEnable?: OrgAutoEnableOptions;
+}
+/**
+ * Resolve `plan.policy.valueFeedback` from PROJECT-DEFINITION (#1709).
+ *
+ * Precedence (#2376): an explicit typed `valueFeedback` block always wins
+ * (including `enabled: false`). Only when the typed flag is ABSENT does the
+ * trusted-org auto-enable layer apply -- for company-owned (deftai) repos it
+ * turns LOCAL emit + session readback ON while leaving network/upstream OFF.
+ * Any other repo (or no origin remote) stays OFF.
+ */
+export declare function resolveValueFeedback(projectRoot: string, options?: ResolveValueFeedbackOptions): ValueFeedbackResolved;
 /** Master gate: when `enabled` is false, every downstream path is rejected. */
 export declare function isValueFeedbackPathAllowed(path: ValueFeedbackSubFlag, policy: ValueFeedbackResolved): boolean;
 /** Resolved per-path gate booleans for policy:show and enable status output. */
@@ -38,8 +51,20 @@ export interface ValueFeedbackPolicyField {
     readonly default: ValueFeedbackConfig;
     readonly source: string;
 }
-/** Inspector row for `policy:show --field=valueFeedback`. */
-export declare function inspectValueFeedback(data: Record<string, unknown> | null): ValueFeedbackPolicyField;
+export interface InspectValueFeedbackOptions {
+    /** Test seam for origin-org auto-enable resolution (#2376). */
+    readonly autoEnable?: OrgAutoEnableOptions;
+}
+/**
+ * Inspector row for `policy:show --field=valueFeedback`.
+ *
+ * When `projectRoot` is supplied this MUST mirror {@link resolveValueFeedback}'s
+ * precedence exactly (#2377 review): with no explicit typed block, a trusted-org
+ * checkout resolves to `org-auto`/ON so `policy:show` never reports OFF while the
+ * ledger is actively collecting. Omitting `projectRoot` keeps the legacy
+ * data-only behavior for callers that only need the field name/shape.
+ */
+export declare function inspectValueFeedback(data: Record<string, unknown> | null, projectRoot?: string, options?: InspectValueFeedbackOptions): ValueFeedbackPolicyField;
 export interface EnableValueFeedbackOptions {
     readonly confirm: boolean;
     readonly actor?: string;

package/dist/policy/value-feedback.js

@@ -2,6 +2,7 @@ import { readFileSync } from "node:fs";
 import { atomicWriteProjectDefinition, projectDefinitionMutationLock, } from "../vbrief-build/project-definition-io.js";
 import { migrateLegacyPolicyKey, PLAN_POLICY_KEY, readPlanPolicy } from "./plan-extensions.js";
 import { appendAuditLog, loadProjectDefinition, projectDefinitionPath } from "./resolve.js";
+import { isTrustedOrgAutoEnable } from "./value-feedback-autoenable.js";
 /** Canonical registered policy field name (matches other FIELD_* dotted paths). */
 export const FIELD_VALUE_FEEDBACK = "plan.policy.valueFeedback";
 /** Short alias accepted by `policy:show --field=valueFeedback` (#1709). */
@@ -33,6 +34,20 @@ function defaultResolved(source, error = null) {
         error,
     };
 }
+/**
+ * Trusted-org auto-enable resolution (#2376): LOCAL emit + session readback ON,
+ * network/upstream OFF. Applies only when the typed flag is absent.
+ */
+function orgAutoResolved() {
+    return {
+        enabled: true,
+        emitEvents: VALUE_FEEDBACK_SUBFLAG_DEFAULTS_WHEN_ENABLED.emitEvents,
+        sessionLine: VALUE_FEEDBACK_SUBFLAG_DEFAULTS_WHEN_ENABLED.sessionLine,
+        upstreamPrompt: false,
+        source: "org-auto",
+        error: null,
+    };
+}
 function readSubFlag(block, key, masterEnabled) {
     if (!masterEnabled) {
         return false;
@@ -88,8 +103,16 @@ function resolveFromPolicyBlock(raw) {
         error: null,
     };
 }
-/** Resolve `plan.policy.valueFeedback` from PROJECT-DEFINITION (#1709). */
-export function resolveValueFeedback(projectRoot) {
+/**
+ * Resolve `plan.policy.valueFeedback` from PROJECT-DEFINITION (#1709).
+ *
+ * Precedence (#2376): an explicit typed `valueFeedback` block always wins
+ * (including `enabled: false`). Only when the typed flag is ABSENT does the
+ * trusted-org auto-enable layer apply -- for company-owned (deftai) repos it
+ * turns LOCAL emit + session readback ON while leaving network/upstream OFF.
+ * Any other repo (or no origin remote) stays OFF.
+ */
+export function resolveValueFeedback(projectRoot, options = {}) {
     const [data, err] = loadProjectDefinition(projectRoot);
     if (data === null) {
         return defaultResolved("default-on-error", err);
@@ -99,6 +122,9 @@ export function resolveValueFeedback(projectRoot) {
         policyBlock === null ||
         Array.isArray(policyBlock) ||
         !("valueFeedback" in policyBlock)) {
+        if (isTrustedOrgAutoEnable(projectRoot, options.autoEnable)) {
+            return orgAutoResolved();
+        }
         return defaultResolved("default");
     }
     return resolveFromPolicyBlock(policyBlock.valueFeedback);
@@ -126,57 +152,49 @@ export function formatValueFeedbackStatusLine(policy) {
         `sessionLine=${String(policy.sessionLine)} (path=${String(gates.sessionLine)}) ` +
         `upstreamPrompt=${String(policy.upstreamPrompt)} (path=${String(gates.upstreamPrompt)}).`);
 }
-function defaultInspectorConfig() {
-    const defaults = defaultResolved("default");
-    return {
-        enabled: defaults.enabled,
-        emitEvents: defaults.emitEvents,
-        sessionLine: defaults.sessionLine,
-        upstreamPrompt: defaults.upstreamPrompt,
-    };
-}
-function buildDefaultInspectorField() {
+function fieldFromResolved(resolved) {
     return {
         name: FIELD_VALUE_FEEDBACK,
-        current: defaultInspectorConfig(),
+        current: {
+            enabled: resolved.enabled,
+            emitEvents: resolved.emitEvents,
+            sessionLine: resolved.sessionLine,
+            upstreamPrompt: resolved.upstreamPrompt,
+        },
         default: {
             enabled: DEFAULT_VALUE_FEEDBACK_ENABLED,
             emitEvents: false,
             sessionLine: false,
             upstreamPrompt: false,
         },
-        source: "default",
+        source: resolved.source,
     };
 }
-/** Inspector row for `policy:show --field=valueFeedback`. */
-export function inspectValueFeedback(data) {
+/**
+ * Inspector row for `policy:show --field=valueFeedback`.
+ *
+ * When `projectRoot` is supplied this MUST mirror {@link resolveValueFeedback}'s
+ * precedence exactly (#2377 review): with no explicit typed block, a trusted-org
+ * checkout resolves to `org-auto`/ON so `policy:show` never reports OFF while the
+ * ledger is actively collecting. Omitting `projectRoot` keeps the legacy
+ * data-only behavior for callers that only need the field name/shape.
+ */
+export function inspectValueFeedback(data, projectRoot, options = {}) {
     if (data === null) {
-        return buildDefaultInspectorField();
+        return fieldFromResolved(defaultResolved("default"));
     }
     const policyBlock = readPlanPolicy(data.plan);
     if (typeof policyBlock !== "object" ||
         policyBlock === null ||
         Array.isArray(policyBlock) ||
         !("valueFeedback" in policyBlock)) {
-        return buildDefaultInspectorField();
+        if (projectRoot !== undefined && isTrustedOrgAutoEnable(projectRoot, options.autoEnable)) {
+            return fieldFromResolved(orgAutoResolved());
+        }
+        return fieldFromResolved(defaultResolved("default"));
     }
     const resolved = resolveFromPolicyBlock(policyBlock.valueFeedback);
-    return {
-        name: FIELD_VALUE_FEEDBACK,
-        current: {
-            enabled: resolved.enabled,
-            emitEvents: resolved.emitEvents,
-            sessionLine: resolved.sessionLine,
-            upstreamPrompt: resolved.upstreamPrompt,
-        },
-        default: {
-            enabled: DEFAULT_VALUE_FEEDBACK_ENABLED,
-            emitEvents: false,
-            sessionLine: false,
-            upstreamPrompt: false,
-        },
-        source: resolved.source,
-    };
+    return fieldFromResolved(resolved);
 }
 /** Persist `valueFeedback.enabled=true` after capability-cost disclosure (#1709). */
 export function enableValueFeedback(projectRoot, options) {

package/dist/policy/wip.d.ts

@@ -10,6 +10,6 @@ export interface WipCapResult {
 }
 /** Resolve plan.policy.wipCap from PROJECT-DEFINITION (#1124). */
 export declare function resolveWipCap(projectRoot: string): WipCapResult;
-/** Count *.vbrief.json files in vbrief/pending/ + vbrief/active/ (#1124). */
+/** Count *.xbrief.json files in xbrief/pending/ + xbrief/active/ (#1124). */
 export declare function countVbriefWip(projectRoot: string): number;
 //# sourceMappingURL=wip.d.ts.map

package/dist/policy/wip.js

@@ -1,6 +1,6 @@
 import { existsSync, readdirSync } from "node:fs";
 import { join } from "node:path";
-import { hasArtifactSuffix, resolveLifecycleRoot } from "../layout/resolve.js";
+import { hasArtifactSuffix, LEGACY_ARTIFACT_DIR, MIGRATED_ARTIFACT_DIR, resolveLifecycleRoot, } from "../layout/resolve.js";
 import { readPlanPolicy } from "./plan-extensions.js";
 import { loadProjectDefinition } from "./resolve.js";
 /** Framework default WIP cap (#2319; raised from 10 per #1124 / umbrella #1119). */
@@ -62,10 +62,22 @@ export function resolveWipCap(projectRoot) {
     }
     return { cap: raw, source: "typed", error: null };
 }
-/** Count *.vbrief.json files in vbrief/pending/ + vbrief/active/ (#1124). */
+/** Count *.xbrief.json files in xbrief/pending/ + xbrief/active/ (#1124). */
 export function countVbriefWip(projectRoot) {
     let total = 0;
-    const vbriefRoot = resolveLifecycleRoot(projectRoot);
+    let vbriefRoot;
+    try {
+        vbriefRoot = resolveLifecycleRoot(projectRoot);
+    }
+    catch (err) {
+        // If xbrief/ dir exists (even without artifacts), there is no WIP to count.
+        // If only vbrief/ exists, this is a legacy project that must be migrated -- re-throw.
+        if (!existsSync(join(projectRoot, MIGRATED_ARTIFACT_DIR)) &&
+            existsSync(join(projectRoot, LEGACY_ARTIFACT_DIR))) {
+            throw err; // Legacy-only project: operator must run deft migrate:xbrief.
+        }
+        return 0; // No layout found at all; no WIP files to count.
+    }
     for (const sub of WIP_LIFECYCLE_DIRS) {
         const folder = join(vbriefRoot, sub);
         if (!existsSync(folder)) {

package/dist/preflight-cache/evaluate.js

@@ -23,7 +23,7 @@ import { resolveCandidatesLogPath } from "../triage/cache-path.js";
 // ---------------------------------------------------------------------------
 export const CACHE_DIR_NAME = ".deft-cache";
 export const DEFAULT_SOURCE = "github-issue";
-export const CANDIDATES_RELPATH = join("vbrief", ".triage-cache", "candidates.jsonl");
+export const CANDIDATES_RELPATH = join("xbrief", ".triage-cache", "candidates.jsonl");
 export const DEFAULT_MAX_AGE_HOURS = 24;
 export const ENV_MAX_AGE_HOURS = "DEFT_CACHE_MAX_AGE_HOURS";
 export const ENV_TRIAGE_REPO = "DEFT_TRIAGE_REPO";

package/dist/release/native-steps.js

@@ -3,10 +3,11 @@
  * Replaces python-steps.ts (scripts/ roadmap_render, reconcile_issues, build_dist).
  */
 import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { fetchIssueStates, isTerminalLifecyclePath, reconcile, scanVbriefDir, } from "../intake/reconcile-issues.js";
-import { resolveLifecycleFolder, resolveLifecycleRoot } from "../layout/resolve.js";
+import { LEGACY_ARTIFACT_DIR, MIGRATED_ARTIFACT_DIR, resolveLifecycleFolder, resolveLifecycleRoot, } from "../layout/resolve.js";
 import { renderRoadmap } from "../render/roadmap-render.js";
 const BUILD_DIST_RUNNER = join(dirname(fileURLToPath(import.meta.url)), "build-dist-runner.js");
 export function refreshRoadmapNative(projectRoot) {
@@ -20,7 +21,18 @@ export function refreshRoadmapNative(projectRoot) {
     return [true, "ROADMAP.md re-rendered"];
 }
 export function checkVbriefLifecycleSyncNative(projectRoot, repo) {
-    const vbriefDir = resolveLifecycleRoot(projectRoot);
+    let vbriefDir;
+    try {
+        vbriefDir = resolveLifecycleRoot(projectRoot);
+    }
+    catch (_err) {
+        // Re-throw if this is a legacy-only vbrief/ project; fall back to canonical path otherwise.
+        if (existsSync(join(projectRoot, LEGACY_ARTIFACT_DIR)) &&
+            !existsSync(join(projectRoot, MIGRATED_ARTIFACT_DIR))) {
+            return [false, 0, "no xbrief/ layout found; skipping lifecycle sync check"];
+        }
+        vbriefDir = join(projectRoot, MIGRATED_ARTIFACT_DIR);
+    }
     try {
         const issueToVbriefs = scanVbriefDir(vbriefDir);
         const issueStateMap = fetchIssueStates(repo, new Set(issueToVbriefs.keys()), {

package/dist/render/export-spec.js

@@ -26,7 +26,7 @@ export function exportSpec(options = {}) {
     const includeProposed = audience === "internal";
     const authority = resolveSpecAuthority(projectRoot);
     if (!authority) {
-        return [false, "✗ Missing vbrief/PROJECT-DEFINITION.vbrief.json — cannot export spec."];
+        return [false, "✗ Missing xbrief/PROJECT-DEFINITION.xbrief.json — cannot export spec."];
     }
     if (authority.kind === "full-spec" && authority.specPath) {
         const [ok, msg] = validateSpec(authority.specPath);
@@ -36,7 +36,7 @@ export function exportSpec(options = {}) {
     else if (!greenfieldOverviewNonEmpty(authority)) {
         return [
             false,
-            "⚠ PROJECT-DEFINITION.vbrief.json Overview narrative is empty (D3). Populate Overview before export.",
+            "⚠ PROJECT-DEFINITION.xbrief.json Overview narrative is empty (D3). Populate Overview before export.",
         ];
     }
     const narratives = resolveExportNarratives(authority);

package/dist/render/project-render.js

@@ -1,6 +1,6 @@
 import { existsSync, mkdirSync, readdirSync, readFileSync } from "node:fs";
 import { basename, join, resolve } from "node:path";
-import { hasArtifactSuffix, resolveLifecycleRoot, stripArtifactSuffix } from "../layout/resolve.js";
+import { hasArtifactSuffix, resolveLayoutRootOrCanonical, stripArtifactSuffix, } from "../layout/resolve.js";
 import { EMITTED_VBRIEF_VERSION } from "../vbrief-build/constants.js";
 import { atomicWriteProjectDefinition, projectDefinitionMutationLock, } from "../vbrief-build/project-definition-io.js";
 import { deriveRegistryItemStatus, registryMetadataReferencesFromScope, } from "../vbrief-validate/registry-status.js";
@@ -317,30 +317,61 @@ export function acknowledgeProjectDefinitionStaleness(vbriefDir, options = {}) {
         ];
     });
 }
+const USAGE = "Usage: project-render [--help] [--acknowledge-staleness] [--project-root <dir>]\n";
 /** CLI entry (mirrors ``scripts/project_render.main``). */
 export function main(argv) {
-    const acknowledge = argv[0] === "--acknowledge-staleness";
-    const rest = acknowledge ? argv.slice(1) : argv;
+    // Handle --help / -h before any other parsing so the flag is never treated
+    // as a positional output path and no stray ./--help/ directory is created
+    // (#2236).
+    if (argv.includes("--help") || argv.includes("-h")) {
+        process.stdout.write(USAGE);
+        return 0;
+    }
+    // Parse all flags in a single positional-independent pass so that
+    // --acknowledge-staleness is recognised at any position (not only argv[0]).
+    let acknowledge = false;
     let projectRoot;
     const positional = [];
-    for (let i = 0; i < rest.length; i += 1) {
-        const arg = rest[i];
-        if (arg === "--project-root") {
-            projectRoot = rest[i + 1];
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--acknowledge-staleness") {
+            acknowledge = true;
+        }
+        else if (arg === "--project-root") {
+            projectRoot = argv[i + 1];
             i += 1;
         }
         else if (arg.startsWith("--project-root=")) {
             projectRoot = arg.slice("--project-root=".length);
         }
+        else if (arg.startsWith("-")) {
+            // Reject unknown flags rather than consuming them as positional output
+            // paths (would otherwise create stray directories like ./--help/).
+            process.stderr.write(`Unknown flag: ${arg}\n${USAGE}`);
+            return 2;
+        }
         else {
             positional.push(arg);
         }
     }
     if (positional.length > 1) {
-        process.stderr.write("Usage: project-render [--acknowledge-staleness] [--project-root <dir>] [vbrief_dir]\n");
+        process.stderr.write(USAGE);
         return 2;
     }
-    const vbriefDir = positional[0] ?? resolveLifecycleRoot(resolve(projectRoot !== undefined ? projectRoot : "."));
+    let vbriefDir;
+    if (positional[0] !== undefined) {
+        vbriefDir = positional[0];
+    }
+    else {
+        const effectiveRoot = resolve(projectRoot !== undefined ? projectRoot : ".");
+        try {
+            vbriefDir = resolveLayoutRootOrCanonical(effectiveRoot);
+        }
+        catch {
+            process.stderr.write(`No xbrief/ layout found at ${effectiveRoot}. Run \`deft migrate:xbrief\` to convert your project from the legacy vbrief/ layout.\n`);
+            return 2;
+        }
+    }
     const [ok, message] = acknowledge
         ? acknowledgeProjectDefinitionStaleness(vbriefDir)
         : renderProjectDefinition(vbriefDir);

package/dist/scope/decompose.js

@@ -9,7 +9,7 @@
 import { accessSync, constants, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { basename, dirname, isAbsolute, join, resolve } from "node:path";
 import { referenceTypeMatches } from "@deftai/directive-types";
-import { hasArtifactSuffix, resolveLifecycleRoot } from "../layout/resolve.js";
+import { hasArtifactSuffix, LEGACY_ARTIFACT_DIR, MIGRATED_ARTIFACT_DIR, resolveLifecycleRoot, } from "../layout/resolve.js";
 import { referenceWithDefaultTrust, slugify } from "../vbrief-build/build.js";
 import { EMITTED_VBRIEF_VERSION } from "../vbrief-build/constants.js";
 import { formatVbriefJson } from "./vbrief-json.js";
@@ -400,7 +400,17 @@ export function storyQualityIssues(opts) {
 // Path helpers
 // ---------------------------------------------------------------------------
 function vbriefDir(projectRoot) {
-    return resolveLifecycleRoot(projectRoot);
+    try {
+        return resolveLifecycleRoot(projectRoot);
+    }
+    catch (err) {
+        // Re-throw if only vbrief/ exists (legacy-only); fall back to canonical xbrief/ path otherwise.
+        if (existsSync(join(projectRoot, LEGACY_ARTIFACT_DIR)) &&
+            !existsSync(join(projectRoot, MIGRATED_ARTIFACT_DIR))) {
+            throw err;
+        }
+        return join(projectRoot, MIGRATED_ARTIFACT_DIR);
+    }
 }
 function relToVbrief(vbriefDirPath, path) {
     const resolvedPath = resolve(path);

package/dist/session/resume-conditions.js

@@ -1,7 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { join, resolve } from "node:path";
-import { hasArtifactSuffix } from "../layout/resolve.js";
+import { hasArtifactSuffix, MIGRATED_ARTIFACT_DIR } from "../layout/resolve.js";
 export const RESUME_ELIGIBLE_DECISION = "resume-eligible";
 export const EVALUATOR_ACTOR = "agent:resume-evaluator";
 export const CACHE_DIR_NAME = ".deft-cache";
@@ -258,7 +258,7 @@ export function evaluate(expr, ctx) {
     throw new ResumeGrammarError(`unknown composition op ${JSON.stringify(expr.op)}`);
 }
 function countPending(projectRoot) {
-    const folder = join(resolve(projectRoot), "vbrief", PENDING_LIFECYCLE_DIR);
+    const folder = join(resolve(projectRoot), MIGRATED_ARTIFACT_DIR, PENDING_LIFECYCLE_DIR);
     try {
         if (!statSync(folder).isDirectory())
             return 0;

package/dist/session/ritual-sentinel.d.ts

@@ -3,7 +3,7 @@ export declare const RITUAL_STATE_SCHEMA_VERSION = 1;
 export declare const SENTINEL_RELPATH: readonly [".deft", "last-session.json"];
 export declare const RITUAL_STATE_RELPATH: readonly [".deft", "ritual-state.json"];
 export declare const MIN_RESUME_AGE_MS: number;
-export declare const ACTIVE_VBRIEF_PREFIX = "vbrief/active/";
+export declare const ACTIVE_VBRIEF_PREFIX: string;
 export interface Sentinel {
     readonly schemaVersion: number;
     readonly deftVersion: string;

package/dist/session/ritual-sentinel.js

@@ -1,6 +1,6 @@
 import { closeSync, existsSync, fdatasyncSync, mkdirSync, openSync, readdirSync, readFileSync, renameSync, statSync, writeSync, } from "node:fs";
 import { join, relative, resolve } from "node:path";
-import { hasArtifactSuffix } from "../layout/resolve.js";
+import { hasArtifactSuffix, LEGACY_ARTIFACT_DIR, MIGRATED_ARTIFACT_DIR, } from "../layout/resolve.js";
 import { stableJson } from "./json.js";
 import { parseTimestamp, timestampIso } from "./time.js";
 export const SCHEMA_VERSION = 1;
@@ -8,7 +8,7 @@ export const RITUAL_STATE_SCHEMA_VERSION = 1;
 export const SENTINEL_RELPATH = [".deft", "last-session.json"];
 export const RITUAL_STATE_RELPATH = [".deft", "ritual-state.json"];
 export const MIN_RESUME_AGE_MS = 2 * 60 * 60 * 1000;
-export const ACTIVE_VBRIEF_PREFIX = "vbrief/active/";
+export const ACTIVE_VBRIEF_PREFIX = `${MIGRATED_ARTIFACT_DIR}/active/`;
 export function ritualStatePath(projectRoot) {
     return join(resolve(projectRoot), ...RITUAL_STATE_RELPATH);
 }
@@ -249,7 +249,9 @@ export function writeSentinel(projectRoot, input) {
         schemaVersion: SCHEMA_VERSION,
         deftVersion: input.deftVersion,
         timestamp: timestampIso(instant),
-        lastActiveVbrief: input.lastActiveVbrief.replace(/\\/g, "/"),
+        lastActiveVbrief: input.lastActiveVbrief
+            .replace(/\\/g, "/")
+            .replace(`${LEGACY_ARTIFACT_DIR}/active/`, `${MIGRATED_ARTIFACT_DIR}/active/`),
         lastBranch: input.lastBranch,
     };
     atomicWriteJson(sentinelFile, payload, ".last-session.");
@@ -290,7 +292,7 @@ export function computeResumeSignal(sentinel, now, projectRoot) {
         `${elapsedLabel} ago. Resume? Run \`task vbrief:show ${lastActive}\`.`);
 }
 export function detectLatestActiveVbrief(projectRoot) {
-    const activeDir = join(resolve(projectRoot), "vbrief", "active");
+    const activeDir = join(resolve(projectRoot), MIGRATED_ARTIFACT_DIR, "active");
     try {
         if (!existsSync(activeDir)) {
             return null;

package/dist/slice/constants.d.ts

@@ -14,5 +14,5 @@ export declare const CHILD_ALLOWED_FIELDS: Set<"n" | "url" | "wave" | "role">;
 export declare const UUID_RE: RegExp;
 export declare const ISO8601_RE: RegExp;
 export declare const WAVE_FLAG_RE: RegExp;
-export declare const PROJECT_ROOT_SENTINELS: readonly ["vbrief", ".git"];
+export declare const PROJECT_ROOT_SENTINELS: readonly ["xbrief", "vbrief", ".git"];
 //# sourceMappingURL=constants.d.ts.map

package/dist/slice/constants.js

@@ -26,5 +26,5 @@ export const CHILD_ALLOWED_FIELDS = new Set(CHILD_REQUIRED_FIELDS);
 export const UUID_RE = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
 export const ISO8601_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?Z$/;
 export const WAVE_FLAG_RE = /^--wave-(\d+)(?:=(.*))?$/;
-export const PROJECT_ROOT_SENTINELS = ["vbrief", ".git"];
+export const PROJECT_ROOT_SENTINELS = ["xbrief", "vbrief", ".git"];
 //# sourceMappingURL=constants.js.map

package/dist/slice/project-context.js

@@ -77,7 +77,7 @@ export function resolveRootAndRepo(cliProjectRoot, cliRepo, requireRepo) {
 export function formatMissingRootError() {
     return ("error: cannot determine project root. Pass --project-root PATH, " +
         "set $DEFT_PROJECT_ROOT, or run from inside a directory tree that " +
-        "contains vbrief/ or .git/ (#535).");
+        "contains xbrief/ or .git/ (#535).");
 }
 export function formatMissingRepoError() {
     return ("error: cannot determine repo slug. Pass --repo OWNER/NAME, " +

package/dist/spec-authority/resolver.js

@@ -5,8 +5,15 @@ import { SPEC_RENDER_BANNER } from "../render/constants.js";
 import { contentHasGeneratedPdSource, contentHasGeneratedSpecSource, EXPORT_SPEC_PD_BANNER, GENERATED_SPEC_PURPOSE, } from "./constants.js";
 export function resolveSpecAuthority(projectRoot) {
     const root = projectRoot;
-    const layout = resolveLifecycleLayout(root);
-    const vbriefDir = resolveLifecycleRoot(root);
+    let layout;
+    let vbriefDir;
+    try {
+        layout = resolveLifecycleLayout(root);
+        vbriefDir = resolveLifecycleRoot(root);
+    }
+    catch {
+        return null; // No xbrief/ layout; spec authority unavailable.
+    }
     const projectDefPath = resolveProjectDefinitionPath(root);
     if (!existsSync(projectDefPath))
         return null;

package/dist/swarm/complete-cohort.js

@@ -230,7 +230,20 @@ function completeParent(parentPath, vbriefDir, projectRoot, settled, dryRun) {
     };
 }
 export function sweepCohort(storyPaths, projectRoot, dryRun) {
-    const vbriefDir = resolveLifecycleRoot(projectRoot);
+    let vbriefDir;
+    try {
+        vbriefDir = resolveLifecycleRoot(projectRoot);
+    }
+    catch {
+        return {
+            project_root: resolve(projectRoot),
+            dry_run: dryRun,
+            stories: [],
+            parents: [],
+            errors: [],
+            ok: true,
+        };
+    }
     const result = {
         project_root: resolve(projectRoot),
         dry_run: dryRun,

package/dist/swarm/readiness.js

@@ -1,7 +1,7 @@
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { basename, join, resolve } from "node:path";
 import { referenceTypeMatches } from "@deftai/directive-types";
-import { ARTIFACT_SUFFIXES, hasArtifactSuffix, LIFECYCLE_DIR_NAMES, resolveLifecycleLayout, resolveLifecycleRoot, stripArtifactSuffix, } from "../layout/resolve.js";
+import { ARTIFACT_SUFFIXES, hasArtifactSuffix, LEGACY_ARTIFACT_DIR, LIFECYCLE_DIR_NAMES, MIGRATED_ARTIFACT_DIR, MIGRATED_ARTIFACT_SUFFIX, MIGRATED_INFO_ROOT_KEY, resolveLifecycleLayout, resolveLifecycleRoot, stripArtifactSuffix, } from "../layout/resolve.js";
 import { acceptanceTextsFromItems, asStrList, deprecatedSubitemsIssues, itemHasTraces, itemsHaveAcceptance, missingRequiredSwarmFields, storyQualityIssues, } from "../vbrief-validation/story-quality.js";
 import { LIFECYCLE_FOLDERS, READY } from "./constants.js";
 function loadJson(path) {
@@ -26,7 +26,31 @@ function projectRel(projectRoot, path) {
     }
 }
 function expandPaths(projectRoot, patterns) {
-    const layout = resolveLifecycleLayout(projectRoot);
+    // Use the canonical xbrief layout; re-throw only if a legacy vbrief/-only tree is detected (#2112).
+    let layout;
+    try {
+        layout = resolveLifecycleLayout(projectRoot);
+    }
+    catch (err) {
+        const xbriefDir = join(projectRoot, MIGRATED_ARTIFACT_DIR);
+        if (existsSync(xbriefDir)) {
+            // xbrief/ dir exists but has no artifacts yet -- treat as valid (empty) layout.
+            layout = {
+                root: xbriefDir,
+                artifactDir: MIGRATED_ARTIFACT_DIR,
+                artifactSuffix: MIGRATED_ARTIFACT_SUFFIX,
+                infoRootKey: MIGRATED_INFO_ROOT_KEY,
+                migrated: true,
+            };
+        }
+        else if (existsSync(join(projectRoot, LEGACY_ARTIFACT_DIR))) {
+            throw err; // Legacy-only project: operator must run deft migrate:xbrief.
+        }
+        else {
+            // Neither exists -- return empty list.
+            return [];
+        }
+    }
     const usePatterns = patterns.length > 0 ? patterns : [`${layout.artifactDir}/active/*${layout.artifactSuffix}`];
     const out = [];
     const seen = new Set();
@@ -210,7 +234,13 @@ function acceptanceCountJustification(plan, swarm) {
 }
 function allScopeIds(projectRoot) {
     const ids = new Map();
-    const vbriefDir = resolveLifecycleRoot(projectRoot);
+    let vbriefDir;
+    try {
+        vbriefDir = resolveLifecycleRoot(projectRoot);
+    }
+    catch {
+        return ids; // No xbrief/ layout; no scope IDs.
+    }
     for (const folder of LIFECYCLE_FOLDERS) {
         const dir = join(vbriefDir, folder);
         if (!existsSync(dir)) {

package/dist/task-surface/index.js

@@ -72,10 +72,10 @@ export function runChangeInit(projectRoot, name, io) {
         return 1;
     }
     mkdirSync(join(base, "specs"), { recursive: true });
-    writeFileSync(join(base, "proposal.vbrief.json"), `${JSON.stringify(proposalTemplate(trimmed), null, 2)}\n`, "utf8");
-    writeFileSync(join(base, "tasks.vbrief.json"), `${JSON.stringify(tasksTemplate(trimmed), null, 2)}\n`, "utf8");
+    writeFileSync(join(base, "proposal.xbrief.json"), `${JSON.stringify(proposalTemplate(trimmed), null, 2)}\n`, "utf8");
+    writeFileSync(join(base, "tasks.xbrief.json"), `${JSON.stringify(tasksTemplate(trimmed), null, 2)}\n`, "utf8");
     io.writeOut(`OK: Created change proposal at ${base}/\n`);
-    for (const file of ["proposal.vbrief.json", "tasks.vbrief.json", "specs/"]) {
+    for (const file of ["proposal.xbrief.json", "tasks.xbrief.json", "specs/"]) {
         io.writeOut(`  - ${file}\n`);
     }
     return 0;

package/dist/triage/actions/candidates-log.d.ts

@@ -1,7 +1,7 @@
 import { resolveCandidatesLogPath } from "../cache-path.js";
 import type { AuditEntry, CandidatesLog } from "./types.js";
 /** Display/back-compat constant; resolution flows through resolveTriageCachePath (#1703). */
-export declare const AUDIT_LOG_REL_PATH = "vbrief/.triage-cache/candidates.jsonl";
+export declare const AUDIT_LOG_REL_PATH = "xbrief/.triage-cache/candidates.jsonl";
 export { resolveCandidatesLogPath };
 /** Read every well-formed audit-log row in insertion order (#1698 shared reader). */
 export declare function readAuditLog(logPath: string, repo?: string | null): AuditEntry[];