@deftai/directive-core 0.99.0 → 0.100.0

package/dist/session/verify-session-ritual.js

@@ -1,5 +1,7 @@
 import { existsSync } from "node:fs";
+import { readCorePackageVersion } from "../engine-version.js";
 import { formatFrameworkCommand } from "../render/framework-commands.js";
+import { checkActiveCliAgainstTarget, } from "./active-cli.js";
 import { defaultGitRunner, gitHead, gitIsAncestor, worktreePath } from "./git.js";
 import { pythonJsonDump } from "./json.js";
 import { ENV_SESSION_POSTURE, readOnlyPostureMessage, resolveSessionPosture, ritualStateIsPostureAuthority, } from "./posture.js";
@@ -389,6 +391,37 @@ export function verifySessionRitual(projectRoot, options = {}) {
                 ritualStateRequired,
             };
         }
+        // #3233: after gated entrypoints, verify the shell-active deft/directive
+        // is not a stale higher-precedence shadow of a multi-prefix install.
+        // Independent target = explicit option, else in-process publishable engine
+        // (never the active CLI's own version — see resolveDefaultActiveCliTarget).
+        const targetEngineVersion = options.targetEngineVersion ?? null;
+        const checkActiveCli = options.checkActiveCli ?? checkActiveCliAgainstTarget;
+        let inProcessVersion = null;
+        try {
+            inProcessVersion = readCorePackageVersion();
+        }
+        catch {
+            inProcessVersion = null;
+        }
+        const activeCliSeams = {
+            inProcessVersion,
+            ...options.activeCliSeams,
+        };
+        const activeCli = checkActiveCli(targetEngineVersion, activeCliSeams);
+        if (!activeCli.ok) {
+            return {
+                code: activeCli.code === 0 ? 1 : activeCli.code,
+                message: activeCli.lines.length > 0 ? activeCli.lines.join("\n") : activeCli.message,
+                tier,
+                statePath,
+                bypassed: false,
+                wouldFailCode: null,
+                posture,
+                ritualStateRequired,
+                recoveryTier: "cold",
+            };
+        }
     }
     const evaluated = evaluateLoadedState(projectRoot, state, {
         tier,

package/dist/story-ready/evaluate.d.ts

@@ -1,4 +1,5 @@
 import { type PathLike } from "node:fs";
+import { type ParentLineageResult } from "../scope/parent-lineage.js";
 import { type ParsedAllocation, parseAllocationSection, SOLO_KIND, SWARM_COHORT_KIND } from "./allocation.js";
 export declare const ACTIVE_FOLDER = "active";
 export declare const ELIGIBLE_STATUS = "running";
@@ -7,17 +8,27 @@ export interface EvaluateResult {
     readonly exitCode: 0 | 1 | 2;
     readonly message: string;
     readonly dispatchKind: string | null;
+    /** #3241 parent-lineage probe (present when vBRIEF checks ran). */
+    readonly parentLineage?: ParentLineageResult;
 }
 export interface EvaluateOptions {
     readonly gitStatus?: string | null;
     readonly allocationContext?: string | null;
     readonly allowDirty?: boolean;
     readonly parsed?: ParsedAllocation;
+    /** Project root for resolving child planRef → parent (#3241). */
+    readonly projectRoot?: string;
+    /** Skip parent-lineage check (tests / opt-out). Default false. */
+    readonly skipParentLineage?: boolean;
 }
 /**
  * Pure evaluator — returns exit code + human message. Faithful to
  * `scripts/preflight_story_start.evaluate`.
+ *
+ * #3241: after structural active+running checks, re-check parent requirement
+ * lineage (coverage map + behavioral deltas) when the parent authors IDs.
  */
 export declare function evaluate(vbriefPath: PathLike, options?: EvaluateOptions): EvaluateResult;
+export { evaluateParentLineage, formatParentLineageLine, type ParentLineageResult, } from "../scope/parent-lineage.js";
 export { parseAllocationSection, SOLO_KIND, SWARM_COHORT_KIND };
 //# sourceMappingURL=evaluate.d.ts.map

package/dist/story-ready/evaluate.js

@@ -1,5 +1,6 @@
 import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
+import { evaluateParentLineage, formatParentLineageLine, } from "../scope/parent-lineage.js";
 import { parseAllocationSection, SOLO_KIND, SWARM_COHORT_KIND, VALID_DISPATCH_KINDS, } from "./allocation.js";
 export const ACTIVE_FOLDER = "active";
 export const ELIGIBLE_STATUS = "running";
@@ -66,7 +67,7 @@ function checkVbrief(vbriefPath) {
                 "is eligible for a story start",
         };
     }
-    return { ok: true };
+    return { ok: true, path, payload: payload };
 }
 function readyMessage(treeNote, suffix) {
     return `OK: ready to start -- ${treeNote}, vBRIEF active+running, ${suffix}`;
@@ -116,6 +117,9 @@ function classifyAllocation(fields, treeNote) {
 /**
  * Pure evaluator — returns exit code + human message. Faithful to
  * `scripts/preflight_story_start.evaluate`.
+ *
+ * #3241: after structural active+running checks, re-check parent requirement
+ * lineage (coverage map + behavioral deltas) when the parent authors IDs.
  */
 export function evaluate(vbriefPath, options = {}) {
     const gitStatus = options.gitStatus ?? null;
@@ -147,15 +151,49 @@ export function evaluate(vbriefPath, options = {}) {
             message: `not ready: ${vbriefCheck.reason}.`,
         };
     }
+    // #3241 parent lineage (fail closed when parent authors IDs and child lacks coverage).
+    const lineage = evaluateParentLineage({
+        child: vbriefCheck.payload,
+        childPath: vbriefCheck.path,
+        projectRoot: options.projectRoot,
+        skip: options.skipParentLineage === true,
+    });
+    if (!lineage.ok) {
+        return {
+            exitCode: 1,
+            dispatchKind: null,
+            parentLineage: lineage,
+            message: `not ready: ${lineage.message}` +
+                (lineage.defect_class !== null ? ` [defect_class=${lineage.defect_class}]` : "") +
+                `\n${formatParentLineageLine(lineage)}`,
+        };
+    }
+    const lineageNote = lineage.applicable
+        ? `parent lineage OK (${lineage.parent_requirement_ids.length} req IDs` +
+            (lineage.negative_invariant_ids.length > 0
+                ? `, ${lineage.negative_invariant_ids.length} negative invariants`
+                : "") +
+            ")"
+        : null;
     const [found, fields] = options.parsed ?? parseAllocationSection(options.allocationContext ?? null);
     if (!found) {
+        const base = readyMessage(treeNote, "no `## Allocation context` section (solo path, #1371 carve-out).");
         return {
             exitCode: 0,
             dispatchKind: null,
-            message: readyMessage(treeNote, "no `## Allocation context` section (solo path, #1371 carve-out)."),
+            parentLineage: lineage,
+            message: lineageNote !== null ? `${base.replace(/\.$/, "")}; ${lineageNote}.` : base,
         };
     }
-    return classifyAllocation(fields, treeNote);
+    const classified = classifyAllocation(fields, treeNote);
+    return {
+        ...classified,
+        parentLineage: lineage,
+        message: classified.exitCode === 0 && lineageNote !== null
+            ? `${classified.message.replace(/\.$/, "")}; ${lineageNote}.`
+            : classified.message,
+    };
 }
+export { evaluateParentLineage, formatParentLineageLine, } from "../scope/parent-lineage.js";
 export { parseAllocationSection, SOLO_KIND, SWARM_COHORT_KIND };
 //# sourceMappingURL=evaluate.js.map

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

@@ -1,6 +1,5 @@
 import { resolveCandidatesLogPath } from "../cache-path.js";
-import type { AuditEntry, CandidatesLog } from "./types.js";
-/** Display/back-compat constant; resolution flows through resolveTriageCachePath (#1703). */
+import type { AuditEntry, CandidatesLog } from "./types.js"; /** Display/back-compat constant; resolution flows through resolveTriageCachePath (#1703). */
 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). */

