@deftai/directive-core 0.61.1 → 0.62.0

package/dist/check-updates/index.d.ts

@@ -0,0 +1,49 @@
+/** Default subprocess timeout for `git ls-remote` (seconds). */
+export declare const REMOTE_PROBE_DEFAULT_TIMEOUT = 5;
+/** Baked-in canonical upstream (#1320). Never probe consumer origin. */
+export declare const DEFT_UPSTREAM_URL = "https://github.com/deftai/directive.git";
+/** Reject git ls-remote targets that could be parsed as options (#CodeQL). */
+export declare function isSafeGitLsRemoteTarget(url: string): boolean;
+/** Return a trimmed upstream URL safe for `git ls-remote`, or null when rejected. */
+export declare function sanitizeGitLsRemoteTarget(url: string): string | null;
+export type RemoteProbeStatus = "ok" | "behind" | "skipped" | "no-upstream" | "no-tags" | "error";
+export interface RemoteProbeResult {
+    readonly status: RemoteProbeStatus;
+    readonly current: string;
+    readonly remote?: string;
+    readonly upstream_url?: string;
+    readonly reason?: string;
+    readonly error?: string;
+}
+export type SemverKey = readonly [number, number, number, number, string];
+export interface GitRunner {
+    lsRemoteTags(upstreamUrl: string, timeoutMs: number): string[] | "timeout" | "os-error";
+}
+export declare function parseSemverTag(tag: string): SemverKey | null;
+export declare function maxSemverTag(tags: readonly string[]): string | null;
+export declare function resolveProbeCurrentVersion(projectRoot: string, frameworkRoot?: string): string;
+export declare function resolveUpstreamUrl(projectRoot: string): string;
+export declare function resolveProbeTimeout(env?: NodeJS.ProcessEnv): number;
+export declare function noNetworkActive(env?: NodeJS.ProcessEnv): boolean;
+export declare function parseLsRemoteTags(stdout: string): string[];
+export declare function defaultGitRunner(): GitRunner;
+export interface RunRemoteProbeOptions {
+    readonly projectRoot: string;
+    readonly frameworkRoot?: string;
+    readonly env?: NodeJS.ProcessEnv;
+    readonly git?: GitRunner;
+}
+export declare function runRemoteProbe(options: RunRemoteProbeOptions): RemoteProbeResult;
+export interface EmitCheckUpdatesOptions {
+    readonly jsonMode: boolean;
+    readonly writeOut: (text: string) => void;
+}
+export declare function emitCheckUpdates(result: RemoteProbeResult, options: EmitCheckUpdatesOptions): number;
+export declare function runCheckUpdates(argv: readonly string[], options?: {
+    projectRoot?: string;
+    frameworkRoot?: string;
+    env?: NodeJS.ProcessEnv;
+    git?: GitRunner;
+    writeOut?: (text: string) => void;
+}): number;
+//# sourceMappingURL=index.d.ts.map

package/dist/check-updates/index.js

