@lsctech/polaris 0.1.0 → 0.1.3

package/dist/cli/adopt-assets.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isThinPointer = isThinPointer;
+exports.installWorkspaceAssets = installWorkspaceAssets;
+exports.runGraphBuild = runGraphBuild;
+const node_fs_1 = require("node:fs");
+const node_child_process_1 = require("node:child_process");
+const node_path_1 = require("node:path");
+function isAncestorSymlink(repoRoot, relPath) {
+    const parts = relPath.split("/").filter(Boolean);
+    for (let i = 0; i < parts.length - 1; i++) {
+        const ancestor = (0, node_path_1.resolve)(repoRoot, ...parts.slice(0, i + 1));
+        try {
+            const stat = (0, node_fs_1.lstatSync)(ancestor);
+            if (stat.isSymbolicLink())
+                return true;
+        }
+        catch (err) {
+            if (err.code === "ENOENT")
+                return false;
+            throw err;
+        }
+    }
+    return false;
+}
+/**
+ * Recursively walk srcDir and install directories + .gitkeep files into dstDir.
+ * parentWasPreExisting: true if dstDir already existed before Polaris touched it this run.
+ * Skip .gitkeep if parentWasPreExisting (user already has content in that dir).
+ */
+function installSmartdocsDir(srcDir, dstDir, relPrefix, installed, alreadyPresent, parentWasPreExisting) {
+    for (const entry of (0, node_fs_1.readdirSync)(srcDir, { withFileTypes: true })) {
+        const srcChild = (0, node_path_1.join)(srcDir, entry.name);
+        const dstChild = (0, node_path_1.join)(dstDir, entry.name);
+        const relChild = `${relPrefix}/${entry.name}`;
+        if (entry.isDirectory()) {
+            const childPreExisted = (0, node_fs_1.existsSync)(dstChild);
+            if (!childPreExisted) {
+                (0, node_fs_1.mkdirSync)(dstChild, { recursive: true });
+                installed.push(relChild);
+            }
+            installSmartdocsDir(srcChild, dstChild, relChild, installed, alreadyPresent, childPreExisted);
+        }
+        else if (entry.name === ".gitkeep") {
+            if (parentWasPreExisting) {
+                alreadyPresent.push(relChild);
+            }
+            else {
+                if (!(0, node_fs_1.existsSync)(dstDir)) {
+                    (0, node_fs_1.mkdirSync)(dstDir, { recursive: true });
+                }
+                installed.push(relChild);
+            }
+        }
+    }
+}
+function isThinPointer(content) {
+    // Split into lines
+    const lines = content.split("\n");
+    // Filter to meaningful lines (non-empty, non-whitespace, non-HTML-comment)
+    const meaningfulLines = lines.filter((line) => {
+        const trimmed = line.trim();
+        // Empty or whitespace-only
+        if (!trimmed)
+            return false;
+        // HTML comment line (entire line is a comment)
+        if (/^<!--.*-->$/.test(trimmed))
+            return false;
+        return true;
+    });
+    // Rule 1: meaningful lines must be <= 3
+    if (meaningfulLines.length > 3)
+        return false;
+    // Rule 2: at least one line must contain "POLARIS.md"
+    const hasPolarisRef = meaningfulLines.some((line) => line.includes("POLARIS.md"));
+    if (!hasPolarisRef)
+        return false;
+    return true;
+}
+function installWorkspaceAssets(repoRoot, workspaceDir) {
+    const installed = [];
+    const alreadyPresent = [];
+    const skipped = [];
+    const conflicted = [];
+    // 1. Skills
+    const srcSkillsDir = (0, node_path_1.join)(workspaceDir, ".polaris", "skills");
+    const dstSkillsDir = (0, node_path_1.join)(repoRoot, ".polaris", "skills");
+    if ((0, node_fs_1.existsSync)(srcSkillsDir)) {
+        for (const entry of (0, node_fs_1.readdirSync)(srcSkillsDir, { withFileTypes: true })) {
+            if (!entry.isDirectory())
+                continue;
+            const relSkillDir = `.polaris/skills/${entry.name}`;
+            if (isAncestorSymlink(repoRoot, relSkillDir)) {
+                skipped.push(relSkillDir);
+                continue;
+            }
+            const dstSkill = (0, node_path_1.join)(dstSkillsDir, entry.name);
+            if ((0, node_fs_1.existsSync)(dstSkill)) {
+                alreadyPresent.push(relSkillDir);
+                continue;
+            }
+            const srcSkill = (0, node_path_1.join)(srcSkillsDir, entry.name);
+            (0, node_fs_1.mkdirSync)(dstSkill, { recursive: true });
+            for (const file of (0, node_fs_1.readdirSync)(srcSkill, { withFileTypes: true })) {
+                if (!file.isFile())
+                    continue;
+                (0, node_fs_1.copyFileSync)((0, node_path_1.join)(srcSkill, file.name), (0, node_path_1.join)(dstSkill, file.name));
+            }
+            installed.push(relSkillDir);
+        }
+    }
+    // 2. ROUTING.md
+    const routingRel = ".polaris/skills/ROUTING.md";
+    const srcRouting = (0, node_path_1.join)(workspaceDir, routingRel);
+    const dstRouting = (0, node_path_1.join)(repoRoot, routingRel);
+    if ((0, node_fs_1.existsSync)(srcRouting)) {
+        if (isAncestorSymlink(repoRoot, routingRel)) {
+            skipped.push(routingRel);
+        }
+        else if ((0, node_fs_1.existsSync)(dstRouting)) {
+            alreadyPresent.push(routingRel);
+        }
+        else {
+            (0, node_fs_1.mkdirSync)((0, node_path_1.join)(repoRoot, ".polaris", "skills"), { recursive: true });
+            (0, node_fs_1.copyFileSync)(srcRouting, dstRouting);
+            installed.push(routingRel);
+        }
+    }
+    // 3. Roles
+    const srcRolesDir = (0, node_path_1.join)(workspaceDir, ".polaris", "roles");
+    const dstRolesDir = (0, node_path_1.join)(repoRoot, ".polaris", "roles");
+    if ((0, node_fs_1.existsSync)(srcRolesDir)) {
+        for (const entry of (0, node_fs_1.readdirSync)(srcRolesDir, { withFileTypes: true })) {
+            if (!entry.isFile())
+                continue;
+            const relFile = `.polaris/roles/${entry.name}`;
+            if (isAncestorSymlink(repoRoot, relFile)) {
+                skipped.push(relFile);
+                continue;
+            }
+            const dstFile = (0, node_path_1.join)(dstRolesDir, entry.name);
+            if ((0, node_fs_1.existsSync)(dstFile)) {
+                alreadyPresent.push(relFile);
+                continue;
+            }
+            (0, node_fs_1.mkdirSync)(dstRolesDir, { recursive: true });
+            (0, node_fs_1.copyFileSync)((0, node_path_1.join)(srcRolesDir, entry.name), dstFile);
+            installed.push(relFile);
+        }
+    }
+    // 4. Smartdocs scaffold
+    const srcSmartdocs = (0, node_path_1.join)(workspaceDir, "smartdocs");
+    const dstSmartdocs = (0, node_path_1.join)(repoRoot, "smartdocs");
+    if ((0, node_fs_1.existsSync)(srcSmartdocs)) {
+        const smartdocsPreExisted = (0, node_fs_1.existsSync)(dstSmartdocs);
+        installSmartdocsDir(srcSmartdocs, dstSmartdocs, "smartdocs", installed, alreadyPresent, smartdocsPreExisted);
+    }
+    return { installed, alreadyPresent, skipped, conflicted };
+}
+function runGraphBuild(repoRoot) {
+    try {
+        const proc = (0, node_child_process_1.spawnSync)(process.execPath, [process.argv[1], "graph", "build"], {
+            cwd: repoRoot,
+            encoding: "buffer",
+            timeout: 5 * 60 * 1000,
+        });
+        if (proc.status === 0) {
+            return {
+                status: "graph-success",
+                stdout: proc.stdout ? proc.stdout.toString("utf-8") : undefined,
+            };
+        }
+        return {
+            status: "graph-failed",
+            reason: proc.stderr ? proc.stderr.toString("utf-8") : "Unknown error",
+            followUpCommand: "polaris-cli graph build",
+        };
+    }
+    catch (err) {
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        return {
+            status: "graph-failed",
+            reason: errorMsg,
+            followUpCommand: "polaris-cli graph build",
+        };
+    }
+}

