@deftai/directive-core 0.55.1 → 0.56.0

package/dist/doctor/checks.js

@@ -1,5 +1,7 @@
 import { join } from "node:path";
+import { detectLegacyLayout, legacyLayoutSignpostLine, } from "../init-deposit/legacy-detect.js";
 import { findSkillPathsInText } from "../text/redos-safe.js";
+import { GO_BRIDGE_RELEASES_URL, UPGRADING_DOC_URL } from "./constants.js";
 import { isDeprecationRedirectStub, locateManifest, manifestCandidatePaths, manifestTagToVersion, parseInstallRootFromAgentsMd, parseManifest, } from "./manifest.js";
 import { readTextSafe } from "./paths.js";
 function readText(path, seams) {
@@ -277,6 +279,39 @@ export function checkInstallPathConsistency(projectRoot, installRoot, seams = {}
         },
     };
 }
+/**
+ * #1912: signpost a legacy on-disk layout. Carries the STABLE UPGRADING.md URL
+ * only -- no baked Go-installer version or literal upgrade command. Returns
+ * `skip` for the canonical / greenfield layout (nothing to signpost).
+ */
+export function checkLegacyLayout(projectRoot, seams = {}) {
+    const legacySeams = {
+        ...(seams.readText ? { readText: seams.readText } : {}),
+        ...(seams.isFile ? { isFile: seams.isFile } : {}),
+        ...(seams.isDir ? { isDir: seams.isDir } : {}),
+    };
+    const detection = detectLegacyLayout(projectRoot, legacySeams);
+    if (!detection.legacy) {
+        return {
+            name: "legacy-layout",
+            status: "skip",
+            detail: "No legacy Deft layout detected (canonical .deft/core/ or greenfield).",
+            data: { legacy_layout: false },
+        };
+    }
+    return {
+        name: "legacy-layout",
+        status: "fail",
+        detail: legacyLayoutSignpostLine(detection),
+        data: {
+            legacy_layout: true,
+            legacy_layout_kind: detection.kind,
+            evidence: [...detection.evidence],
+            upgrading_doc_url: UPGRADING_DOC_URL,
+            go_bridge_releases_url: GO_BRIDGE_RELEASES_URL,
+        },
+    };
+}
 export function deriveExitCode(checks, errors) {
     if (errors.length > 0 || checks.some((c) => c.status === "error")) {
         return 2;
@@ -313,6 +348,7 @@ export function runChecksImpl(projectRoot, seams = {}) {
             data: { agents_md_path: agentsMdPath },
         });
         checks.push(checkManifestAgreement(projectRoot, null, seams));
+        checks.push(checkLegacyLayout(projectRoot, seams));
         return {
             projectRoot,
             installRoot: null,
@@ -325,6 +361,7 @@ export function runChecksImpl(projectRoot, seams = {}) {
     checks.push(checkSkillPathsResolve(projectRoot, agentsMdText, seams));
     checks.push(checkManifestAgreement(projectRoot, installRoot, seams));
     checks.push(checkInstallPathConsistency(projectRoot, installRoot, seams));
+    checks.push(checkLegacyLayout(projectRoot, seams));
     return {
         projectRoot,
         installRoot,

package/dist/doctor/constants.d.ts

@@ -1,4 +1,6 @@
 export declare const UV_INSTALL_URL = "https://docs.astral.sh/uv/";
+export declare const UPGRADING_DOC_URL = "https://github.com/deftai/directive/blob/master/content/UPGRADING.md";
+export declare const GO_BRIDGE_RELEASES_URL = "https://github.com/deftai/directive/releases";
 export declare const AGENTS_MANAGED_CLOSE = "<!-- /deft:managed-section -->";
 export declare const DEPRECATED_REDIRECT_SENTINEL = "<!-- deft:deprecated-redirect -->";
 export declare const DEPRECATED_SKILL_REDIRECT_SENTINEL = "<!-- deft:deprecated-skill-redirect -->";

package/dist/doctor/constants.js

@@ -1,4 +1,12 @@
 export const UV_INSTALL_URL = "https://docs.astral.sh/uv/";
+// Stable, version-neutral upgrade signposts (#1912). Core principle: never bake
+// the upgrade command/version into the artifact being upgraded -- bake in a
+// stable pointer resolved fresh. These URLs carry NO Go-installer version and
+// NO literal upgrade command; they point at the canonical docs + the frozen
+// final Go bridge release so the npm CLI / doctor can signpost the
+// legacy -> bridge -> npm recovery without going stale.
+export const UPGRADING_DOC_URL = "https://github.com/deftai/directive/blob/master/content/UPGRADING.md";
+export const GO_BRIDGE_RELEASES_URL = "https://github.com/deftai/directive/releases";
 export const AGENTS_MANAGED_CLOSE = "<!-- /deft:managed-section -->";
 export const DEPRECATED_REDIRECT_SENTINEL = "<!-- deft:deprecated-redirect -->";
 export const DEPRECATED_SKILL_REDIRECT_SENTINEL = "<!-- deft:deprecated-skill-redirect -->";

package/dist/engine-version.d.ts

@@ -0,0 +1,3 @@
+/** Reads `@deftai/directive-core` version from the installed package.json adjacent to dist/ or src/. */
+export declare function readCorePackageVersion(): string;
+//# sourceMappingURL=engine-version.d.ts.map

package/dist/engine-version.js

@@ -0,0 +1,23 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+const FALLBACK_VERSION = "0.0.0";
+function parsePackageVersion(raw) {
+    const parsed = JSON.parse(raw);
+    if (parsed === null || typeof parsed !== "object") {
+        return FALLBACK_VERSION;
+    }
+    const version = parsed.version;
+    return typeof version === "string" && version.length > 0 ? version : FALLBACK_VERSION;
+}
+/** Reads `@deftai/directive-core` version from the installed package.json adjacent to dist/ or src/. */
+export function readCorePackageVersion() {
+    try {
+        const pkgPath = join(dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+        return parsePackageVersion(readFileSync(pkgPath, "utf8"));
+    }
+    catch {
+        return FALLBACK_VERSION;
+    }
+}
+//# sourceMappingURL=engine-version.js.map

package/dist/index.d.ts

@@ -16,6 +16,7 @@ export * as codebase from "./codebase/index.js";
 export * as doctor from "./doctor/index.js";
 export * from "./encoding/index.js";
 export * as intake from "./intake/index.js";
+export * as legacyBridge from "./legacy-bridge/index.js";
 export * as lifecycle from "./lifecycle/index.js";
 export * as orchestration from "./orchestration/index.js";
 export * as packs from "./packs/index.js";

package/dist/index.js

@@ -1,3 +1,4 @@
+import { readCorePackageVersion } from "./engine-version.js";
 /**
  * `@deftai/directive-core` — the deft directive engine core.
  *
@@ -15,6 +16,7 @@ export * as codebase from "./codebase/index.js";
 export * as doctor from "./doctor/index.js";
 export * from "./encoding/index.js";
 export * as intake from "./intake/index.js";
+export * as legacyBridge from "./legacy-bridge/index.js";
 export * as lifecycle from "./lifecycle/index.js";
 export * as orchestration from "./orchestration/index.js";
 export * as packs from "./packs/index.js";
@@ -50,6 +52,6 @@ export * as wipCap from "./wip-cap/index.js";
 export const CORE_PACKAGE = "@deftai/directive-core";
 /** Returns identifying metadata for the core engine package. */
 export function engineInfo() {
-    return { name: CORE_PACKAGE, version: "0.0.0" };
+    return { name: CORE_PACKAGE, version: readCorePackageVersion() };
 }
 //# sourceMappingURL=index.js.map

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

@@ -0,0 +1,51 @@
+/**
+ * Greenfield init `.gitignore` upkeep + deposit reconstitution (#1942 S4).
+ *
+ * Writes the canonical deft-install baseline (mirroring cmd/deft-install/setup.go
+ * EnsureGitignoreLines) and, for greenfield installs, appends `.deft/core/` so the
+ * deposit is born ignored (node_modules model). Existing tracked deposits are left
+ * alone — the vendored→hybrid un-commit is owned by #1941.
+ *
+ * Refs #1942, #1941, #1015, #1464, #1672.
+ */
+import type { InitDepositIo } from "./scaffold.js";
+/** Directory ignore entry for the hybrid deposit (greenfield only). */
+export declare const GITIGNORE_DEFT_CORE_LINE = ".deft/core/";
+/**
+ * Canonical baseline mirrored from cmd/deft-install/setup.go::canonicalGitignoreLines
+ * (excluding `.deft/core/` — that line is greenfield-only per Option B / #1941 split).
+ */
+export declare const CANONICAL_GITIGNORE_BASELINE: readonly string[];
+export interface EnsureInitGitignoreResult {
+    readonly changed: boolean;
+    readonly deftCoreIgnored: boolean;
+    readonly skippedDeftCoreBecauseTracked: boolean;
+}
+export interface ReconstituteDepositResult {
+    readonly reconstituted: boolean;
+}
+export type GitLsFiles = (projectDir: string, paths: readonly string[]) => string | null;
+/**
+ * Reports whether `.deft/core` is tracked in git. Returns `null` when git is
+ * unavailable or the tree is not a repository (treated as greenfield).
+ */
+export declare function isDepositTrackedInGit(projectDir: string, gitLsFiles?: GitLsFiles): boolean | null;
+/** Build the canonical line set for this init, honoring the Option B journey split. */
+export declare function resolveInitGitignoreLines(projectDir: string, gitLsFiles?: GitLsFiles): {
+    readonly lines: readonly string[];
+    readonly includeDeftCore: boolean;
+};
+/**
+ * Ensure the consumer `.gitignore` carries the canonical baseline plus, for
+ * greenfield installs, the `.deft/core/` ignore entry. Heals forbidden blanket
+ * `vbrief/.eval/` lines (#1464). Never un-commits a tracked deposit (#1941).
+ */
+export declare function ensureInitGitignoreLines(projectDir: string, io: InitDepositIo, options?: {
+    gitLsFiles?: GitLsFiles;
+}): EnsureInitGitignoreResult;
+/**
+ * Copy the content package into `.deft/core`, reporting whether the deposit was
+ * absent before copy (reconstitution). Always refreshes when present.
+ */
+export declare function reconstituteDepositFromContent(contentRoot: string, deftDir: string, copyContent: (src: string, dst: string) => Promise<void>): Promise<ReconstituteDepositResult>;
+//# sourceMappingURL=gitignore.d.ts.map

package/dist/init-deposit/gitignore.js

@@ -0,0 +1,200 @@
+/**
+ * Greenfield init `.gitignore` upkeep + deposit reconstitution (#1942 S4).
+ *
+ * Writes the canonical deft-install baseline (mirroring cmd/deft-install/setup.go
+ * EnsureGitignoreLines) and, for greenfield installs, appends `.deft/core/` so the
+ * deposit is born ignored (node_modules model). Existing tracked deposits are left
+ * alone — the vendored→hybrid un-commit is owned by #1941.
+ *
+ * Refs #1942, #1941, #1015, #1464, #1672.
+ */
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { FORBIDDEN_BLANKET_EVAL_LINES, stripGitignoreInlineComment, } from "../triage/bootstrap/gitignore.js";
+/** Directory ignore entry for the hybrid deposit (greenfield only). */
+export const GITIGNORE_DEFT_CORE_LINE = ".deft/core/";
+/** Alternate spellings that already cover the deposit ignore entry. */
+const DEFT_CORE_COVERING_LINES = new Set([".deft/core/", ".deft/core"]);
+/**
+ * Canonical baseline mirrored from cmd/deft-install/setup.go::canonicalGitignoreLines
+ * (excluding `.deft/core/` — that line is greenfield-only per Option B / #1941 split).
+ */
+export const CANONICAL_GITIGNORE_BASELINE = [
+    ".deft-cache/",
+    ".deft/ritual-state.json",
+    ".deft/last-session.json",
+    ".deft/routing.local.json",
+    "vbrief/.eval/candidates.jsonl",
+    "vbrief/.eval/summary-history.jsonl",
+    "vbrief/.eval/scope-lifecycle.jsonl",
+    "vbrief/.eval/decompositions/",
+    "vbrief/.eval/doctor-state.json",
+    "vbrief/*.lock",
+    ".deft/core.bak-*/",
+    ".deft/*.bak-*",
+    "*.premigrate.*",
+];
+const DEFT_FRAMEWORK_GITIGNORE_HEADER = "# Deft framework: ignore local-only caches and scratch directories\n";
+const DEFT_CORE_GITIGNORE_RATIONALE = "# Hybrid deposit (#1942): reconstituted by `directive init` like node_modules.\n" +
+    "# The vendored→hybrid un-commit for existing tracked deposits is #1941.\n";
+function defaultGitLsFiles(projectDir, paths) {
+    try {
+        return execFileSync("git", ["ls-files", "--", ...paths], {
+            cwd: projectDir,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT")
+            return null;
+        return null;
+    }
+}
+function isForbiddenBlanketEvalLine(line) {
+    return FORBIDDEN_BLANKET_EVAL_LINES.includes(line);
+}
+function gitignoreCoversLine(present, line) {
+    if (present.has(line))
+        return true;
+    if (line === GITIGNORE_DEFT_CORE_LINE) {
+        return [...DEFT_CORE_COVERING_LINES].some((candidate) => present.has(candidate));
+    }
+    return false;
+}
+function collectPresentGitignoreLines(existing) {
+    const present = new Set();
+    for (const raw of existing.split("\n")) {
+        const stripped = stripGitignoreInlineComment(raw);
+        if (stripped)
+            present.add(stripped);
+    }
+    return present;
+}
+/**
+ * Reports whether `.deft/core` is tracked in git. Returns `null` when git is
+ * unavailable or the tree is not a repository (treated as greenfield).
+ */
+export function isDepositTrackedInGit(projectDir, gitLsFiles = defaultGitLsFiles) {
+    const tracked = gitLsFiles(projectDir, [".deft/core", ".deft/core/"]);
+    if (tracked === null)
+        return null;
+    return tracked.trim().length > 0;
+}
+/** Build the canonical line set for this init, honoring the Option B journey split. */
+export function resolveInitGitignoreLines(projectDir, gitLsFiles = defaultGitLsFiles) {
+    const tracked = isDepositTrackedInGit(projectDir, gitLsFiles);
+    const includeDeftCore = tracked !== true;
+    return {
+        lines: includeDeftCore
+            ? [...CANONICAL_GITIGNORE_BASELINE, GITIGNORE_DEFT_CORE_LINE]
+            : CANONICAL_GITIGNORE_BASELINE,
+        includeDeftCore,
+    };
+}
+/**
+ * Ensure the consumer `.gitignore` carries the canonical baseline plus, for
+ * greenfield installs, the `.deft/core/` ignore entry. Heals forbidden blanket
+ * `vbrief/.eval/` lines (#1464). Never un-commits a tracked deposit (#1941).
+ */
+export function ensureInitGitignoreLines(projectDir, io, options = {}) {
+    const gitLsFiles = options.gitLsFiles ?? defaultGitLsFiles;
+    const { lines: targetLines, includeDeftCore } = resolveInitGitignoreLines(projectDir, gitLsFiles);
+    const tracked = isDepositTrackedInGit(projectDir, gitLsFiles);
+    const path = join(projectDir, ".gitignore");
+    let existing = "";
+    if (existsSync(path)) {
+        try {
+            existing = readFileSync(path, { encoding: "utf8" });
+        }
+        catch (cause) {
+            throw new Error(`could not read .gitignore: ${String(cause)}`);
+        }
+    }
+    let rawLines = existing.split("\n");
+    let trailingNewline = false;
+    if (existing.endsWith("\n") && rawLines.length > 0 && rawLines[rawLines.length - 1] === "") {
+        trailingNewline = true;
+        rawLines = rawLines.slice(0, -1);
+    }
+    const kept = [];
+    let blanketRemoved = false;
+    const present = new Set();
+    for (const raw of rawLines) {
+        const stripped = stripGitignoreInlineComment(raw);
+        if (isForbiddenBlanketEvalLine(stripped)) {
+            blanketRemoved = true;
+            continue;
+        }
+        kept.push(raw);
+        if (stripped)
+            present.add(stripped);
+    }
+    const additions = [];
+    for (const line of targetLines) {
+        if (!gitignoreCoversLine(present, line)) {
+            additions.push(line);
+        }
+    }
+    if (!blanketRemoved && additions.length === 0) {
+        io.printf(".gitignore already covers the canonical deft entries — skipping.\n");
+        return {
+            changed: false,
+            deftCoreIgnored: gitignoreCoversLine(present, GITIGNORE_DEFT_CORE_LINE),
+            skippedDeftCoreBecauseTracked: tracked === true,
+        };
+    }
+    let healed = kept.join("\n");
+    if (kept.length > 0 && trailingNewline) {
+        healed += "\n";
+    }
+    let body = healed;
+    if (additions.length > 0) {
+        if (healed !== "" && !healed.endsWith("\n")) {
+            body += "\n";
+        }
+        if (healed !== "" && !healed.endsWith("\n\n")) {
+            body += "\n";
+        }
+        body += DEFT_FRAMEWORK_GITIGNORE_HEADER;
+        if (includeDeftCore && additions.includes(GITIGNORE_DEFT_CORE_LINE)) {
+            body += DEFT_CORE_GITIGNORE_RATIONALE;
+        }
+        for (const add of additions) {
+            body += `${add}\n`;
+        }
+    }
+    try {
+        writeFileSync(path, body, { encoding: "utf8", mode: 0o644 });
+    }
+    catch (cause) {
+        throw new Error(`could not write .gitignore: ${String(cause)}`);
+    }
+    if (additions.length > 0) {
+        io.printf(`.gitignore updated with canonical entries: ${additions.join(", ")}\n`);
+    }
+    if (blanketRemoved) {
+        io.printf(".gitignore healed: removed forbidden blanket vbrief/.eval/ line (#1464).\n");
+    }
+    if (tracked === true) {
+        io.printf(".deft/core is tracked in git — leaving it tracked; vendored→hybrid un-commit is #1941.\n");
+    }
+    const finalPresent = collectPresentGitignoreLines(body);
+    return {
+        changed: true,
+        deftCoreIgnored: gitignoreCoversLine(finalPresent, GITIGNORE_DEFT_CORE_LINE),
+        skippedDeftCoreBecauseTracked: tracked === true,
+    };
+}
+/**
+ * Copy the content package into `.deft/core`, reporting whether the deposit was
+ * absent before copy (reconstitution). Always refreshes when present.
+ */
+export async function reconstituteDepositFromContent(contentRoot, deftDir, copyContent) {
+    const wasAbsent = !existsSync(deftDir);
+    await copyContent(contentRoot, deftDir);
+    return { reconstituted: wasAbsent };
+}
+//# sourceMappingURL=gitignore.js.map

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

@@ -0,0 +1,6 @@
+export * from "./init-deposit.js";
+export * from "./legacy-detect.js";
+export * from "./migrate.js";
+export * from "./refresh.js";
+export * from "./scaffold.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/init-deposit/index.js

@@ -0,0 +1,6 @@
+export * from "./init-deposit.js";
+export * from "./legacy-detect.js";
+export * from "./migrate.js";
+export * from "./refresh.js";
+export * from "./scaffold.js";
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,44 @@
+/**
+ * TS-native greenfield init deposit orchestrator (#1942 S2).
+ *
+ * Composes the S1 resolve-and-copy primitive with AGENTS.md render, vbrief
+ * scaffold, skills/githooks/#1430 neutralization, and Taskfile wiring.
+ * Refs #1942, #11, #1430.
+ */
+import { type LegacyLayoutDetection } from "./legacy-detect.js";
+import { type InitDepositIo, writeConsumerGitHooks } from "./scaffold.js";
+export interface InitDepositArgs {
+    readonly projectDir: string;
+    readonly jsonOut: boolean;
+    readonly nonInteractive: boolean;
+}
+export interface InitDepositResult {
+    readonly projectDir: string;
+    readonly deftDir: string;
+    readonly skillsCreated: boolean;
+    readonly taskfileWired: boolean;
+    readonly configDir: string;
+    readonly legacyLayout: boolean;
+}
+export interface InitDepositSeams {
+    resolveContentRoot?: () => Promise<string>;
+    copyContent?: (src: string, dst: string) => Promise<void>;
+    readPackageVersion?: () => string;
+    nowIso?: () => string;
+    gitHooks?: Parameters<typeof writeConsumerGitHooks>[3];
+    detectLegacy?: (projectDir: string) => LegacyLayoutDetection;
+}
+export declare function parseInitArgv(canonicalArgv: readonly string[], userArgv?: readonly string[]): InitDepositArgs;
+export declare function userConfigDir(): string;
+export declare function createUserConfigDir(io: InitDepositIo): string;
+export declare function buildInstallSummaryJson(result: InitDepositResult, options: InitDepositArgs): Record<string, unknown>;
+export declare function printNextSteps(result: InitDepositResult, io: InitDepositIo): void;
+export declare function runInitDeposit(args: InitDepositArgs, io: InitDepositIo, seams?: InitDepositSeams): Promise<InitDepositResult>;
+export interface RunInitDepositCliOptions extends InitDepositArgs {
+    readonly writeOut: (text: string) => void;
+    readonly writeErr: (text: string) => void;
+    readonly seams?: InitDepositSeams;
+}
+/** CLI-facing wrapper: runs deposit, emits JSON or wizard UX, returns exit code. */
+export declare function runInitDepositCli(options: RunInitDepositCliOptions): Promise<number>;
+//# sourceMappingURL=init-deposit.d.ts.map

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

@@ -0,0 +1,197 @@
+/**
+ * TS-native greenfield init deposit orchestrator (#1942 S2).
+ *
+ * Composes the S1 resolve-and-copy primitive with AGENTS.md render, vbrief
+ * scaffold, skills/githooks/#1430 neutralization, and Taskfile wiring.
+ * Refs #1942, #11, #1430.
+ */
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { homedir, platform } from "node:os";
+import { join, resolve } from "node:path";
+import { copyTree } from "../deposit/copy-tree.js";
+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 { CANONICAL_INSTALL_ROOT, depositNeutralization, ensureTaskfile, writeAgentsMd, writeAgentsSkills, writeConsumerGitHooks, writeConsumerVbrief, writeInstallManifest, } from "./scaffold.js";
+export function parseInitArgv(canonicalArgv, userArgv = []) {
+    const args = [...canonicalArgv, ...userArgv];
+    let projectDir = process.cwd();
+    let jsonOut = false;
+    let nonInteractive = false;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === "--json" || arg === "/json")
+            jsonOut = true;
+        if (arg === "--yes" ||
+            arg === "--non-interactive" ||
+            arg === "/yes" ||
+            arg === "/non-interactive") {
+            nonInteractive = true;
+        }
+        if ((arg === "--repo-root" || arg === "/repo-root") && args[i + 1]) {
+            projectDir = resolve(args[i + 1] ?? projectDir);
+            i += 1;
+        }
+    }
+    return { projectDir: resolve(projectDir), jsonOut, nonInteractive };
+}
+export function userConfigDir() {
+    const override = process.env.DEFT_USER_PATH?.trim();
+    if (override)
+        return resolve(override);
+    if (platform() === "win32") {
+        const appData = process.env.APPDATA?.trim();
+        return appData ? join(appData, "deft") : join(homedir(), "AppData", "Roaming", "deft");
+    }
+    return join(homedir(), ".config", "deft");
+}
+export function createUserConfigDir(io) {
+    const dir = userConfigDir();
+    mkdirSync(dir, { recursive: true });
+    const userMd = join(dir, "USER.md");
+    if (existsSync(userMd)) {
+        io.printf(`USER.md already exists at ${userMd} — keeping existing file.\n`);
+    }
+    return dir;
+}
+function readContentVersion(contentRoot, readVersion = readCorePackageVersion) {
+    try {
+        const parsed = JSON.parse(readFileSync(join(contentRoot, "package.json"), "utf8"));
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            const version = parsed.version;
+            if (version?.trim())
+                return version.trim();
+        }
+    }
+    catch {
+        // fall through
+    }
+    return readVersion();
+}
+export function buildInstallSummaryJson(result, options) {
+    return {
+        success: true,
+        action: "install",
+        version: readCorePackageVersion(),
+        project_dir: result.projectDir,
+        deft_dir: result.deftDir,
+        legacy_layout: result.legacyLayout,
+        update: false,
+        non_interactive: options.nonInteractive,
+        upgrade: false,
+        taskfile_wired: result.taskfileWired,
+        missing_tools: [],
+        maintainer_mode: false,
+        maintainer_tools: [],
+        skipped_consumer_projections: [],
+        user_config_dir: result.configDir,
+        skills_created: result.skillsCreated,
+        payload_layout: "vendored",
+        strategy: "vendor",
+        dirty_tree: false,
+        dirty_files: [],
+        staged_paths: [],
+        backup_path: "",
+        previous_version: "",
+    };
+}
+export function printNextSteps(result, io) {
+    const skillsStatus = result.skillsCreated ? "created" : "already present";
+    io.printf("\n✓ Deft installed successfully!\n\n");
+    io.printf(`  Location     : ${result.deftDir}\n`);
+    io.printf("  AGENTS.md    : updated\n");
+    io.printf(`  Skills       : .agents/skills/ ${skillsStatus} (auto-discovered by AI agents)\n`);
+    io.printf(`  User config  : ${result.configDir}\n`);
+    io.printf("\nNext steps:\n");
+    io.printf(`  1. Open your AI coding assistant in ${result.projectDir}\n`);
+    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");
+    io.printf("\n");
+}
+export async function runInitDeposit(args, io, seams = {}) {
+    const projectDir = args.projectDir;
+    const deftDir = join(projectDir, CANONICAL_INSTALL_ROOT);
+    // #1912: refuse a legacy on-disk layout BEFORE any deposit. The npm CLI never
+    // migrates -- the frozen Go bridge does (stage 1), then the npm path (stage 2).
+    const detectLegacy = seams.detectLegacy ?? detectLegacyLayout;
+    const legacy = detectLegacy(projectDir);
+    if (legacy.legacy) {
+        throw new LegacyLayoutRefusedError(legacy);
+    }
+    const resolveContent = seams.resolveContentRoot ?? resolveInstalledContentRoot;
+    const copyContent = seams.copyContent ?? copyTree;
+    const contentRoot = await resolveContent();
+    await reconstituteDepositFromContent(contentRoot, deftDir, copyContent);
+    ensureInitGitignoreLines(projectDir, io);
+    const nowIso = seams.nowIso ?? (() => new Date().toISOString().replace(/\.\d{3}Z$/, "Z"));
+    const version = readContentVersion(contentRoot, seams.readPackageVersion ?? readCorePackageVersion);
+    const manifestFields = {
+        ref: version.startsWith("v") ? version : `v${version}`,
+        sha: "content-package",
+        tag: version.startsWith("v") ? version : `v${version}`,
+        installRoot: CANONICAL_INSTALL_ROOT,
+        fetchedAt: nowIso(),
+        fetchedBy: "directive-init",
+    };
+    writeInstallManifest(projectDir, deftDir, manifestFields);
+    writeAgentsMd(projectDir, deftDir, io);
+    const skillsCreated = writeAgentsSkills(projectDir, io);
+    await depositNeutralization(projectDir, io);
+    await writeConsumerVbrief(projectDir, deftDir, io);
+    writeConsumerGitHooks(projectDir, deftDir, io, seams.gitHooks);
+    let taskfileWired = false;
+    if (args.nonInteractive) {
+        taskfileWired = ensureTaskfile(projectDir, io);
+    }
+    const configDir = createUserConfigDir(io);
+    return {
+        projectDir,
+        deftDir,
+        skillsCreated,
+        taskfileWired,
+        configDir,
+        legacyLayout: false,
+    };
+}
+/** CLI-facing wrapper: runs deposit, emits JSON or wizard UX, returns exit code. */
+export async function runInitDepositCli(options) {
+    const io = {
+        printf: (text) => {
+            if (options.jsonOut) {
+                options.writeErr(text);
+            }
+            else {
+                options.writeOut(text);
+            }
+        },
+    };
+    try {
+        const result = await runInitDeposit(options, io, options.seams);
+        if (options.jsonOut) {
+            options.writeOut(`${JSON.stringify(buildInstallSummaryJson(result, options), null, 2)}\n`);
+            printNextSteps(result, { printf: options.writeErr });
+        }
+        else {
+            printNextSteps(result, io);
+        }
+        return 0;
+    }
+    catch (cause) {
+        if (cause instanceof LegacyLayoutRefusedError) {
+            io.printf(buildLegacyRefusalMessage("init", cause.detection));
+            if (options.jsonOut) {
+                options.writeOut(`${JSON.stringify(buildLegacyRefusalJson("init", resolve(options.projectDir), cause.detection), null, 2)}\n`);
+            }
+            return LEGACY_LAYOUT_REFUSED_EXIT_CODE;
+        }
+        const message = cause instanceof Error ? cause.message : String(cause);
+        options.writeErr(`directive init: ${message}\n`);
+        if (options.jsonOut) {
+            options.writeOut(`${JSON.stringify({ success: false, error: message, error_code: "init_deposit_failed" }, null, 2)}\n`);
+        }
+        return 1;
+    }
+}
+//# sourceMappingURL=init-deposit.js.map