@@ -0,0 +1,323 @@
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { manifestTagToVersion, parseInstallManifest } from "../doctor/manifest.js";
+import { resolveVersion } from "../doctor/paths.js";
+/** Default subprocess timeout for `git ls-remote` (seconds). */
+export const REMOTE_PROBE_DEFAULT_TIMEOUT = 5.0;
+/** Baked-in canonical upstream (#1320). Never probe consumer origin. */
+export const DEFT_UPSTREAM_URL = "https://github.com/deftai/directive.git";
+const MANIFEST_UPSTREAM_URL_KEYS = [
+    "source_url",
+    "url",
+    "upstream_url",
+    "upstream",
+    "origin",
+];
+/** Reject git ls-remote targets that could be parsed as options (#CodeQL). */
+export function isSafeGitLsRemoteTarget(url) {
+    return sanitizeGitLsRemoteTarget(url) !== null;
+}
+/** Return a trimmed upstream URL safe for `git ls-remote`, or null when rejected. */
+export function sanitizeGitLsRemoteTarget(url) {
+    const trimmed = url.trim();
+    if (!trimmed || trimmed.startsWith("-")) {
+        return null;
+    }
+    if (/^https?:\/\/\S+$/i.test(trimmed)) {
+        return trimmed;
+    }
+    if (/^git@[\w.-]+:[\w./-]+\.git$/i.test(trimmed)) {
+        return trimmed;
+    }
+    return null;
+}
+function normalizePrereleaseForSort(pre) {
+    const dot = pre.indexOf(".");
+    if (dot <= 0) {
+        return pre;
+    }
+    const kind = pre.slice(0, dot).toLowerCase();
+    if (kind !== "alpha" && kind !== "beta" && kind !== "rc") {
+        return pre;
+    }
+    const afterKind = pre.slice(dot + 1);
+    let numEnd = 0;
+    while (numEnd < afterKind.length) {
+        const ch = afterKind[numEnd];
+        if (ch === undefined || ch < "0" || ch > "9") {
+            break;
+        }
+        numEnd += 1;
+    }
+    if (numEnd === 0) {
+        return pre;
+    }
+    const padded = afterKind.slice(0, numEnd).padStart(8, "0");
+    return `${kind}.${padded}${afterKind.slice(numEnd)}`;
+}
+const SEMVER_TAG_RE = /^v?(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)(?<pre>-[\w][\w.-]*)?$/;
+export function parseSemverTag(tag) {
+    if (!tag) {
+        return null;
+    }
+    const match = SEMVER_TAG_RE.exec(tag.trim());
+    if (!match?.groups) {
+        return null;
+    }
+    const pre = match.groups.pre ?? "";
+    const preStripped = pre.replace(/^-/, "");
+    return [
+        Number(match.groups.major),
+        Number(match.groups.minor),
+        Number(match.groups.patch),
+        pre ? 0 : 1,
+        normalizePrereleaseForSort(preStripped),
+    ];
+}
+export function maxSemverTag(tags) {
+    const parsed = [];
+    for (const tag of tags) {
+        const key = parseSemverTag(tag);
+        if (key !== null) {
+            parsed.push({ key, tag });
+        }
+    }
+    if (parsed.length === 0) {
+        return null;
+    }
+    parsed.sort((a, b) => {
+        for (let i = 0; i < a.key.length; i += 1) {
+            const av = a.key[i];
+            const bv = b.key[i];
+            if (typeof av === "number" && typeof bv === "number" && av !== bv) {
+                return av - bv;
+            }
+            if (typeof av === "string" && typeof bv === "string" && av !== bv) {
+                return av < bv ? -1 : 1;
+            }
+        }
+        return 0;
+    });
+    return parsed[parsed.length - 1]?.tag ?? null;
+}
+function readVendoredManifest(projectRoot) {
+    for (const candidate of [
+        join(projectRoot, ".deft", "core", "VERSION"),
+        join(projectRoot, ".deft", "VERSION"),
+        join(projectRoot, "deft", "VERSION"),
+    ]) {
+        if (!existsSync(candidate)) {
+            continue;
+        }
+        try {
+            return parseInstallManifest(readFileSync(candidate, "utf8"));
+        }
+        catch { }
+    }
+    return null;
+}
+export function resolveProbeCurrentVersion(projectRoot, frameworkRoot) {
+    const manifest = readVendoredManifest(projectRoot);
+    if (manifest) {
+        const derived = manifestTagToVersion(manifest);
+        if (derived) {
+            return derived;
+        }
+    }
+    return resolveVersion(frameworkRoot).replace(/^v/, "");
+}
+export function resolveUpstreamUrl(projectRoot) {
+    const manifest = readVendoredManifest(projectRoot);
+    if (manifest) {
+        for (const key of MANIFEST_UPSTREAM_URL_KEYS) {
+            const value = manifest[key];
+            if (typeof value === "string" && value.trim()) {
+                const safe = sanitizeGitLsRemoteTarget(value);
+                if (safe) {
+                    return safe;
+                }
+            }
+        }
+    }
+    return DEFT_UPSTREAM_URL;
+}
+export function resolveProbeTimeout(env = process.env) {
+    const raw = (env.DEFT_REMOTE_PROBE_TIMEOUT ?? "").trim();
+    if (!raw) {
+        return REMOTE_PROBE_DEFAULT_TIMEOUT;
+    }
+    const value = Number(raw);
+    if (!Number.isFinite(value) || value <= 0) {
+        return REMOTE_PROBE_DEFAULT_TIMEOUT;
+    }
+    return value;
+}
+export function noNetworkActive(env = process.env) {
+    return (env.DEFT_NO_NETWORK ?? "").trim() === "1";
+}
+export function parseLsRemoteTags(stdout) {
+    const tags = [];
+    for (const line of stdout.split("\n")) {
+        const marker = "\trefs/tags/";
+        const idx = line.indexOf(marker);
+        if (idx < 0) {
+            continue;
+        }
+        const tag = line.slice(idx + marker.length).trim();
+        if (tag) {
+            tags.push(tag);
+        }
+    }
+    return tags;
+}
+export function defaultGitRunner() {
+    return {
+        lsRemoteTags(upstreamUrl, timeoutMs) {
+            const safeUrl = sanitizeGitLsRemoteTarget(upstreamUrl);
+            if (!safeUrl) {
+                return "os-error";
+            }
+            try {
+                const stdout = execFileSync("git", ["ls-remote", "--tags", "--refs", "--", safeUrl], {
+                    encoding: "utf8",
+                    timeout: timeoutMs,
+                });
+                return parseLsRemoteTags(stdout);
+            }
+            catch (exc) {
+                if (exc instanceof Error &&
+                    (exc.message.includes("ETIMEDOUT") || exc.message.includes("timed out"))) {
+                    return "timeout";
+                }
+                return "os-error";
+            }
+        },
+    };
+}
+export function runRemoteProbe(options) {
+    const env = options.env ?? process.env;
+    const current = resolveProbeCurrentVersion(options.projectRoot, options.frameworkRoot);
+    if (noNetworkActive(env)) {
+        return {
+            status: "skipped",
+            reason: "DEFT_NO_NETWORK=1",
+            current,
+        };
+    }
+    const timeoutSec = resolveProbeTimeout(env);
+    const upstreamUrl = resolveUpstreamUrl(options.projectRoot);
+    const git = options.git ?? defaultGitRunner();
+    const tagsResult = git.lsRemoteTags(upstreamUrl, Math.ceil(timeoutSec * 1000));
+    if (tagsResult === "timeout") {
+        return {
+            status: "error",
+            current,
+            upstream_url: upstreamUrl,
+            error: "timeout",
+        };
+    }
+    if (tagsResult === "os-error") {
+        return {
+            status: "error",
+            current,
+            upstream_url: upstreamUrl,
+            error: "Error: git unavailable",
+        };
+    }
+    const remoteTag = maxSemverTag(tagsResult);
+    if (remoteTag === null) {
+        return {
+            status: "no-tags",
+            current,
+            upstream_url: upstreamUrl,
+        };
+    }
+    const remoteKey = parseSemverTag(remoteTag);
+    const currentKey = parseSemverTag(current.startsWith("v") ? current : `v${current}`);
+    if (currentKey !== null && remoteKey !== null && compareSemverKeys(remoteKey, currentKey) > 0) {
+        return {
+            status: "behind",
+            current,
+            remote: remoteTag,
+            upstream_url: upstreamUrl,
+        };
+    }
+    return {
+        status: "ok",
+        current,
+        remote: remoteTag,
+        upstream_url: upstreamUrl,
+    };
+}
+function compareSemverKeys(a, b) {
+    for (let i = 0; i < a.length; i += 1) {
+        const av = a[i];
+        const bv = b[i];
+        if (av === bv) {
+            continue;
+        }
+        if (typeof av === "number" && typeof bv === "number") {
+            return av - bv;
+        }
+        return String(av) < String(bv) ? -1 : 1;
+    }
+    return 0;
+}
+export function emitCheckUpdates(result, options) {
+    if (options.jsonMode) {
+        const payload = {
+            status: result.status,
+            current: result.current,
+        };
+        if (result.remote !== undefined) {
+            payload.remote = result.remote;
+        }
+        if (result.upstream_url !== undefined) {
+            payload.upstream_url = result.upstream_url;
+        }
+        if (result.reason !== undefined) {
+            payload.reason = result.reason;
+        }
+        if (result.error !== undefined) {
+            payload.error = result.error;
+        }
+        options.writeOut(`${JSON.stringify(payload, Object.keys(payload).sort())}\n`);
+    }
+    else {
+        const current = result.current;
+        switch (result.status) {
+            case "ok":
+                options.writeOut(`OK upstream=${result.remote}\n`);
+                break;
+            case "behind":
+                options.writeOut(`BEHIND upstream=${result.remote} current=v${current} commits-behind=unknown\n`);
+                break;
+            case "skipped":
+                options.writeOut(`SKIPPED reason=DEFT_NO_NETWORK current=v${current}\n`);
+                break;
+            case "no-upstream":
+                options.writeOut(`NO-UPSTREAM current=v${current}\n`);
+                break;
+            case "no-tags":
+                options.writeOut(`NO-TAGS current=v${current} upstream=${result.upstream_url ?? ""}\n`);
+                break;
+            default:
+                options.writeOut(`ERROR current=v${current} upstream=${result.upstream_url ?? ""} error=${result.error ?? "unknown"}\n`);
+                break;
+        }
+    }
+    return result.status === "behind" ? 1 : 0;
+}
+export function runCheckUpdates(argv, options = {}) {
+    const jsonMode = argv.includes("--json");
+    const result = runRemoteProbe({
+        projectRoot: options.projectRoot ?? process.cwd(),
+        frameworkRoot: options.frameworkRoot,
+        env: options.env,
+        git: options.git,
+    });
+    const writeOut = options.writeOut ?? ((text) => process.stdout.write(text));
+    return emitCheckUpdates(result, { jsonMode, writeOut });
+}
+//# sourceMappingURL=index.js.map