package/dist/cli/adopt-cognition.js

@@ -157,11 +157,10 @@ function buildSummaryDraft(folder) {
         "",
     ].join("\n");
 }
-function generateFolderCognition(plan, inventory) {
+function generateFolderCognition(plan, inventory, repoRoot) {
     if (plan.dry_run) {
         return Promise.resolve();
     }
-    const repoRoot = (0, node_path_1.resolve)(process.cwd());
     const folders = Array.from(new Set(inventory.likely_canonical_folders.map(normalizeFolder)));
     for (const folder of folders) {
         if (!isFolderEligible(folder, inventory)) {

package/dist/cli/adopt-genesis.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reconcileAgentFiles = reconcileAgentFiles;
+const promises_1 = require("node:readline/promises");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const adopt_assets_js_1 = require("./adopt-assets.js");
+const AGENT_FILES = ["CLAUDE.md", "AGENTS.md", ".github/copilot-instructions.md"];
+function formatDate(d) {
+    return d.toISOString().slice(0, 10);
+}
+async function reconcileAgentFiles(repoRoot, options) {
+    const results = [];
+    for (const file of AGENT_FILES) {
+        const filePath = (0, node_path_1.join)(repoRoot, file);
+        if (!(0, node_fs_1.existsSync)(filePath)) {
+            continue;
+        }
+        const content = (0, node_fs_1.readFileSync)(filePath, "utf8");
+        if ((0, adopt_assets_js_1.isThinPointer)(content)) {
+            results.push({ file, outcome: "already-present" });
+            continue;
+        }
+        const rl = (0, promises_1.createInterface)({ input: process.stdin, output: process.stdout });
+        let answer;
+        try {
+            answer = await rl.question(`\n${file} has existing content. Compress and archive as genesis doctrine? (Requires ANTHROPIC_API_KEY) [Y/n]: `);
+        }
+        finally {
+            rl.close();
+        }
+        const trimmed = answer.trim().toLowerCase();
+        if (trimmed === "n" || trimmed === "no") {
+            const pointer = `<!-- See [POLARIS.md](POLARIS.md) for repo instructions -->\n`;
+            (0, node_fs_1.writeFileSync)(filePath, pointer + content, "utf8");
+            results.push({ file, outcome: "refused" });
+            continue;
+        }
+        // Accepted — attempt compression
+        const apiKey = options?.anthropicKey ?? process.env["ANTHROPIC_API_KEY"];
+        if (!apiKey) {
+            process.stderr.write(`Warning: ANTHROPIC_API_KEY not found. Skipping compression of ${file}.\n`);
+            results.push({ file, outcome: "skipped" });
+            continue;
+        }
+        let Anthropic;
+        try {
+            // @ts-ignore: @anthropic-ai/sdk may not be installed as a dependency
+            const mod = await import("@anthropic-ai/sdk");
+            Anthropic = mod.default;
+        }
+        catch {
+            process.stderr.write(`Warning: @anthropic-ai/sdk not installed. Skipping compression of ${file}.\n`);
+            results.push({ file, outcome: "skipped" });
+            continue;
+        }
+        const client = new Anthropic({ apiKey });
+        const response = await client.messages.create({
+            model: "claude-opus-4-5",
+            max_tokens: 1024,
+            messages: [
+                {
+                    role: "user",
+                    content: `Distill the following agent instructions into concise bullet-point rules that preserve all essential guidance:\n\n${content}`,
+                },
+            ],
+        });
+        const distilled = response.content
+            .filter((b) => b.type === "text")
+            .map((b) => b.text)
+            .join("\n");
+        const now = options?.now ?? new Date();
+        const dateStr = formatDate(now);
+        const genesisPath = `smartdocs/doctrine/active/${dateStr}-genesis-agent-doctrine.md`;
+        const genesisFullPath = (0, node_path_1.join)(repoRoot, genesisPath);
+        (0, node_fs_1.mkdirSync)((0, node_path_1.join)(repoRoot, "smartdocs/doctrine/active"), { recursive: true });
+        (0, node_fs_1.writeFileSync)(genesisFullPath, distilled, "utf8");
+        const thinPointer = `# Agent Instructions\n\nRead [POLARIS.md](POLARIS.md) before beginning any work.\n\n` +
+            `<!-- genesis doctrine archived: ${genesisPath} -->\n`;
+        (0, node_fs_1.writeFileSync)(filePath, thinPointer, "utf8");
+        results.push({ file, outcome: "compressed", genesisPath });
+    }
+    return results;
+}

package/dist/cli/adopt-instructions.js

@@ -100,11 +100,10 @@ function appendInstructionProvenance(repoRoot, records) {
     };
     (0, node_fs_1.writeFileSync)(provenancePath, `${JSON.stringify(updated, null, 2)}\n`, "utf-8");
 }
-function handleInstructionFiles(plan, inventory) {
+function handleInstructionFiles(plan, inventory, repoRoot) {
     if (plan.dry_run) {
         return Promise.resolve();
     }
-    const repoRoot = (0, node_path_1.resolve)(process.cwd());
     const doctrineExists = hasDoctrine(repoRoot);
     const now = new Date().toISOString();
     const candidates = Array.from(new Set(inventory.agent_instruction_files

package/dist/cli/adopt-report.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildAdoptionReport = buildAdoptionReport;
+exports.writeAdoptionReport = writeAdoptionReport;
+exports.printAdoptionReport = printAdoptionReport;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+function buildAdoptionReport(options) {
+    const { install, graph, agents, now } = options;
+    const timestamp = (now ?? new Date()).toISOString();
+    return {
+        timestamp,
+        installed: install.installed,
+        alreadyPresent: install.alreadyPresent,
+        skipped: install.skipped,
+        conflicted: install.conflicted,
+        graphStatus: graph.status,
+        graphDetail: graph.stdout ?? graph.reason,
+        graphFollowUp: graph.followUpCommand,
+        agents,
+    };
+}
+function writeAdoptionReport(repoRoot, report) {
+    // Safe timestamp: replace ":" with "-" and "." with "-"
+    // e.g. "2026-06-09T12:00:00.000Z" → "adoption-report-2026-06-09T12-00-00-000Z.json"
+    const safeTimestamp = report.timestamp.replace(/:/g, "-").replace(/\./g, "-");
+    const fileName = `adoption-report-${safeTimestamp}.json`;
+    const runsDir = (0, node_path_1.join)(repoRoot, ".polaris", "runs");
+    if (!(0, node_fs_1.existsSync)(runsDir)) {
+        (0, node_fs_1.mkdirSync)(runsDir, { recursive: true });
+    }
+    const reportPath = (0, node_path_1.join)(runsDir, fileName);
+    (0, node_fs_1.writeFileSync)(reportPath, JSON.stringify(report, null, 2), "utf-8");
+}
+function printAdoptionReport(report) {
+    // Print structured summary to stdout
+    console.log("Adoption Report:");
+    console.log(`  Timestamp: ${report.timestamp}`);
+    console.log("");
+    console.log("Asset Installation:");
+    console.log(`  Installed: ${report.installed.length}`);
+    console.log(`  Already Present: ${report.alreadyPresent.length}`);
+    console.log(`  Skipped: ${report.skipped.length}`);
+    console.log(`  Conflicted: ${report.conflicted.length}`);
+    console.log("");
+    console.log("Agent Files:");
+    if (report.agents.length === 0) {
+        console.log("  (none)");
+    }
+    else {
+        for (const agent of report.agents) {
+            console.log(`  ${agent.file}: ${agent.outcome}`);
+            if (agent.genesisPath) {
+                console.log(`    -> archived to ${agent.genesisPath}`);
+            }
+        }
+    }
+    console.log("");
+    console.log("Graph Build:");
+    console.log(`  Status: ${report.graphStatus}`);
+    if (report.graphDetail) {
+        console.log(`  Detail: ${report.graphDetail}`);
+    }
+    if (report.graphFollowUp) {
+        console.log(`  Follow-up: ${report.graphFollowUp}`);
+    }
+}

package/dist/cli/adopt-workspace.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scaffoldRootSurfaces = scaffoldRootSurfaces;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+function isAncestorSymlink(repoRoot, relPath) {
+    const parts = relPath.split("/").filter(Boolean);
+    for (let i = 0; i < parts.length - 1; i++) {
+        const ancestor = (0, node_path_1.resolve)(repoRoot, ...parts.slice(0, i + 1));
+        try {
+            const stat = (0, node_fs_1.lstatSync)(ancestor);
+            if (stat.isSymbolicLink())
+                return true;
+        }
+        catch (err) {
+            if (err.code === "ENOENT")
+                return false;
+            throw err;
+        }
+    }
+    return false;
+}
+function buildRootPolarisDraft() {
+    return [
+        "<!-- polaris:draft -->",
+        "# Repository",
+        "",
+        "> Polaris draft — review and remove the `<!-- polaris:draft -->` marker to promote.",
+        "",
+        "## Purpose",
+        "",
+        "<!-- One paragraph describing what this repository does. -->",
+        "",
+        "**Domain:** unknown",
+        "**Route:** /",
+        "**Taskchain:** unknown",
+        "",
+        "## What belongs here",
+        "",
+        "<!-- Describe the top-level assets and responsibilities. -->",
+        "",
+        "## What does not belong here",
+        "",
+        "<!-- Describe content that should be routed elsewhere. -->",
+        "",
+        "## Polaris Rules",
+        "",
+        "See [POLARIS_RULES.md](POLARIS_RULES.md) for canonical Polaris navigation and routing rules.",
+        "",
+    ].join("\n");
+}
+function buildRootSummaryDraft() {
+    return [
+        "<!-- polaris:draft -->",
+        "# Summary — Repository Root",
+        "",
+        "> Polaris draft — review and remove the `<!-- polaris:draft -->` marker to promote.",
+        "",
+        "- Route: `/`",
+        "- Canon status: draft",
+        "- Linked doctrine: `POLARIS.md`",
+        "",
+        "## Notes",
+        "",
+        "<!-- Add concise context, references, and ownership details. -->",
+        "",
+    ].join("\n");
+}
+function buildAgentPointer() {
+    return [
+        "# Agent Instructions",
+        "",
+        "This repository is managed by Polaris.",
+        "Read [POLARIS.md](POLARIS.md) before beginning any work.",
+        "",
+    ].join("\n");
+}
+function buildCopilotPointer() {
+    return [
+        "# Copilot Instructions",
+        "",
+        "This repository is managed by Polaris.",
+        "Read [POLARIS.md](../../POLARIS.md) before beginning any work.",
+        "",
+    ].join("\n");
+}
+function scaffoldRootSurfaces(repoRoot) {
+    const surfaces = [
+        { relPath: "POLARIS.md", content: buildRootPolarisDraft() },
+        { relPath: "SUMMARY.md", content: buildRootSummaryDraft() },
+        { relPath: "CLAUDE.md", content: buildAgentPointer() },
+        { relPath: "AGENTS.md", content: buildAgentPointer() },
+        { relPath: ".github/copilot-instructions.md", content: buildCopilotPointer() },
+    ];
+    const created = [];
+    const skipped = [];
+    for (const { relPath, content } of surfaces) {
+        if (isAncestorSymlink(repoRoot, relPath)) {
+            process.stderr.write(`Skipping root surface inside symlinked path: ${relPath}\n`);
+            skipped.push(relPath);
+            continue;
+        }
+        const absPath = (0, node_path_1.join)(repoRoot, relPath);
+        if ((0, node_fs_1.existsSync)(absPath)) {
+            skipped.push(relPath);
+            continue;
+        }
+        const dir = (0, node_path_1.dirname)(absPath);
+        (0, node_fs_1.mkdirSync)(dir, { recursive: true });
+        (0, node_fs_1.writeFileSync)(absPath, content, "utf-8");
+        created.push(relPath);
+    }
+    return { created, skipped };
+}

package/dist/cli/adoption-plan.js

@@ -43,6 +43,17 @@ function buildSteps(inventory) {
         requires_approval: false,
         estimated_risk: "low",
     }));
+    steps.push(createStep(order++, {
+        step_id: "workspace-root-surfaces",
+        phase: "A",
+        category: "scaffold",
+        action: "create",
+        dest_path: "CLAUDE.md, AGENTS.md, .github/copilot-instructions.md",
+        description: "Create root POLARIS.md, SUMMARY.md, and thin-pointer agent instruction files if missing.",
+        destructive: false,
+        requires_approval: false,
+        estimated_risk: "low",
+    }));
     for (const candidate of inventory.smartdocs_candidates) {
         steps.push(createStep(order++, {
             step_id: `smartdocs-migrate-${order.toString().padStart(3, "0")}`,

package/dist/cli/init.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.detectRepoState = void 0;
 exports.runAdoptionAtlas = runAdoptionAtlas;
+exports.isBeyondSymlink = isBeyondSymlink;
 exports.finalizeAdoption = finalizeAdoption;
 exports.runInit = runInit;
 exports.createInitCommand = createInitCommand;
@@ -18,6 +19,10 @@ const adopt_cognition_js_1 = require("./adopt-cognition.js");
 const adopt_smartdocs_js_1 = require("./adopt-smartdocs.js");
 const index_js_1 = require("../map/index.js");
 const adopt_instructions_js_1 = require("./adopt-instructions.js");
+const adopt_workspace_js_1 = require("./adopt-workspace.js");
+const adopt_assets_js_1 = require("./adopt-assets.js");
+const adopt_genesis_js_1 = require("./adopt-genesis.js");
+const adopt_report_js_1 = require("./adopt-report.js");
 const artifact_policy_js_1 = require("../finalize/artifact-policy.js");
 var init_detect_js_2 = require("./init-detect.js");
 Object.defineProperty(exports, "detectRepoState", { enumerable: true, get: function () { return init_detect_js_2.detectRepoState; } });
@@ -243,6 +248,26 @@ function updatePlanForFinalization(repoRoot, plan, now) {
     (0, node_fs_1.writeFileSync)((0, node_path_1.join)(repoRoot, ".polaris", "adoption-plan.json"), `${JSON.stringify(updatedPlan, null, 2)}\n`, "utf-8");
     return updatedPlan;
 }
+/**
+ * Returns true if any ancestor of relPath (from repoRoot) is a symlink.
+ * Prevents git from rejecting pathspecs that are "beyond a symbolic link".
+ */
+function isBeyondSymlink(repoRoot, relPath) {
+    const parts = relPath.split("/").filter(Boolean);
+    for (let i = 0; i < parts.length - 1; i++) {
+        const ancestor = (0, node_path_1.resolve)(repoRoot, ...parts.slice(0, i + 1));
+        try {
+            if ((0, node_fs_1.lstatSync)(ancestor).isSymbolicLink()) {
+                return true;
+            }
+        }
+        catch {
+            // ancestor doesn't exist — can't be a symlink
+            return false;
+        }
+    }
+    return false;
+}
 function stageAdoptionOutputs(repoRoot, plan) {
     const stagePaths = new Set([
         ".polaris/adoption-plan.json",
@@ -252,6 +277,9 @@ function stageAdoptionOutputs(repoRoot, plan) {
         ".polaris/map",
         "POLARIS.md",
         "SUMMARY.md",
+        "CLAUDE.md",
+        "AGENTS.md",
+        ".github/copilot-instructions.md",
         ".gitignore",
     ]);
     for (const step of plan.steps) {
@@ -262,9 +290,19 @@ function stageAdoptionOutputs(repoRoot, plan) {
             stagePaths.add(step.dest_path);
         }
     }
-    const existingPaths = [...stagePaths].filter((p) => (0, node_fs_1.existsSync)((0, node_path_1.resolve)(repoRoot, p)));
-    if (existingPaths.length > 0) {
-        (0, node_child_process_1.execFileSync)("git", ["add", "-A", "--", ...existingPaths], { cwd: repoRoot, stdio: "pipe" });
+    const validPaths = [];
+    for (const p of stagePaths) {
+        if (!(0, node_fs_1.existsSync)((0, node_path_1.resolve)(repoRoot, p))) {
+            continue;
+        }
+        if (isBeyondSymlink(repoRoot, p)) {
+            process.stderr.write(`Skipping adoption output inside symlinked path: ${p}\n`);
+            continue;
+        }
+        validPaths.push(p);
+    }
+    if (validPaths.length > 0) {
+        (0, node_child_process_1.execFileSync)("git", ["add", "-A", "--", ...validPaths], { cwd: repoRoot, stdio: "pipe" });
     }
 }
 function unstageRuntimeArtifacts(repoRoot) {
@@ -360,6 +398,13 @@ async function runInit(options = {}) {
     if (options.adopt) {
         if (!options.dryRun) {
             writeAdoptionConfigLock(repoRoot, configPath, existing, detected, detectedRepoAnalysis);
+            // Phase A: scaffold root surfaces before inventory scan so doctrineExists check in
+            // instruction reconciliation sees POLARIS.md at runtime.
+            const scaffoldFn = options.scaffoldRootSurfaces ?? adopt_workspace_js_1.scaffoldRootSurfaces;
+            const scaffoldResult = scaffoldFn(repoRoot);
+            if (scaffoldResult.created.length > 0) {
+                process.stdout.write(`Root surfaces created: ${scaffoldResult.created.join(", ")}\n`);
+            }
         }
     }
     else {
@@ -451,19 +496,46 @@ async function runInit(options = {}) {
         const migrationResult = (options.applySmartDocsMigration ?? applySmartDocsMigration)(repoRoot, inventory);
         process.stdout.write(`SmartDocs migration step completed: moved ${migrationResult.moved}, skipped ${migrationResult.skipped}.\n`);
     }
-    void (options.generateFolderCognition ?? adopt_cognition_js_1.generateFolderCognition)(adoptionArtifacts.plan, inventory);
+    void (options.generateFolderCognition ?? adopt_cognition_js_1.generateFolderCognition)(adoptionArtifacts.plan, inventory, repoRoot);
     process.stdout.write("Folder cognition generation step completed.\n");
-    (0, adopt_instructions_js_1.handleInstructionFiles)(adoptionArtifacts.plan, inventory);
+    (0, adopt_instructions_js_1.handleInstructionFiles)(adoptionArtifacts.plan, inventory, repoRoot);
     process.stdout.write("Instruction file handling step completed.\n");
+    // Phase B — install bundled workspace assets
+    const installFn = options.installWorkspaceAssets ?? adopt_assets_js_1.installWorkspaceAssets;
+    const workspaceDir = (0, node_path_1.resolve)(__dirname, "../workspace");
+    const installResult = installFn(repoRoot, workspaceDir);
+    process.stdout.write(`Workspace assets installed: ${installResult.installed.length} installed, ${installResult.alreadyPresent.length} already present.\n`);
+    const finalizeAdoptionFn = options.finalizeAdoption ?? finalizeAdoption;
     if (adoptionArtifacts.plan.steps.some((step) => step.category === "stage")) {
-        finalizeAdoption(adoptionArtifacts.plan, {
+        await finalizeAdoptionFn(adoptionArtifacts.plan, {
             repoRoot,
             commit: options.commit,
             now,
         });
         return;
     }
-    process.stdout.write("Adoption approved. Proceeding with mutation phases.\n");
+    // Phase C2 — graph build (automatic, non-blocking)
+    const graphBuildFn = options.runGraphBuild ?? adopt_assets_js_1.runGraphBuild;
+    const graphResult = graphBuildFn(repoRoot);
+    // Phase D — agent file reconciliation
+    const reconcileFn = options.reconcileAgentFiles ?? adopt_genesis_js_1.reconcileAgentFiles;
+    const agentResults = await reconcileFn(repoRoot);
+    // Phase E — adoption report
+    const adoptReport = (0, adopt_report_js_1.buildAdoptionReport)({ install: installResult, graph: graphResult, agents: agentResults });
+    (0, adopt_report_js_1.printAdoptionReport)(adoptReport);
+    (0, adopt_report_js_1.writeAdoptionReport)(repoRoot, adoptReport);
+    // Phase F — safe stage + optional commit
+    stageAdoptionOutputs(repoRoot, adoptionArtifacts.plan);
+    unstageRuntimeArtifacts(repoRoot);
+    printAdoptionSummary(repoRoot, adoptionArtifacts.plan);
+    if (options.commit) {
+        const message = createAdoptionCommitMessage(adoptionArtifacts.plan);
+        (0, node_child_process_1.execFileSync)("git", ["commit", "-m", message], { cwd: repoRoot, stdio: "pipe" });
+        process.stdout.write(`Adoption commit created: ${message}\n`);
+    }
+    else {
+        process.stdout.write("Adoption changes staged. Review with `git diff --cached` and commit when ready.\n");
+    }
 }
 /**
  * Registers the `init` subcommand on a Commander program.