package/dist/triage/actions/candidates-log.js

@@ -1,9 +1,9 @@
 import { randomUUID } from "node:crypto";
-import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { dirname, isAbsolute, relative, resolve } from "node:path";
+import { containedWrite } from "../../fs/contained-write.js";
 import { resolveCandidatesLogPath, TRIAGE_CANDIDATES_LOG_REL_PATH } from "../cache-path.js";
 import { CandidatesLogError } from "./errors.js";
-/** Display/back-compat constant; resolution flows through resolveTriageCachePath (#1703). */
 export const AUDIT_LOG_REL_PATH = TRIAGE_CANDIDATES_LOG_REL_PATH;
 export { resolveCandidatesLogPath };
 const VALID_DECISIONS = new Set([
@@ -108,6 +108,32 @@ function resolveLogPath(projectRoot, override) {
     }
     return resolveCandidatesLogPath(projectRoot);
 }
+/**
+ * Containment root for candidates-log product writes (#3245).
+ * Prefer project root when the log is nested under it; otherwise parent dir
+ * (matches intake candidates-log parity for override paths outside the tree).
+ */
+function containmentRootForLog(projectRoot, logPath) {
+    const rootAbs = resolve(projectRoot);
+    const logAbs = resolve(logPath);
+    const parent = dirname(logAbs);
+    mkdirSync(parent, { recursive: true });
+    const rel = relative(rootAbs, logAbs);
+    if (rel.length > 0 && !rel.startsWith("..") && !isAbsolute(rel)) {
+        return rootAbs;
+    }
+    return resolve(parent);
+}
+/** #3245 / #2980: product append refuses leaf symlink follow (in-tree or escape). */
+function appendAuditLine(projectRoot, logPath, line) {
+    const root = containmentRootForLog(projectRoot, logPath);
+    containedWrite({
+        root,
+        target: logPath,
+        data: line.endsWith("\n") ? line : `${line}\n`,
+        mode: "append",
+    });
+}
 function stableStringify(entry) {
     const sortedKeys = Object.keys(entry).sort();
     const sorted = {};
@@ -186,8 +212,7 @@ export function createCandidatesLog(defaultProjectRoot) {
         append(entry, options) {
             validateEntry(entry);
             const logPath = resolveLogPath(defaultProjectRoot, options?.path);
-            mkdirSync(join(logPath, ".."), { recursive: true });
-            appendFileSync(logPath, `${stableStringify(entry)}\n`, { encoding: "utf8" });
+            appendAuditLine(defaultProjectRoot, logPath, `${stableStringify(entry)}\n`);
             return entry.decision_id;
         },
         latestDecision(issueNumber, repo, options) {
@@ -225,7 +250,13 @@ export function rollbackAuditEntry(decisionId, projectRoot, logPathOverride) {
         }
     }
     if (removed) {
-        writeFileSync(path, kept.join(""), { encoding: "utf8" });
+        // #3245: replace rewrite also refuses leaf symlink follow.
+        containedWrite({
+            root: containmentRootForLog(projectRoot, path),
+            target: path,
+            data: kept.join(""),
+            mode: "replace",
+        });
     }
     return removed;
 }

package/dist/xbrief-migrate/migrate-project.d.ts

@@ -24,6 +24,10 @@ export type XbriefMigrationOutcome = {
     readonly kind: "migrated";
     readonly backupDir: string;
     readonly files: number;
+} | {
+    readonly kind: "rewritten";
+    readonly files: number;
+    readonly message: string;
 } | {
     readonly kind: "converged";
     readonly action: VbriefConvergeAction;

package/dist/xbrief-migrate/migrate-project.js

@@ -5,12 +5,12 @@ import { assertWriteTargetSafe, ProjectionContainmentError } from "../fs/project
 import { checkGitClean } from "../migrate-preflight/index.js";
 import { applyAgentsRefresh } from "../platform/agents-md.js";
 import { patchAgentsMdHeader, renderHeaderPatchSummary } from "./agents-header.js";
-import { LEGACY_ARTIFACT_DIR, LEGACY_ARTIFACT_SUFFIX, MIGRATED_ARTIFACT_DIR, MIGRATED_ARTIFACT_SUFFIX, OBSOLETE_FRAMEWORK_NARRATIVE_FILENAME, VBRIEF_DEPRECATION_MARKER_BODY, VBRIEF_DEPRECATION_MARKER_FILENAME, } from "./constants.js";
+import { LEGACY_ARTIFACT_DIR, LEGACY_ARTIFACT_SUFFIX, LEGACY_VBRIEF_VERSION, MIGRATED_ARTIFACT_DIR, MIGRATED_ARTIFACT_SUFFIX, OBSOLETE_FRAMEWORK_NARRATIVE_FILENAME, VBRIEF_DEPRECATION_MARKER_BODY, VBRIEF_DEPRECATION_MARKER_FILENAME, } from "./constants.js";
 import { detectLegacyVbriefLayout, detectXbriefConvergence } from "./detect.js";
 import { hasVbriefDeprecationMarker, isDirectory, isEffectivelyEmptyDir } from "./fs-helpers.js";
 import { assertMigrationSourceSafe } from "./migration-containment.js";
 import { renderXbriefMigrationLine, xbriefMigrationGuidance } from "./signpost.js";
-import { rewriteEmbeddedTokens, transformArtifactV06ToV08Transactional } from "./transforms.js";
+import { readDeclaredArtifactVersion, rewriteEmbeddedTokens, transformArtifactV06ToV08Transactional, } from "./transforms.js";
 function collectFiles(root, acc = []) {
     if (!isDirectory(root)) {
         return acc;
@@ -74,6 +74,65 @@ function writeMigratedFile(projectRoot, srcPath, destPath) {
         mode: "replace",
     });
 }
+/**
+ * Plan in-place hybrid envelope rewrites for xbrief lifecycle `.xbrief.json`
+ * artifacts that still declare `xBRIEFInfo@0.6` after the layout rename
+ * (#3236 / #2974). Pure probe — no writes. Already-0.8 artifacts, schema
+ * deposits, and non-0.6 JSON are skipped so residual #2368 schema-only markers
+ * still route to `directive update`.
+ */
+function planHybridEnvelopeRewrites(projectRoot) {
+    const migratedDir = join(projectRoot, MIGRATED_ARTIFACT_DIR);
+    const artifactPaths = collectFiles(migratedDir).filter((path) => path.endsWith(MIGRATED_ARTIFACT_SUFFIX));
+    const pending = [];
+    for (const filePath of artifactPaths) {
+        let parsed;
+        try {
+            parsed = JSON.parse(readFileSync(filePath, "utf8"));
+        }
+        catch (err) {
+            const detail = err instanceof Error ? err.message : String(err);
+            return {
+                ok: false,
+                error: `failed to parse hybrid envelope candidate ${relative(projectRoot, filePath)}: ${detail}`,
+            };
+        }
+        // Only residual v0.6 envelopes are rewrite candidates; skip 0.8 and unknown.
+        if (readDeclaredArtifactVersion(parsed) !== LEGACY_VBRIEF_VERSION) {
+            continue;
+        }
+        const result = transformArtifactV06ToV08Transactional(parsed);
+        if (!result.ok) {
+            return {
+                ok: false,
+                error: `failed to transform hybrid envelope ${relative(projectRoot, filePath)}: ${result.error}`,
+            };
+        }
+        if (!result.changed) {
+            continue;
+        }
+        pending.push({
+            path: filePath,
+            body: `${JSON.stringify(result.artifact, null, 2)}\n`,
+        });
+    }
+    return { ok: true, pending };
+}
+/**
+ * Apply a previously planned hybrid-envelope rewrite set via containedWrite (#3236).
+ */
+function applyHybridEnvelopeRewrites(projectRoot, pending) {
+    const root = resolve(projectRoot);
+    for (const entry of pending) {
+        containedWrite({
+            root,
+            target: entry.path,
+            data: entry.body,
+            mode: "replace",
+        });
+    }
+    return pending.length;
+}
 function backupMigrationInputs(projectRoot, legacyDir, migratedDir) {
     const stamp = new Date().toISOString().replace(/[:.]/g, "-");
     const backupRoot = join(projectRoot, ".deft", `xbrief-migrate-backup-${stamp}`);
@@ -256,6 +315,33 @@ export function runXbriefMigration(args, _io) {
         default:
             break;
     }
+    // #3236: on already-xbrief trees with no vbrief/, rewrite residual hybrid
+    // xBRIEFInfo@0.6 envelopes in place (transform accepts hybrid — #2974).
+    // Run before the layout-detection short-circuit so compact `"version":"0.6"`
+    // JSON that the string-scan may miss still gets rewritten.
+    if (convergence.xbriefHasContent && !convergence.vbriefPresent) {
+        const plan = planHybridEnvelopeRewrites(projectRoot);
+        if (!plan.ok) {
+            return { kind: "config", message: plan.error };
+        }
+        if (plan.pending.length > 0) {
+            if (!args.force) {
+                const git = checkGitClean(projectRoot);
+                if (git.status === "WARN") {
+                    return {
+                        kind: "refused",
+                        message: `${git.message} ${xbriefMigrationGuidance()} Pass --force to override.`,
+                    };
+                }
+            }
+            const files = applyHybridEnvelopeRewrites(projectRoot, plan.pending);
+            return {
+                kind: "rewritten",
+                files,
+                message: `Rewrote ${files} hybrid xBRIEFInfo@0.6 envelope(s) in place to xBRIEFInfo@0.8 under '${MIGRATED_ARTIFACT_DIR}/'.`,
+            };
+        }
+    }
     const detection = detectLegacyVbriefLayout(projectRoot);
     if (!detection.legacyLayout) {
         return {
@@ -266,7 +352,7 @@ export function runXbriefMigration(args, _io) {
     if (!isDirectory(legacyDir)) {
         // Already on canonical xbrief/ with no vbrief/ tree — residual markers (e.g. a
         // stale deposited v0.6 schema under xbrief/schemas/) are refreshed by update,
-        // not migrate:xbrief (#2368).
+        // not migrate:xbrief (#2368). Hybrid 0.6 envelopes were handled above (#3236).
         if (convergence.xbriefHasContent && !convergence.vbriefPresent) {
             return {
                 kind: "noop",
@@ -319,6 +405,9 @@ export function emitXbriefMigration(outcome, io, options = {}) {
             io.writeOut(`Migrated ${outcome.files} file(s) from ${LEGACY_ARTIFACT_DIR}/ to ${MIGRATED_ARTIFACT_DIR}/.\n` +
                 `Backup written to ${outcome.backupDir}.\n`);
             return 0;
+        case "rewritten":
+            io.writeOut(`${outcome.message}\n`);
+            return 0;
         case "converged":
             io.writeOut(`${outcome.message}\n`);
             return 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deftai/directive-core",
-  "version": "0.99.0",
+  "version": "0.100.0",
   "description": "TypeScript engine core for the Directive framework.",
   "license": "MIT",
   "type": "module",
@@ -283,6 +283,10 @@
       "types": "./dist/lifecycle/index.d.ts",
       "default": "./dist/lifecycle/index.js"
     },
+    "./literal-acceptance": {
+      "types": "./dist/literal-acceptance/index.d.ts",
+      "default": "./dist/literal-acceptance/index.js"
+    },
     "./packs": {
       "types": "./dist/packs/index.d.ts",
       "default": "./dist/packs/index.js"
@@ -366,8 +370,8 @@
     "provenance": true
   },
   "dependencies": {
-    "@deftai/directive-content": "^0.99.0",
-    "@deftai/directive-types": "^0.99.0",
+    "@deftai/directive-content": "^0.100.0",
+    "@deftai/directive-types": "^0.100.0",
     "archiver": "^8.0.0"
   },
   "scripts": {