package/dist/init-deposit/init-deposit.js

@@ -14,6 +14,7 @@ import { resolveInstalledContentRoot } from "../deposit/resolve-content.js";
 import { readCorePackageVersion } from "../engine-version.js";
 import { ensureInitGitignoreLines, reconstituteDepositFromContent } from "./gitignore.js";
 import { buildLegacyRefusalJson, buildLegacyRefusalMessage, detectLegacyLayout, LEGACY_LAYOUT_REFUSED_EXIT_CODE, LegacyLayoutRefusedError, } from "./legacy-detect.js";
+import { printMigrateNudgeIfNeeded } from "./migrate.js";
 import { CANONICAL_INSTALL_ROOT, depositNeutralization, ensureTaskfile, writeAgentsMd, writeAgentsSkills, writeConsumerGitHooks, writeConsumerVbrief, writeInstallManifest, } from "./scaffold.js";
 export function parseInitArgv(canonicalArgv, userArgv = []) {
     const args = [...canonicalArgv, ...userArgv];
@@ -109,6 +110,7 @@ export function printNextSteps(result, io) {
     io.printf("  2. Deft skill auto-discovery is partially implemented — if your agent doesn't\n");
     io.printf('     start setup automatically, tell it: "Use AGENTS.md"\n');
     io.printf("  3. On first session, the agent will guide you through creating USER.md and PROJECT-DEFINITION.vbrief.json\n");
+    printMigrateNudgeIfNeeded(result.projectDir, io);
     io.printf("\n");
 }
 export async function runInitDeposit(args, io, seams = {}) {

package/dist/init-deposit/migrate.d.ts

@@ -85,4 +85,13 @@ export interface RunMigrateCliOptions {
  * stderr; config errors print to stderr; success prints to stdout.
  */
 export declare function runMigrateCli(options: RunMigrateCliOptions): number;
+/** One-line nudge for init/update/session completion when provenance is unstamped (#2059). */
+export declare const MIGRATE_COMPLETION_NUDGE = "[deft] One-time: run `directive migrate` to stamp npm provenance (idempotent). See content/UPGRADING.md.";
+/** True when a canonical-vendored deposit exists and lacks the npm-managed sentinel. */
+export declare function shouldEmitMigrateNudge(projectRoot: string, seams?: Pick<MigrateSeams, "isFile" | "readText">): boolean;
+export interface MigrateNudgeIo {
+    printf: (text: string) => void;
+}
+/** Prints {@link MIGRATE_COMPLETION_NUDGE} when {@link shouldEmitMigrateNudge} is true. */
+export declare function printMigrateNudgeIfNeeded(projectRoot: string, io: MigrateNudgeIo, seams?: Pick<MigrateSeams, "isFile" | "readText">): void;
 //# sourceMappingURL=migrate.d.ts.map

package/dist/init-deposit/migrate.js

@@ -193,4 +193,27 @@ export function runMigrateCli(options) {
     }
     return result.exitCode;
 }
+/** One-line nudge for init/update/session completion when provenance is unstamped (#2059). */
+export const MIGRATE_COMPLETION_NUDGE = "[deft] One-time: run `directive migrate` to stamp npm provenance (idempotent). See content/UPGRADING.md.";
+/** True when a canonical-vendored deposit exists and lacks the npm-managed sentinel. */
+export function shouldEmitMigrateNudge(projectRoot, seams = {}) {
+    const isFile = seams.isFile ?? existsSync;
+    const readText = seams.readText ?? defaultReadText;
+    const manifestPath = detectCanonicalVendoredManifest(projectRoot, isFile);
+    if (manifestPath === null)
+        return false;
+    const text = readText(manifestPath);
+    if (text === null)
+        return false;
+    const manifest = parseInstallManifest(text);
+    if (Object.keys(manifest).length === 0)
+        return false;
+    return !isNpmManaged(manifest);
+}
+/** Prints {@link MIGRATE_COMPLETION_NUDGE} when {@link shouldEmitMigrateNudge} is true. */
+export function printMigrateNudgeIfNeeded(projectRoot, io, seams = {}) {
+    if (shouldEmitMigrateNudge(projectRoot, seams)) {
+        io.printf(`\n${MIGRATE_COMPLETION_NUDGE}\n`);
+    }
+}
 //# sourceMappingURL=migrate.js.map

package/dist/init-deposit/refresh.js

@@ -18,6 +18,7 @@ import { DEV_FALLBACK } from "../platform/constants.js";
 import { gitPorcelain } from "../story-ready/git.js";
 import { parseInitArgv } from "./init-deposit.js";
 import { buildLegacyRefusalJson, buildLegacyRefusalMessage, detectLegacyLayout, LEGACY_LAYOUT_REFUSED_EXIT_CODE, LegacyLayoutRefusedError, } from "./legacy-detect.js";
+import { printMigrateNudgeIfNeeded } from "./migrate.js";
 import { CANONICAL_INSTALL_ROOT, depositNeutralization, writeAgentsMd, writeInstallManifest, } from "./scaffold.js";
 const INSTALLER_MANAGED_EXACT = new Set([
     "AGENTS.md",
@@ -231,6 +232,7 @@ export function printUpdateComplete(result, io) {
     if (result.versionSkewNotice) {
         io.printf(`\n${result.versionSkewNotice}\n`);
     }
+    printMigrateNudgeIfNeeded(result.projectDir, io);
     io.printf("\n");
 }
 export async function runRefreshDeposit(args, io, seams = {}) {

package/dist/install-upgrade/index.js

@@ -6,7 +6,7 @@ import { buildInstallManifestText, CANONICAL_INSTALL_ROOT, } from "../init-depos
 import { agentsRefreshPlan } from "../platform/agents-md.js";
 import { DEV_FALLBACK } from "../platform/constants.js";
 import { resolveVersion } from "../platform/resolve-version.js";
-import { detectPreCutoverLegacy } from "../vbrief-validate/precutover.js";
+import { detectPreCutoverLegacy, frozenPreCutoverMigrationGuidance, } from "../vbrief-validate/precutover.js";
 const ENGINE_PACKAGE_FALLBACK = "0.0.0";
 /**
  * Resolve the framework version for an upgrade (#2053).
@@ -193,7 +193,7 @@ export function runInstallUpgrade(args, io) {
     }
     const legacy = detectPreCutoverLegacy(projectRoot);
     if (legacy.length > 0) {
-        io.writeOut(`Pre-v0.20 document model detected (${legacy.join(", ")}). Run \`task migrate:vbrief\` first -- it migrates legacy artifacts and creates the lifecycle folder structure. This command only records the framework version.\n`);
+        io.writeOut(`Pre-v0.20 document model detected (${legacy.join(", ")}). ${frozenPreCutoverMigrationGuidance()}\n`);
     }
     const vbriefDir = join(projectRoot, "vbrief");
     const targetDir = existsSync(vbriefDir) && statSync(vbriefDir).isDirectory() ? vbriefDir : projectRoot;
@@ -216,7 +216,7 @@ export function runInstallUpgrade(args, io) {
     else {
         io.writeOut(`Updated .deft-version from ${recorded} to ${normalizedVersion}.\n`);
     }
-    io.writeOut("If legacy SPECIFICATION.md or PROJECT.md content remains, run `task migrate:vbrief` to complete the upgrade.\n");
+    io.writeOut(`If legacy SPECIFICATION.md or PROJECT.md content remains, see UPGRADING.md § Frozen pre-v0.20 document-model migration (#2068).\n`);
     return runAgentsRefresh(projectRoot, agentsRoot, io);
 }
 //# sourceMappingURL=index.js.map

package/dist/migrate-preflight/index.d.ts

@@ -18,11 +18,10 @@ export type MigratePreflightOutcome = {
     readonly exitCode: 0 | 1;
     readonly results: readonly CheckResult[];
 } | MigratePreflightConfigError;
-export declare function checkUv(which?: (cmd: string) => string | null): CheckResult;
 export declare function checkLayout(deftRoot: string, projectRoot: string): CheckResult;
 export declare function checkGitClean(projectRoot: string): CheckResult;
 export declare function checkDocumentModel(projectRoot: string): CheckResult;
-export declare function evaluate(deftRoot: string, projectRoot: string, which?: (cmd: string) => string | null): {
+export declare function evaluate(deftRoot: string, projectRoot: string): {
     exitCode: 0 | 1;
     results: CheckResult[];
 };

package/dist/migrate-preflight/index.js

@@ -1,8 +1,7 @@
 import { execFileSync } from "node:child_process";
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { join, resolve } from "node:path";
-import { defaultWhich } from "../scm/binary.js";
-import { detectPreCutoverLegacy, isCurrentGeneratedSpecification, isGeneratedSpecificationExport, missingLifecycleFolders, } from "../vbrief-validate/precutover.js";
+import { detectPreCutoverLegacy, frozenPreCutoverMigrationGuidance, isCurrentGeneratedSpecification, isGeneratedSpecificationExport, missingLifecycleFolders, } from "../vbrief-validate/precutover.js";
 function resolveContentRoot(frameworkRoot) {
     const nested = join(frameworkRoot, "content");
     try {
@@ -14,25 +13,7 @@ function resolveContentRoot(frameworkRoot) {
     }
     return frameworkRoot;
 }
-export function checkUv(which = defaultWhich) {
-    if (which("uv") !== null) {
-        return { name: "uv", status: "PASS", message: "uv is on PATH." };
-    }
-    return {
-        name: "uv",
-        status: "FAIL",
-        message: "uv is not on PATH. Install from https://docs.astral.sh/uv/ and re-run.",
-    };
-}
 export function checkLayout(deftRoot, projectRoot) {
-    const migrator = join(deftRoot, "scripts", "migrate_vbrief.py");
-    if (!existsSync(migrator) || !statSync(migrator).isFile()) {
-        return {
-            name: "layout",
-            status: "FAIL",
-            message: `Migrator script missing at ${migrator}. The framework checkout appears incomplete or pre-v0.20; refresh per deft/QUICK-START.md.`,
-        };
-    }
     const schemasDir = join(resolveContentRoot(deftRoot), "vbrief", "schemas");
     if (!existsSync(schemasDir) || !statSync(schemasDir).isDirectory()) {
         return {
@@ -46,13 +27,13 @@ export function checkLayout(deftRoot, projectRoot) {
         return {
             name: "layout",
             status: "WARN",
-            message: `Project vbrief/ not present at ${projectVbrief} -- migrator will create it on first run; this is expected for greenfield projects.`,
+            message: `Project vbrief/ not present at ${projectVbrief} -- expected for greenfield projects.`,
         };
     }
     return {
         name: "layout",
         status: "PASS",
-        message: `Framework migrator + schemas present; project vbrief/ at ${projectVbrief}.`,
+        message: `Framework schemas present; project vbrief/ at ${projectVbrief}.`,
     };
 }
 export function checkGitClean(projectRoot) {
@@ -65,7 +46,7 @@ export function checkGitClean(projectRoot) {
             return {
                 name: "git-clean",
                 status: "WARN",
-                message: "Working tree is dirty. The migrator will refuse to run without --force; preview with `task migrate:vbrief -- --dry-run` first.",
+                message: "Working tree is dirty. Commit or stash before running a frozen-release migration.",
             };
         }
         return { name: "git-clean", status: "PASS", message: "Working tree is clean." };
@@ -76,7 +57,7 @@ export function checkGitClean(projectRoot) {
             return {
                 name: "git-clean",
                 status: "WARN",
-                message: "git executable not on PATH; skipping working-tree check. Migrator's dirty-tree guard will still fire if applicable.",
+                message: "git executable not on PATH; skipping working-tree check.",
             };
         }
         return {
@@ -91,8 +72,8 @@ export function checkDocumentModel(projectRoot) {
     if (legacy.length > 0) {
         return {
             name: "document-model",
-            status: "PASS",
-            message: `Legacy root artifact(s) detected: ${legacy.join(", ")}.`,
+            status: "FAIL",
+            message: `Pre-v0.20 document model detected (${legacy.join(", ")}). ${frozenPreCutoverMigrationGuidance()}`,
         };
     }
     const specPath = join(projectRoot, "SPECIFICATION.md");
@@ -117,8 +98,8 @@ export function checkDocumentModel(projectRoot) {
         if (isCurrentGeneratedSpecification(projectRoot, content)) {
             return {
                 name: "document-model",
-                status: "FAIL",
-                message: "Current generated SPECIFICATION.md detected (source: vbrief/specification.vbrief.json); `task migrate:vbrief` is not needed.",
+                status: "PASS",
+                message: "Current generated SPECIFICATION.md detected (source: vbrief/specification.vbrief.json); pre-v0.20 migration is not needed.",
             };
         }
     }
@@ -128,20 +109,19 @@ export function checkDocumentModel(projectRoot) {
         if (missing.length > 0) {
             return {
                 name: "document-model",
-                status: "PASS",
-                message: `Partial vBRIEF layout detected; missing lifecycle folder(s): ${missing.join(", ")}.`,
+                status: "FAIL",
+                message: `Partial vBRIEF layout detected; missing lifecycle folder(s): ${missing.join(", ")}. Create the folders or follow ${frozenPreCutoverMigrationGuidance()}`,
             };
         }
     }
     return {
         name: "document-model",
-        status: "WARN",
-        message: "No legacy root SPECIFICATION.md/PROJECT.md artifacts detected. Migration may have nothing to do.",
+        status: "PASS",
+        message: "No pre-v0.20 document-model artifacts detected.",
     };
 }
-export function evaluate(deftRoot, projectRoot, which = defaultWhich) {
+export function evaluate(deftRoot, projectRoot) {
     const results = [
-        checkUv(which),
         checkLayout(deftRoot, projectRoot),
         checkDocumentModel(projectRoot),
         checkGitClean(projectRoot),
@@ -183,10 +163,10 @@ export function emitMigratePreflight(outcome, io, quiet) {
             io.writeOut(line);
     }
     if (outcome.exitCode === 1) {
-        io.writeErr("migrate:preflight FAILED -- resolve the FAIL line(s) above before running `task migrate:vbrief`.\n");
+        io.writeErr("migrate:preflight FAILED -- pre-v0.20 document model or incomplete vBRIEF layout. Resolve using UPGRADING.md § Frozen pre-v0.20 document-model migration (#2068).\n");
     }
     else {
-        io.writeOut("migrate:preflight OK -- environment ready for `task migrate:vbrief`.\n");
+        io.writeOut("migrate:preflight OK -- no pre-v0.20 document-model migration required.\n");
     }
     return outcome.exitCode;
 }

package/dist/render/framework-commands.js

@@ -42,7 +42,6 @@ export const COMMANDS = {
     "triage:accept": spec("triage:accept", "triage_actions:main", { defaultArgs: ["accept"] }),
     "triage:status": spec("triage:status", "triage_actions:main", { defaultArgs: ["status"] }),
     "triage:scope": spec("triage:scope", "triage_scope:main"),
-    "migrate:vbrief": spec("migrate:vbrief", "framework_commands:_cmd_migrate_vbrief"),
     "cache:fetch-all": spec("cache:fetch-all", "cache:main", { defaultArgs: ["fetch-all"] }),
     "capacity:show": spec("capacity:show", "capacity_show:main", {
         projectRootArg: "--project-root",

package/dist/session/session-start.js

@@ -1,4 +1,6 @@
 import { randomUUID } from "node:crypto";
+import { runningInsideDeftRepo } from "../doctor/paths.js";
+import { MIGRATE_COMPLETION_NUDGE, shouldEmitMigrateNudge } from "../init-deposit/migrate.js";
 import { disclosureLine } from "../policy/disclosure.js";
 import { resolvePolicy } from "../policy/resolve.js";
 import { runDefaultMode } from "../triage/welcome/default-mode.js";
@@ -263,6 +265,9 @@ export function runSessionStart(projectRoot, options = {}) {
             lines.push(message);
         }
     }
+    if (!runningInsideDeftRepo(projectRoot) && shouldEmitMigrateNudge(projectRoot)) {
+        lines.push(MIGRATE_COMPLETION_NUDGE);
+    }
     const payload = newRitualStatePayload({
         sessionId: (options.newSessionId ?? randomUUID)(),
         gitHead: gitHeadValue,

package/dist/umbrella-current-shape/index.d.ts

@@ -0,0 +1,87 @@
+/** Matches `## Current shape (as of pass-N)` — same pattern as vbrief-reconcile/umbrellas.ts. */
+export declare const CURRENT_SHAPE_HEADER_RE: RegExp;
+export declare const SECTION_MARKERS: {
+    readonly lastUpdated: RegExp;
+    readonly lastPassType: RegExp;
+    readonly childCount: RegExp;
+    readonly childCountHistory: RegExp;
+    readonly openChildren: RegExp;
+    readonly closedChildren: RegExp;
+    readonly waveOrder: RegExp;
+    readonly openQuestions: RegExp;
+    readonly readingOrder: RegExp;
+};
+export type SectionKey = keyof typeof SECTION_MARKERS;
+/** Required per AGENTS.md #1152; openQuestions is optional. */
+export declare const REQUIRED_SECTIONS: readonly SectionKey[];
+export declare const OPTIONAL_SECTIONS: readonly SectionKey[];
+export interface IssueComment {
+    readonly id: number;
+    readonly body: string;
+    readonly htmlUrl: string;
+    readonly updatedAt: string;
+}
+export interface CurrentShapeComment extends IssueComment {
+    readonly pass: number;
+}
+export interface SectionPresence {
+    readonly present: SectionKey[];
+    readonly missing: SectionKey[];
+    readonly optionalPresent: SectionKey[];
+    readonly optionalMissing: SectionKey[];
+}
+export interface CurrentShapeResult {
+    readonly issueNumber: number;
+    readonly repo: string;
+    readonly commentId: number;
+    readonly htmlUrl: string;
+    readonly pass: number;
+    readonly body: string;
+    readonly sections: SectionPresence;
+}
+export type ScmFetcher = (repo: string, issueNumber: number) => IssueComment[] | {
+    error: string;
+};
+export interface RunCurrentShapeOptions {
+    readonly issueNumber: number;
+    readonly projectRoot: string;
+    readonly repo?: string | null;
+    readonly jsonMode?: boolean;
+    readonly strict?: boolean;
+    readonly fetchComments?: ScmFetcher;
+    readonly writeOut?: (text: string) => void;
+    readonly writeErr?: (text: string) => void;
+}
+/** Merge `gh api --paginate` concatenated JSON array pages into comment rows. */
+export declare function parseCommentsFromGhStdout(stdout: string): IssueComment[];
+export declare function extractPassFromBody(body: string): number | null;
+/** Pick the canonical comment — highest pass-N; tie-break by comment id (latest). */
+export declare function selectCurrentShapeComment(comments: readonly IssueComment[]): CurrentShapeComment | null;
+export declare function detectSections(body: string): SectionPresence;
+export declare function sectionsRecord(presence: SectionPresence): Record<string, boolean>;
+export declare const NO_CURRENT_SHAPE_MESSAGE: string;
+export declare function fetchCurrentShape(options: {
+    repo: string;
+    issueNumber: number;
+    fetchComments?: ScmFetcher;
+}): {
+    ok: true;
+    result: CurrentShapeResult;
+} | {
+    ok: false;
+    error: string;
+    kind: "not-found" | "config";
+};
+export declare function emitCurrentShape(result: CurrentShapeResult, options: {
+    jsonMode: boolean;
+    writeOut: (text: string) => void;
+}): number;
+export declare function runCurrentShape(options: RunCurrentShapeOptions): number;
+export declare function parseCurrentShapeArgv(argv: readonly string[]): {
+    issueNumber: number | null;
+    repo: string | null;
+    jsonMode: boolean;
+    strict: boolean;
+    passthroughError?: string;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/umbrella-current-shape/index.js

@@ -0,0 +1,329 @@
+import { spawnSync } from "node:child_process";
+import { resolveBinary } from "../scm/binary.js";
+import { SUBPROCESS_MAX_BUFFER } from "../subprocess/max-buffer.js";
+import { resolveRepo } from "../triage/queue/repo.js";
+/** Matches `## Current shape (as of pass-N)` — same pattern as vbrief-reconcile/umbrellas.ts. */
+export const CURRENT_SHAPE_HEADER_RE = /^## Current shape \(as of pass-(\d+)\)/m;
+export const SECTION_MARKERS = {
+    lastUpdated: /^Last updated:\s/m,
+    lastPassType: /^Last pass type:\s/m,
+    childCount: /^Child count:\s/m,
+    childCountHistory: /^Child-count history:\s/m,
+    openChildren: /^### Open children\s*$/m,
+    closedChildren: /^### Closed children\s*$/m,
+    waveOrder: /^### Wave order\s*$/m,
+    openQuestions: /^### Open questions\s*$/m,
+    readingOrder: /^### Reading order for fresh contributors\s*$/m,
+};
+/** Required per AGENTS.md #1152; openQuestions is optional. */
+export const REQUIRED_SECTIONS = [
+    "lastUpdated",
+    "lastPassType",
+    "childCount",
+    "childCountHistory",
+    "openChildren",
+    "closedChildren",
+    "waveOrder",
+    "readingOrder",
+];
+export const OPTIONAL_SECTIONS = ["openQuestions"];
+function mapCommentEntry(entry) {
+    if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+        return null;
+    }
+    const rec = entry;
+    if (typeof rec.id !== "number" || typeof rec.body !== "string") {
+        return null;
+    }
+    return {
+        id: rec.id,
+        body: rec.body,
+        htmlUrl: typeof rec.html_url === "string" ? rec.html_url : "",
+        updatedAt: typeof rec.updated_at === "string" ? rec.updated_at : "",
+    };
+}
+/** Merge `gh api --paginate` concatenated JSON array pages into comment rows. */
+export function parseCommentsFromGhStdout(stdout) {
+    const comments = [];
+    const text = stdout.trim();
+    if (!text) {
+        return comments;
+    }
+    const pages = [];
+    try {
+        pages.push(JSON.parse(text));
+    }
+    catch {
+        let idx = 0;
+        while (idx < text.length) {
+            while (idx < text.length && /\s/.test(text[idx] ?? "")) {
+                idx += 1;
+            }
+            if (idx >= text.length) {
+                break;
+            }
+            const slice = text.slice(idx);
+            if (!slice.startsWith("[")) {
+                break;
+            }
+            let depth = 0;
+            let end = -1;
+            for (let j = 0; j < slice.length; j += 1) {
+                const ch = slice[j];
+                if (ch === "[") {
+                    depth += 1;
+                }
+                else if (ch === "]") {
+                    depth -= 1;
+                    if (depth === 0) {
+                        end = j + 1;
+                        break;
+                    }
+                }
+            }
+            if (end < 0) {
+                throw new SyntaxError("invalid paginated JSON");
+            }
+            pages.push(JSON.parse(slice.slice(0, end)));
+            idx += end;
+        }
+    }
+    for (const page of pages) {
+        if (!Array.isArray(page)) {
+            continue;
+        }
+        for (const entry of page) {
+            const mapped = mapCommentEntry(entry);
+            if (mapped !== null) {
+                comments.push(mapped);
+            }
+        }
+    }
+    return comments;
+}
+function defaultFetchComments(repo, issueNumber) {
+    const binary = resolveBinary();
+    const path = `repos/${repo}/issues/${issueNumber}/comments?per_page=100`;
+    const proc = spawnSync(binary, ["api", "--paginate", path], {
+        encoding: "utf8",
+        maxBuffer: SUBPROCESS_MAX_BUFFER,
+    });
+    if (proc.error !== undefined) {
+        return {
+            error: `fetch comments #${issueNumber} (${repo}) failed: ${proc.error.message}`,
+        };
+    }
+    if (proc.status !== 0) {
+        return {
+            error: `fetch comments #${issueNumber} (${repo}) failed: ${(proc.stderr || proc.stdout || "").trim()}`,
+        };
+    }
+    try {
+        return parseCommentsFromGhStdout(String(proc.stdout ?? ""));
+    }
+    catch (exc) {
+        return {
+            error: `fetch comments #${issueNumber} (${repo}) returned non-JSON: ${String(exc)}`,
+        };
+    }
+}
+export function extractPassFromBody(body) {
+    const match = CURRENT_SHAPE_HEADER_RE.exec(body);
+    if (!match?.[1]) {
+        return null;
+    }
+    const pass = Number(match[1]);
+    return Number.isFinite(pass) ? pass : null;
+}
+/** Pick the canonical comment — highest pass-N; tie-break by comment id (latest). */
+export function selectCurrentShapeComment(comments) {
+    let best = null;
+    for (const comment of comments) {
+        const pass = extractPassFromBody(comment.body);
+        if (pass === null) {
+            continue;
+        }
+        const candidate = { ...comment, pass };
+        if (best === null ||
+            candidate.pass > best.pass ||
+            (candidate.pass === best.pass && candidate.id > best.id)) {
+            best = candidate;
+        }
+    }
+    return best;
+}
+export function detectSections(body) {
+    const present = [];
+    const missing = [];
+    const optionalPresent = [];
+    const optionalMissing = [];
+    for (const key of REQUIRED_SECTIONS) {
+        if (SECTION_MARKERS[key].test(body)) {
+            present.push(key);
+        }
+        else {
+            missing.push(key);
+        }
+    }
+    for (const key of OPTIONAL_SECTIONS) {
+        if (SECTION_MARKERS[key].test(body)) {
+            optionalPresent.push(key);
+        }
+        else {
+            optionalMissing.push(key);
+        }
+    }
+    return { present, missing, optionalPresent, optionalMissing };
+}
+export function sectionsRecord(presence) {
+    const out = {};
+    for (const key of REQUIRED_SECTIONS) {
+        out[key] = presence.present.includes(key);
+    }
+    for (const key of OPTIONAL_SECTIONS) {
+        out[key] = presence.optionalPresent.includes(key);
+    }
+    return out;
+}
+export const NO_CURRENT_SHAPE_MESSAGE = "No ## Current shape (as of pass-N) comment found on this issue. " +
+    "Create one per AGENTS.md ## Umbrella current-shape convention (#1152) — " +
+    "do not fall back to the issue body (stale by design).";
+export function fetchCurrentShape(options) {
+    const fetcher = options.fetchComments ?? defaultFetchComments;
+    const fetched = fetcher(options.repo, options.issueNumber);
+    if (!Array.isArray(fetched)) {
+        return { ok: false, error: fetched.error, kind: "config" };
+    }
+    const selected = selectCurrentShapeComment(fetched);
+    if (selected === null) {
+        return { ok: false, error: NO_CURRENT_SHAPE_MESSAGE, kind: "not-found" };
+    }
+    const sections = detectSections(selected.body);
+    return {
+        ok: true,
+        result: {
+            issueNumber: options.issueNumber,
+            repo: options.repo,
+            commentId: selected.id,
+            htmlUrl: selected.htmlUrl,
+            pass: selected.pass,
+            body: selected.body,
+            sections,
+        },
+    };
+}
+export function emitCurrentShape(result, options) {
+    if (options.jsonMode) {
+        const payload = {
+            issueNumber: result.issueNumber,
+            repo: result.repo,
+            commentId: result.commentId,
+            htmlUrl: result.htmlUrl,
+            pass: result.pass,
+            body: result.body,
+            sections: sectionsRecord(result.sections),
+            missingSections: result.sections.missing,
+            missingOptionalSections: result.sections.optionalMissing,
+        };
+        options.writeOut(`${JSON.stringify(payload)}\n`);
+    }
+    else {
+        options.writeOut(`${result.body}\n`);
+    }
+    return 0;
+}
+export function runCurrentShape(options) {
+    const writeOut = options.writeOut ?? ((text) => process.stdout.write(text));
+    const writeErr = options.writeErr ?? ((text) => process.stderr.write(text));
+    if (!Number.isInteger(options.issueNumber) || options.issueNumber <= 0) {
+        writeErr("umbrella:current-shape: issue number must be a positive integer\n");
+        return 2;
+    }
+    const repo = resolveRepo(options.repo ?? null, options.projectRoot);
+    if (repo === null) {
+        writeErr("umbrella:current-shape: could not resolve owner/repo — pass --repo OWNER/REPO or run inside a git repo with origin\n");
+        return 2;
+    }
+    const fetched = fetchCurrentShape({
+        repo,
+        issueNumber: options.issueNumber,
+        fetchComments: options.fetchComments,
+    });
+    if (!fetched.ok) {
+        writeErr(`umbrella:current-shape: ${fetched.error}\n`);
+        return fetched.kind === "config" ? 2 : 1;
+    }
+    if (options.strict === true && fetched.result.sections.missing.length > 0) {
+        writeErr(`umbrella:current-shape: --strict: missing required section(s): ${fetched.result.sections.missing.join(", ")}\n`);
+        return 1;
+    }
+    return emitCurrentShape(fetched.result, {
+        jsonMode: options.jsonMode ?? false,
+        writeOut,
+    });
+}
+export function parseCurrentShapeArgv(argv) {
+    let issueNumber = null;
+    let repo = null;
+    let jsonMode = false;
+    let strict = false;
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i] ?? "";
+        if (arg === "--json") {
+            jsonMode = true;
+        }
+        else if (arg === "--strict") {
+            strict = true;
+        }
+        else if (arg === "--repo") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return {
+                    issueNumber,
+                    repo,
+                    jsonMode,
+                    strict,
+                    passthroughError: "argument --repo: expected one argument",
+                };
+            }
+            repo = value;
+            i += 1;
+        }
+        else if (arg.startsWith("--repo=")) {
+            repo = arg.slice("--repo=".length);
+        }
+        else if (arg.startsWith("-")) {
+            return {
+                issueNumber,
+                repo,
+                jsonMode,
+                strict,
+                passthroughError: `unknown flag: ${arg}`,
+            };
+        }
+        else if (issueNumber === null) {
+            const parsed = Number(arg);
+            if (!Number.isInteger(parsed) || parsed <= 0) {
+                return {
+                    issueNumber,
+                    repo,
+                    jsonMode,
+                    strict,
+                    passthroughError: `invalid issue number: ${arg}`,
+                };
+            }
+            issueNumber = parsed;
+        }
+        else {
+            return {
+                issueNumber,
+                repo,
+                jsonMode,
+                strict,
+                passthroughError: `unexpected positional argument: ${arg}`,
+            };
+        }
+    }
+    return { issueNumber, repo, jsonMode, strict };
+}
+//# sourceMappingURL=index.js.map

package/dist/vbrief-validate/precutover.d.ts

@@ -16,6 +16,9 @@ export interface PrecutoverDetection {
     reasons: string[];
 }
 export declare function detectPreCutover(projectRoot: string): PrecutoverDetection;
+/** Last release that ships `scripts/migrate_vbrief.py` on the consumer deposit path (#2068). */
+export declare const FROZEN_PRECUTOVER_MIGRATION_TAG = "v0.59.0";
+export declare function frozenPreCutoverMigrationGuidance(): string;
 export declare function renderPrecutoverLine(projectRoot: string): string;
 export { isFullSpecState, isGreenfieldSpecExport };
 //# sourceMappingURL=precutover.d.ts.map

package/dist/vbrief-validate/precutover.js

@@ -98,13 +98,20 @@ export function detectPreCutover(projectRoot) {
     }
     return { preCutover: reasons.length > 0, reasons };
 }
+/** Last release that ships `scripts/migrate_vbrief.py` on the consumer deposit path (#2068). */
+export const FROZEN_PRECUTOVER_MIGRATION_TAG = "v0.59.0";
+export function frozenPreCutoverMigrationGuidance() {
+    return (`Current npm releases no longer ship in-product \`task migrate:vbrief\`. Pin framework ${FROZEN_PRECUTOVER_MIGRATION_TAG} ` +
+        `(frozen Go installer or git tag), install Python 3.11+ and uv, run \`task migrate:vbrief\` once from that payload, ` +
+        `then upgrade to current npm. See UPGRADING.md § Frozen pre-v0.20 document-model migration (#2068).`);
+}
 export function renderPrecutoverLine(projectRoot) {
     const { preCutover, reasons } = detectPreCutover(projectRoot);
     if (!preCutover) {
         return "Pre-cutover: none -- project is on the current vBRIEF document model.";
     }
     const summary = reasons.join("; ").replace(/\r?\n/g, " ");
-    return `Pre-cutover: migration needed -- ${summary}. Run \`deft migrate:vbrief\` to migrate.`;
+    return `Pre-cutover: migration needed -- ${summary}. ${frozenPreCutoverMigrationGuidance()}`;
 }
 // Re-export for classify callers (#2013).
 export { isFullSpecState, isGreenfieldSpecExport };

package/dist/verify-env/verify-hooks-installed.d.ts

@@ -16,6 +16,8 @@ export interface EvaluateOptions {
     readonly gitConfigReader?: GitConfigReader;
     readonly platform?: NodeJS.Platform;
 }
+/** Drop shell ``#`` comment lines before pattern scans (#2049 shipped-hook false positives). */
+export declare function stripShellCommentLines(content: string): string;
 /** Pure evaluator mirroring scripts/verify_hooks_installed.py::evaluate. */
 export declare function evaluate(projectRoot: string, options?: EvaluateOptions): EvaluateResult;
 //# sourceMappingURL=verify-hooks-installed.d.ts.map

package/dist/verify-env/verify-hooks-installed.js

@@ -69,15 +69,31 @@ function readHookContent(hookPath) {
         return null;
     }
 }
+/** Drop shell ``#`` comment lines before pattern scans (#2049 shipped-hook false positives). */
+export function stripShellCommentLines(content) {
+    return content
+        .split(/\r?\n/)
+        .filter((line) => !/^\s*#/.test(line))
+        .join("\n");
+}
+function executableHookBody(content) {
+    return stripShellCommentLines(content);
+}
 function usesLegacyPythonDispatch(content) {
-    return LEGACY_HOOK_PATTERNS.some((pattern) => pattern.test(content));
+    const body = executableHookBody(content);
+    return LEGACY_HOOK_PATTERNS.some((pattern) => pattern.test(body));
 }
 function hookInvokesDeftCli(content, requiredCommands) {
-    if (!/\bdeft\b/.test(content))
+    const body = executableHookBody(content);
+    if (!/\bdeft\b/.test(body))
         return false;
     if (usesLegacyPythonDispatch(content))
         return false;
-    return requiredCommands.every((cmd) => content.includes(cmd));
+    return requiredCommands.every((cmd) => body.includes(cmd));
+}
+function prePushInvokesVerifyBranch(content) {
+    const body = executableHookBody(content);
+    return /\bdeft\s+verify:branch\b/.test(body);
 }
 function validateHookContent(hookName, content, requiredCommands) {
     if (content === null) {
@@ -176,7 +192,7 @@ export function evaluate(projectRoot, options = {}) {
             stream: "stderr",
         };
     }
-    if (prePushContent?.includes("verify:branch")) {
+    if (prePushContent && prePushInvokesVerifyBranch(prePushContent)) {
         return {
             code: 1,
             message: "❌ deft hooks wired but NON-FUNCTIONAL: pre-push must not invoke verify:branch (#1814).\n" +

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deftai/directive-core",
-  "version": "0.61.1",
+  "version": "0.62.0",
   "description": "TypeScript engine core for the Directive framework.",
   "type": "module",
   "main": "./dist/index.js",
@@ -194,6 +194,14 @@
       "types": "./dist/migrate-preflight/index.d.ts",
       "default": "./dist/migrate-preflight/index.js"
     },
+    "./check-updates": {
+      "types": "./dist/check-updates/index.d.ts",
+      "default": "./dist/check-updates/index.js"
+    },
+    "./umbrella-current-shape": {
+      "types": "./dist/umbrella-current-shape/index.d.ts",
+      "default": "./dist/umbrella-current-shape/index.js"
+    },
     "./install-upgrade": {
       "types": "./dist/install-upgrade/index.d.ts",
       "default": "./dist/install-upgrade/index.js"
@@ -221,8 +229,8 @@
     "provenance": true
   },
   "dependencies": {
-    "@deftai/directive-content": "^0.61.1",
-    "@deftai/directive-types": "^0.61.1"
+    "@deftai/directive-content": "^0.62.0",
+    "@deftai/directive-types": "^0.62.0"
   },
   "scripts": {
     "build": "tsc -b",