@phren/cli 0.0.36 → 0.0.38

package/mcp/dist/init/init.js

@@ -1,31 +1,34 @@
 /**
  * CLI orchestrator for phren init, mcp-mode, hooks-mode, and uninstall.
- * Delegates to focused helpers in init-config, init-setup, and init-preferences.
+ * Delegates to focused helpers in init-config, init-setup, init-preferences,
+ * init-walkthrough, init-mcp-mode, init-hooks-mode, and init-uninstall.
  */
 import * as fs from "fs";
 import * as path from "path";
-import * as crypto from "crypto";
-import { execFileSync, spawnSync } from "child_process";
-import { configureAllHooks, installPhrenCliWrapper } from "../hooks.js";
-import { getMachineName, machineFilePath, persistMachineName } from "../machine-identity.js";
-import { atomicWriteText, debugLog, isRecord, hookConfigPath, homeDir, homePath, expandHomePath, findPhrenPath, getProjectDirs, readRootManifest, writeRootManifest, } from "../shared.js";
+import { execFileSync } from "child_process";
+import { getMachineName, persistMachineName } from "../machine-identity.js";
+import { atomicWriteText, debugLog, expandHomePath, hookConfigPath, writeRootManifest, } from "../shared.js";
 import { isValidProjectName, errorMessage } from "../utils.js";
-import { codexJsonCandidates, copilotMcpCandidates, cursorMcpCandidates, vscodeMcpCandidates, } from "../provider-adapters.js";
 import { logger } from "../logger.js";
 export { configureClaude, configureVSCode, configureCursorMcp, configureCopilotMcp, configureCodexMcp, logMcpTargetStatus, resetVSCodeProbeCache, patchJsonFile, } from "./config.js";
 export { getMcpEnabledPreference, setMcpEnabledPreference, getHooksEnabledPreference, setHooksEnabledPreference, } from "./preferences.js";
 export { PROJECT_OWNERSHIP_MODES, parseProjectOwnershipMode, getProjectOwnershipDefault, } from "../project-config.js";
 export { PROACTIVITY_LEVELS, getProactivityLevel, getProactivityLevelForFindings, getProactivityLevelForTask, } from "../proactivity.js";
 export { ensureGovernanceFiles, repairPreexistingInstall, runPostInitVerify, getVerifyOutcomeNote, listTemplates, detectProjectDir, isProjectTracked, ensureLocalGitRepo, resolvePreferredHomeDir, inferInitScaffoldFromRepo, } from "./setup.js";
-// Imports from helpers (used internally in this file)
-import { configureClaude, configureVSCode, configureCursorMcp, configureCopilotMcp, configureCodexMcp, logMcpTargetStatus, removeMcpServerAtPath, removeTomlMcpServer, isPhrenCommand, patchJsonFile, } from "./config.js";
-import { getMcpEnabledPreference, getHooksEnabledPreference, setMcpEnabledPreference, setHooksEnabledPreference, writeInstallPreferences, writeGovernanceInstallPreferences, readInstallPreferences, } from "./preferences.js";
-import { ensureGovernanceFiles, repairPreexistingInstall, runPostInitVerify, applyStarterTemplateUpdates, listTemplates, applyTemplate, ensureProjectScaffold, ensureLocalGitRepo, bootstrapFromExisting, ensureGitignoreEntry, upsertProjectEnvVar, updateMachinesYaml, detectProjectDir, isProjectTracked, inferInitScaffoldFromRepo, } from "./setup.js";
+// Re-export from extracted modules so consumers can still import from init.js
+export { configureMcpTargets, warmSemanticSearch, runProjectLocalInit } from "./init-configure.js";
+export { runMcpMode } from "./init-mcp-mode.js";
+export { runHooksMode } from "./init-hooks-mode.js";
+export { runUninstall } from "./init-uninstall.js";
+// Internal imports from extracted modules (used by runInit)
+import { configureMcpTargets, configureHooksIfEnabled, applyOnboardingPreferences, writeWalkthroughEnvDefaults, collectRepairedAssetLabels, applyProjectStorageBindings, warmSemanticSearch, runProjectLocalInit, } from "./init-configure.js";
+import { runWalkthrough, createWalkthroughPrompts, createWalkthroughStyle } from "./init-walkthrough.js";
+import { getMcpEnabledPreference, getHooksEnabledPreference, writeInstallPreferences, readInstallPreferences, } from "./preferences.js";
+import { ensureGovernanceFiles, repairPreexistingInstall, runPostInitVerify, applyStarterTemplateUpdates, listTemplates, applyTemplate, ensureProjectScaffold, ensureLocalGitRepo, bootstrapFromExisting, updateMachinesYaml, detectProjectDir, isProjectTracked, } from "./setup.js";
 import { DEFAULT_PHREN_PATH, STARTER_DIR, VERSION, log, confirmPrompt } from "./shared.js";
 import { PROJECT_OWNERSHIP_MODES, getProjectOwnershipDefault, } from "../project-config.js";
-import { getWorkflowPolicy, updateWorkflowPolicy } from "../shared/governance.js";
+import { getWorkflowPolicy } from "../shared/governance.js";
 import { addProjectToProfile } from "../profile-store.js";
-const PHREN_NPM_PACKAGE_NAME = "@phren/cli";
 function parseVersion(version) {
     const match = version.trim().match(/^(\d+)\.(\d+)\.(\d+)(?:-(.+))?/);
     if (!match)
@@ -60,53 +63,6 @@ export function isVersionNewer(current, previous) {
         return true;
     return c.pre > p.pre;
 }
-function getNpmCommand() {
-    return process.platform === "win32" ? "npm.cmd" : "npm";
-}
-function runSyncCommand(command, args) {
-    try {
-        const result = spawnSync(command, args, {
-            encoding: "utf8",
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-        return {
-            ok: result.status === 0,
-            status: result.status,
-            stdout: typeof result.stdout === "string" ? result.stdout : "",
-            stderr: typeof result.stderr === "string" ? result.stderr : "",
-        };
-    }
-    catch (err) {
-        return {
-            ok: false,
-            status: null,
-            stdout: "",
-            stderr: errorMessage(err),
-        };
-    }
-}
-function shouldUninstallCurrentGlobalPackage() {
-    // Always attempt to remove the global package if it exists, regardless of
-    // whether the uninstaller was invoked from the global install or a local repo.
-    const npmRootResult = runSyncCommand(getNpmCommand(), ["root", "-g"]);
-    if (!npmRootResult.ok)
-        return false;
-    const npmRoot = npmRootResult.stdout.trim();
-    if (!npmRoot)
-        return false;
-    const globalPkgPath = path.join(npmRoot, PHREN_NPM_PACKAGE_NAME);
-    return fs.existsSync(globalPkgPath);
-}
-function uninstallCurrentGlobalPackage() {
-    const result = runSyncCommand(getNpmCommand(), ["uninstall", "-g", PHREN_NPM_PACKAGE_NAME]);
-    if (result.ok) {
-        log(`  Removed global npm package (${PHREN_NPM_PACKAGE_NAME})`);
-        return;
-    }
-    const detail = result.stderr.trim() || result.stdout.trim() || (result.status === null ? "failed to start command" : `exit code ${result.status}`);
-    log(`  Warning: could not remove global npm package (${PHREN_NPM_PACKAGE_NAME})`);
-    debugLog(`uninstall: global npm cleanup failed: ${detail}`);
-}
 export function parseMcpMode(raw) {
     if (!raw)
         return undefined;
@@ -118,7 +74,7 @@ export function parseMcpMode(raw) {
 function normalizedBootstrapProjectName(projectPath) {
     return path.basename(projectPath).toLowerCase().replace(/[^a-z0-9_-]/g, "-");
 }
-function getPendingBootstrapTarget(phrenPath, _opts) {
+export function getPendingBootstrapTarget(phrenPath, _opts) {
     const cwdProject = detectProjectDir(process.cwd(), phrenPath);
     if (!cwdProject)
         return null;
@@ -127,31 +83,6 @@ function getPendingBootstrapTarget(phrenPath, _opts) {
         return null;
     return { path: cwdProject, mode: "detected" };
 }
-function parseLowConfidenceThreshold(raw, fallback) {
-    if (!raw)
-        return fallback;
-    const value = Number.parseFloat(raw.trim());
-    if (!Number.isFinite(value) || value < 0 || value > 1)
-        return fallback;
-    return value;
-}
-function parseRiskySectionsAnswer(raw, fallback) {
-    if (!raw)
-        return [...fallback];
-    const aliases = {
-        review: "Review",
-        stale: "Stale",
-        conflict: "Conflicts",
-        conflicts: "Conflicts",
-    };
-    const parsed = raw
-        .split(/[,\s]+/)
-        .map((token) => aliases[token.trim().toLowerCase()])
-        .filter((section) => Boolean(section));
-    if (!parsed.length)
-        return [...fallback];
-    return Array.from(new Set(parsed));
-}
 function hasInstallMarkers(phrenPath) {
     // Require at least two markers to consider this a real install.
     // A partial clone or failed init may create one directory but not finish.
@@ -170,814 +101,6 @@ function resolveInitPhrenPath(opts) {
     const raw = opts._walkthroughStoragePath || (process.env.PHREN_PATH) || DEFAULT_PHREN_PATH;
     return path.resolve(expandHomePath(raw));
 }
-function detectRepoRootForStorage(phrenPath) {
-    return detectProjectDir(process.cwd(), phrenPath);
-}
-function withFallbackColors(style) {
-    return {
-        header: style?.header ?? ((text) => text),
-        success: style?.success ?? ((text) => text),
-        warning: style?.warning ?? ((text) => text),
-    };
-}
-async function createWalkthroughStyle() {
-    try {
-        const chalkModule = await import(String("chalk"));
-        const chalkAny = chalkModule.default
-            ?? chalkModule.chalk
-            ?? chalkModule;
-        const chalk = chalkAny;
-        return withFallbackColors({
-            header: (text) => chalk.bold.cyan(text),
-            success: (text) => chalk.green(text),
-            warning: (text) => chalk.yellow(text),
-        });
-    }
-    catch {
-        return withFallbackColors();
-    }
-}
-async function createWalkthroughPrompts() {
-    try {
-        const inquirerModule = await import(String("inquirer"));
-        const maybeFns = inquirerModule;
-        if (typeof maybeFns.input === "function"
-            && typeof maybeFns.confirm === "function"
-            && typeof maybeFns.select === "function") {
-            return {
-                input: async (message, initialValue) => (await maybeFns.input({ message, default: initialValue })).trim(),
-                confirm: async (message, defaultValue = false) => Boolean(await maybeFns.confirm({ message, default: defaultValue })),
-                select: async (message, choices, defaultValue) => maybeFns.select({
-                    message,
-                    choices: choices.map((choice) => ({ value: choice.value, name: choice.name, description: choice.description })),
-                    default: defaultValue,
-                }),
-            };
-        }
-        const prompt = maybeFns.default?.prompt ?? maybeFns.prompt;
-        if (typeof prompt === "function") {
-            return {
-                input: async (message, initialValue) => {
-                    const answer = await prompt([{ type: "input", name: "value", message, default: initialValue }]);
-                    return String(answer.value ?? "").trim();
-                },
-                confirm: async (message, defaultValue = false) => {
-                    const answer = await prompt([{ type: "confirm", name: "value", message, default: defaultValue }]);
-                    return Boolean(answer.value);
-                },
-                select: async (message, choices, defaultValue) => {
-                    const answer = await prompt([{
-                            type: "list",
-                            name: "value",
-                            message,
-                            choices: choices.map((choice) => ({ value: choice.value, name: choice.name })),
-                            default: defaultValue,
-                        }]);
-                    return String(answer.value);
-                },
-            };
-        }
-    }
-    catch {
-        // fallback below
-    }
-    const readline = await import("readline");
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    const ask = (message) => new Promise((resolve) => rl.question(message, resolve));
-    process.once("exit", () => rl.close());
-    return {
-        input: async (message, initialValue) => {
-            const prompt = initialValue ? `${message} (${initialValue}): ` : `${message}: `;
-            const answer = (await ask(prompt)).trim();
-            return answer || (initialValue ?? "");
-        },
-        confirm: async (message, defaultValue = false) => {
-            const suffix = defaultValue ? "[Y/n]" : "[y/N]";
-            const answer = (await ask(`${message} ${suffix}: `)).trim().toLowerCase();
-            if (!answer)
-                return defaultValue;
-            return answer === "y" || answer === "yes";
-        },
-        select: async (message, choices, defaultValue) => {
-            log(`${message}`);
-            for (const [index, choice] of choices.entries()) {
-                log(`  ${index + 1}. ${choice.name}`);
-            }
-            const selected = (await ask(`Select [1-${choices.length}]${defaultValue ? " (Enter for default)" : ""}: `)).trim();
-            if (!selected && defaultValue)
-                return defaultValue;
-            const idx = Number.parseInt(selected, 10) - 1;
-            if (!Number.isNaN(idx) && idx >= 0 && idx < choices.length)
-                return choices[idx].value;
-            return defaultValue ?? choices[0].value;
-        },
-    };
-}
-// Interactive walkthrough for first-time init
-async function runWalkthrough(phrenPath) {
-    const prompts = await createWalkthroughPrompts();
-    const style = await createWalkthroughStyle();
-    const divider = style.header("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
-    const printSection = (title) => {
-        log("");
-        log(divider);
-        log(style.header(title));
-        log(divider);
-    };
-    const printSummary = (items) => {
-        printSection("Configuration Summary");
-        for (const item of items) {
-            log(style.success(`✓ ${item}`));
-        }
-    };
-    const { renderPhrenArt } = await import("../phren-art.js");
-    log("");
-    log(renderPhrenArt("  "));
-    log("");
-    printSection("Welcome");
-    log("Let's set up persistent memory for your AI agents.");
-    log("Every option can be changed later.\n");
-    printSection("Storage Location");
-    log("Where should phren store data?");
-    const storageChoice = await prompts.select("Storage location", [
-        {
-            value: "global",
-            name: "global (~/.phren/ - default, shared across projects)",
-        },
-        {
-            value: "project",
-            name: "per-project (<repo>/.phren/ - scoped to this repo, add to .gitignore)",
-        },
-        {
-            value: "custom",
-            name: "custom path",
-        },
-    ], "global");
-    let storagePath = path.resolve(homePath(".phren"));
-    let storageRepoRoot;
-    if (storageChoice === "project") {
-        const repoRoot = detectRepoRootForStorage(phrenPath);
-        if (!repoRoot) {
-            throw new Error("Per-project storage requires running init from a repository directory.");
-        }
-        storageRepoRoot = repoRoot;
-        storagePath = path.join(repoRoot, ".phren");
-    }
-    else if (storageChoice === "custom") {
-        const customInput = await prompts.input("Custom phren path", phrenPath);
-        storagePath = path.resolve(expandHomePath(customInput || phrenPath));
-    }
-    printSection("Existing Phren");
-    log("If you've already set up phren on another machine, paste the git clone URL.");
-    log("Otherwise, leave blank.");
-    const cloneAnswer = await prompts.input("Clone URL (leave blank to skip)");
-    if (cloneAnswer) {
-        const cloneConfig = {
-            storageChoice,
-            storagePath,
-            storageRepoRoot,
-            machine: getMachineName(),
-            profile: "personal",
-            mcp: "on",
-            hooks: "on",
-            projectOwnershipDefault: "phren-managed",
-            findingsProactivity: "high",
-            taskProactivity: "high",
-            lowConfidenceThreshold: 0.7,
-            riskySections: ["Stale", "Conflicts"],
-            taskMode: "auto",
-            bootstrapCurrentProject: false,
-            ollamaEnabled: false,
-            autoCaptureEnabled: false,
-            semanticDedupEnabled: false,
-            semanticConflictEnabled: false,
-            findingSensitivity: "balanced",
-            cloneUrl: cloneAnswer,
-            domain: "software",
-        };
-        printSummary([
-            `Storage: ${storageChoice} (${storagePath})`,
-            `Existing memory clone: ${cloneAnswer}`,
-            `Machine: ${cloneConfig.machine}`,
-            `Profile: ${cloneConfig.profile}`,
-            "MCP: enabled",
-            "Hooks: enabled",
-            "Project ownership default: phren-managed",
-            "Task mode: auto",
-            "Domain: software",
-        ]);
-        return cloneConfig;
-    }
-    const defaultMachine = getMachineName();
-    printSection("Identity");
-    const machine = await prompts.input("Machine name", defaultMachine);
-    const profile = await prompts.input("Profile name", "personal");
-    const repoForInference = detectProjectDir(process.cwd(), storagePath);
-    const inferredScaffold = repoForInference
-        ? inferInitScaffoldFromRepo(repoForInference)
-        : null;
-    const inferredDomain = inferredScaffold?.domain ?? "software";
-    printSection("Project Domain");
-    log("What kind of project is this?");
-    if (repoForInference && inferredScaffold) {
-        log(`Detected repo signals from ${repoForInference} (${inferredScaffold.reason}).`);
-        if (inferredScaffold.referenceHints.length > 0) {
-            log(`Reference hints: ${inferredScaffold.referenceHints.join(", ")}`);
-        }
-    }
-    // Use inferred domain directly — adaptive init derives domain from repo content.
-    // Only ask if inference was weak (fell back to default "software" with no signals).
-    let domain = inferredDomain;
-    if (inferredDomain === "software" && !inferredScaffold) {
-        domain = await prompts.select("Project domain", [
-            { value: "software", name: "software" },
-            { value: "research", name: "research" },
-            { value: "creative", name: "creative" },
-            { value: "other", name: "other" },
-        ], "software");
-    }
-    else {
-        log(`Domain: ${inferredDomain} (inferred from project content)`);
-    }
-    printSection("Project Ownership");
-    log("Choose who owns repo-facing instruction files for projects you add.");
-    log("  phren-managed: Phren may mirror CLAUDE.md / AGENTS.md into the repo");
-    log("  detached: Phren keeps its own docs but does not write into the repo");
-    log("  repo-managed: keep the repo's existing CLAUDE/AGENTS files as canonical");
-    log("  Change later: npx phren config project-ownership <mode>");
-    const projectOwnershipDefault = await prompts.select("Default project ownership", [
-        { value: "detached", name: "detached (default)" },
-        { value: "phren-managed", name: "phren-managed" },
-        { value: "repo-managed", name: "repo-managed" },
-    ], "detached");
-    printSection("MCP");
-    log("MCP mode registers phren as a tool server so your AI agent can call it");
-    log("directly: search memory, manage tasks, save findings, etc.");
-    log("  Recommended for: Claude Code, Cursor, Copilot CLI, Codex");
-    log("  Alternative: hooks-only mode (read-only context injection, any agent)");
-    log("  Change later: npx phren mcp-mode on|off");
-    const mcp = (await prompts.confirm("Enable MCP?", true)) ? "on" : "off";
-    printSection("Hooks");
-    log("Hooks run shell commands at session start, prompt submit, and session end.");
-    log("  - SessionStart: git pull (keeps memory in sync across machines)");
-    log("  - UserPromptSubmit: searches phren and injects relevant context");
-    log("  - Stop: commits and pushes any new findings after each response");
-    log("  What they touch: ~/.claude/settings.json (hooks section only)");
-    log("  Change later: npx phren hooks-mode on|off");
-    const hooks = (await prompts.confirm("Enable hooks?", true)) ? "on" : "off";
-    printSection("Semantic Search (Optional)");
-    log("Phren can use a local embedding model for semantic (fuzzy) search via Ollama.");
-    log("  Best fit: paraphrase-heavy or weak-lexical queries.");
-    log("  Skip it if you mostly search by filenames, symbols, commands, or exact phrases.");
-    log("  - Model: nomic-embed-text (274 MB, one-time download)");
-    log("  - Ollama runs locally, no cloud, no cost");
-    log("  - Falls back to FTS5 keyword search if disabled or unavailable");
-    log("  Change later: set PHREN_OLLAMA_URL=off to disable");
-    let ollamaEnabled = false;
-    try {
-        const { checkOllamaStatus } = await import("../shared/ollama.js");
-        const status = await checkOllamaStatus();
-        if (status === "ready") {
-            log("  Ollama detected with nomic-embed-text ready.");
-            ollamaEnabled = await prompts.confirm("Enable semantic search for fuzzy/paraphrase recovery?", false);
-        }
-        else if (status === "no_model") {
-            log("  Ollama detected, but nomic-embed-text is not pulled yet.");
-            ollamaEnabled = await prompts.confirm("Enable semantic search for fuzzy/paraphrase recovery? (will pull nomic-embed-text)", false);
-            if (ollamaEnabled) {
-                log("  Run after init: ollama pull nomic-embed-text");
-            }
-        }
-        else if (status === "not_running") {
-            log("  Ollama not detected. Install it to enable semantic search:");
-            log("    https://ollama.com  →  then: ollama pull nomic-embed-text");
-            ollamaEnabled = await prompts.confirm("Enable semantic search (Ollama not installed yet)?", false);
-            if (ollamaEnabled) {
-                log(style.success("  Semantic search enabled — will activate once Ollama is running."));
-                log("  To disable: set PHREN_OLLAMA_URL=off in your shell profile");
-            }
-        }
-    }
-    catch (err) {
-        logger.debug("init", `init ollamaCheck: ${errorMessage(err)}`);
-    }
-    printSection("Auto-Capture (Optional)");
-    log("After each session, phren scans the conversation for insight-signal phrases");
-    log("(\"always\", \"never\", \"pitfall\", \"gotcha\", etc.) and saves them automatically.");
-    log("  - Runs silently in the Stop hook; captured findings go to FINDINGS.md");
-    log("  - You can review and remove any auto-captured entry at any time");
-    log("  - Can be toggled: set PHREN_FEATURE_AUTO_CAPTURE=0 to disable");
-    const autoCaptureEnabled = await prompts.confirm("Enable auto-capture?", true);
-    let findingsProactivity = "high";
-    if (autoCaptureEnabled) {
-        log("  Findings capture level controls how eager phren is to save lessons automatically.");
-        log("  Change later: npx phren config proactivity.findings <high|medium|low>");
-        findingsProactivity = await prompts.select("Findings capture level", [
-            { value: "high", name: "high (recommended)" },
-            { value: "medium", name: "medium" },
-            { value: "low", name: "low" },
-        ], "high");
-    }
-    else {
-        findingsProactivity = "low";
-    }
-    printSection("Task Management");
-    log("Choose how phren handles tasks as you work.");
-    log("  auto (recommended): captures tasks naturally as you work, links findings to tasks");
-    log("  suggest: proposes tasks but waits for approval before writing");
-    log("  manual: tasks are fully manual — you add them yourself");
-    log("  off: never touch tasks automatically");
-    log("  Change later: npx phren config workflow set --taskMode=<mode>");
-    const taskMode = await prompts.select("Task mode", [
-        { value: "auto", name: "auto (recommended)" },
-        { value: "suggest", name: "suggest" },
-        { value: "manual", name: "manual" },
-        { value: "off", name: "off" },
-    ], "auto");
-    let taskProactivity = "high";
-    if (taskMode === "auto" || taskMode === "suggest") {
-        log("  Task proactivity controls how much evidence phren needs before capturing tasks.");
-        log("  high (recommended): captures tasks as they come up naturally");
-        log("  medium: only when you explicitly mention a task");
-        log("  low: minimal auto-capture");
-        log("  Change later: npx phren config proactivity.tasks <high|medium|low>");
-        taskProactivity = await prompts.select("Task proactivity", [
-            { value: "high", name: "high (recommended)" },
-            { value: "medium", name: "medium" },
-            { value: "low", name: "low" },
-        ], "high");
-    }
-    printSection("Workflow Guardrails");
-    log("Choose how strict review gates should be for risky or low-confidence writes.");
-    log("  lowConfidenceThreshold: confidence cutoff used to mark writes as risky");
-    log("  riskySections: sections always treated as risky");
-    log("  Change later: npx phren config workflow set --lowConfidenceThreshold=0.7 --riskySections=Stale,Conflicts");
-    const thresholdAnswer = await prompts.input("Low-confidence threshold [0.0-1.0]", "0.7");
-    const lowConfidenceThreshold = parseLowConfidenceThreshold(thresholdAnswer, 0.7);
-    const riskySectionsAnswer = await prompts.input("Risky sections [Review,Stale,Conflicts]", "Stale,Conflicts");
-    const riskySections = parseRiskySectionsAnswer(riskySectionsAnswer, ["Stale", "Conflicts"]);
-    // Only offer semantic dedup/conflict when an LLM endpoint is explicitly configured.
-    // These features call /chat/completions, not an embedding endpoint, so we gate on
-    // PHREN_LLM_ENDPOINT (primary) or the presence of a known API key as a fallback.
-    // PHREN_EMBEDDING_API_URL alone is NOT sufficient — it only enables embeddings,
-    // not the LLM chat call that callLlm() makes.
-    const hasLlmApi = Boolean((process.env.PHREN_LLM_ENDPOINT) ||
-        process.env.ANTHROPIC_API_KEY ||
-        process.env.OPENAI_API_KEY);
-    let semanticDedupEnabled = false;
-    let semanticConflictEnabled = false;
-    if (hasLlmApi) {
-        printSection("LLM-Powered Memory Quality (Optional)");
-        log("Phren can use an LLM to catch near-duplicate or conflicting findings.");
-        log("  Requires: PHREN_LLM_ENDPOINT or ANTHROPIC_API_KEY/OPENAI_API_KEY set");
-        log("");
-        log("Semantic dedup: before saving a finding, ask the LLM whether it means the");
-        log("same thing as an existing one (catches same idea with different wording).");
-        semanticDedupEnabled = await prompts.confirm("Enable LLM-powered duplicate detection?", false);
-        log("");
-        log("Conflict detection: after saving a finding, check whether it contradicts an");
-        log("existing one (e.g. \"always use X\" vs \"never use X\"). Adds an inline annotation.");
-        semanticConflictEnabled = await prompts.confirm("Enable LLM-powered conflict detection?", false);
-        if (semanticDedupEnabled || semanticConflictEnabled) {
-            const currentModel = (process.env.PHREN_LLM_MODEL) || "gpt-4o-mini / claude-haiku-4-5-20251001 (default)";
-            log("");
-            log("  Cost note: each semantic check is ~80 input + ~5 output tokens, cached 24h.");
-            log(`  Current model: ${currentModel}`);
-            const llmModel = (process.env.PHREN_LLM_MODEL);
-            const isExpensive = llmModel && /opus|sonnet|gpt-4(?!o-mini)/i.test(llmModel);
-            if (isExpensive) {
-                log(style.warning(`  Warning: ${llmModel} is 20x more expensive than Haiku for yes/no checks.`));
-                log("  Consider: PHREN_LLM_MODEL=claude-haiku-4-5-20251001");
-            }
-            else {
-                log("  With Haiku: fractions of a cent/session. With Opus: ~$0.20/session for heavy use.");
-                log("  Tip: set PHREN_LLM_MODEL=claude-haiku-4-5-20251001 to keep costs low.");
-            }
-        }
-    }
-    printSection("Finding Sensitivity");
-    log("Controls how eagerly agents save findings to memory.");
-    log("  minimal      — only when you explicitly ask");
-    log("  conservative — decisions and pitfalls only");
-    log("  balanced     — non-obvious patterns, decisions, pitfalls, bugs (recommended)");
-    log("  aggressive   — everything worth remembering, err on the side of capturing");
-    log("  Change later: npx phren config finding-sensitivity <level>");
-    const findingSensitivity = await prompts.select("Finding sensitivity", [
-        { value: "balanced", name: "balanced (recommended)" },
-        { value: "conservative", name: "conservative" },
-        { value: "minimal", name: "minimal" },
-        { value: "aggressive", name: "aggressive" },
-    ], "balanced");
-    printSection("GitHub Sync");
-    log(`Phren stores memory as plain Markdown files in a git repo (${storagePath}).`);
-    log("Push it to a private GitHub repo to sync memory across machines.");
-    log("  Hooks will auto-commit + push after every session and pull on start.");
-    log("  Skip this if you just want to try phren locally first.");
-    const githubAnswer = await prompts.input("GitHub username (leave blank to skip)");
-    const githubUsername = githubAnswer || undefined;
-    let githubRepo;
-    if (githubUsername) {
-        const repoAnswer = await prompts.input("Repo name", "my-phren");
-        githubRepo = repoAnswer || "my-phren";
-    }
-    let bootstrapCurrentProject = false;
-    let bootstrapOwnership;
-    const detectedProject = detectProjectDir(process.cwd(), storagePath);
-    if (detectedProject) {
-        const detectedProjectName = path.basename(detectedProject);
-        printSection("Current Project");
-        log(`Detected project: ${detectedProjectName}`);
-        bootstrapCurrentProject = await prompts.confirm("Add this project to phren now?", true);
-        if (!bootstrapCurrentProject) {
-            bootstrapCurrentProject = false;
-            log(style.warning(`  Skipped. Later: cd ${detectedProject} && npx phren add`));
-        }
-        else {
-            bootstrapOwnership = await prompts.select("Ownership for detected project", [
-                { value: projectOwnershipDefault, name: `${projectOwnershipDefault} (default)` },
-                ...PROJECT_OWNERSHIP_MODES
-                    .filter((mode) => mode !== projectOwnershipDefault)
-                    .map((mode) => ({ value: mode, name: mode })),
-            ], projectOwnershipDefault);
-        }
-    }
-    const summaryItems = [
-        `Storage: ${storageChoice} (${storagePath})`,
-        `Machine: ${machine}`,
-        `Profile: ${profile}`,
-        `Domain: ${domain}`,
-        `Project ownership default: ${projectOwnershipDefault}`,
-        `MCP: ${mcp === "on" ? "enabled" : "disabled"}`,
-        `Hooks: ${hooks === "on" ? "enabled" : "disabled"}`,
-        `Auto-capture: ${autoCaptureEnabled ? "enabled" : "disabled"}`,
-        `Findings capture level: ${findingsProactivity}`,
-        `Task mode: ${taskMode}`,
-        `Task proactivity: ${taskProactivity}`,
-        `Low-confidence threshold: ${lowConfidenceThreshold}`,
-        `Risky sections: ${riskySections.join(", ")}`,
-        `Finding sensitivity: ${findingSensitivity}`,
-        `Semantic search: ${ollamaEnabled ? "enabled" : "disabled"}`,
-        `Semantic dedup: ${semanticDedupEnabled ? "enabled" : "disabled"}`,
-        `Semantic conflict detection: ${semanticConflictEnabled ? "enabled" : "disabled"}`,
-        `GitHub sync: ${githubUsername ? `${githubUsername}/${githubRepo ?? "my-phren"}` : "skipped"}`,
-        `Add detected project: ${bootstrapCurrentProject ? `yes (${bootstrapOwnership ?? projectOwnershipDefault})` : "no"}`,
-    ];
-    if (inferredScaffold) {
-        summaryItems.push(`Inference: ${inferredScaffold.reason}`);
-    }
-    printSummary(summaryItems);
-    return {
-        storageChoice,
-        storagePath,
-        storageRepoRoot,
-        machine,
-        profile,
-        mcp,
-        hooks,
-        projectOwnershipDefault,
-        findingsProactivity,
-        taskProactivity,
-        lowConfidenceThreshold,
-        riskySections,
-        taskMode,
-        bootstrapCurrentProject,
-        bootstrapOwnership,
-        ollamaEnabled,
-        autoCaptureEnabled,
-        semanticDedupEnabled,
-        semanticConflictEnabled,
-        findingSensitivity,
-        githubUsername,
-        githubRepo,
-        domain,
-        inferredScaffold: inferredScaffold
-            ? (domain === inferredScaffold.domain
-                ? inferredScaffold
-                : { ...inferredScaffold, domain, topics: [] })
-            : undefined,
-    };
-}
-export async function warmSemanticSearch(phrenPath, profile) {
-    const { checkOllamaAvailable, checkModelAvailable, getOllamaUrl, getEmbeddingModel } = await import("../shared/ollama.js");
-    const ollamaUrl = getOllamaUrl();
-    if (!ollamaUrl)
-        return "Semantic search: disabled.";
-    const model = getEmbeddingModel();
-    if (!await checkOllamaAvailable()) {
-        return `Semantic search not warmed: Ollama offline at ${ollamaUrl}.`;
-    }
-    if (!await checkModelAvailable()) {
-        return `Semantic search not warmed: model ${model} is not pulled yet.`;
-    }
-    const { buildIndex, listIndexedDocumentPaths } = await import("../shared/index.js");
-    const { getEmbeddingCache, formatEmbeddingCoverage } = await import("../shared/embedding-cache.js");
-    const { backgroundEmbedMissingDocs } = await import("../startup-embedding.js");
-    const { getPersistentVectorIndex } = await import("../shared/vector-index.js");
-    const db = await buildIndex(phrenPath, profile);
-    try {
-        const cache = getEmbeddingCache(phrenPath);
-        await cache.load().catch(() => { });
-        const allPaths = listIndexedDocumentPaths(phrenPath, profile);
-        const before = cache.coverage(allPaths);
-        if (before.missing > 0) {
-            await backgroundEmbedMissingDocs(db, cache);
-        }
-        await cache.load().catch(() => { });
-        const after = cache.coverage(allPaths);
-        if (cache.size() > 0) {
-            getPersistentVectorIndex(phrenPath).ensure(cache.getAllEntries());
-        }
-        if (after.total === 0) {
-            return `Semantic search ready (${model}), but there are no indexed docs yet.`;
-        }
-        const embeddedNow = Math.max(0, after.embedded - before.embedded);
-        const prefix = after.state === "warm" ? "Semantic search warmed" : "Semantic search warming";
-        const delta = embeddedNow > 0 ? `; embedded ${embeddedNow} new docs during init` : "";
-        return `${prefix}: ${model}, ${formatEmbeddingCoverage(after)}${delta}.`;
-    }
-    finally {
-        try {
-            db.close();
-        }
-        catch { /* ignore close errors in init */ }
-    }
-}
-function applyOnboardingPreferences(phrenPath, opts) {
-    if (opts.projectOwnershipDefault) {
-        writeInstallPreferences(phrenPath, { projectOwnershipDefault: opts.projectOwnershipDefault });
-    }
-    const runtimePatch = {};
-    if (opts.findingsProactivity)
-        runtimePatch.proactivityFindings = opts.findingsProactivity;
-    if (opts.taskProactivity)
-        runtimePatch.proactivityTask = opts.taskProactivity;
-    if (Object.keys(runtimePatch).length > 0) {
-        writeInstallPreferences(phrenPath, runtimePatch);
-    }
-    const governancePatch = {};
-    if (opts.findingsProactivity)
-        governancePatch.proactivityFindings = opts.findingsProactivity;
-    if (opts.taskProactivity)
-        governancePatch.proactivityTask = opts.taskProactivity;
-    if (Object.keys(governancePatch).length > 0) {
-        writeGovernanceInstallPreferences(phrenPath, governancePatch);
-    }
-    const workflowPatch = {};
-    if (typeof opts.lowConfidenceThreshold === "number")
-        workflowPatch.lowConfidenceThreshold = opts.lowConfidenceThreshold;
-    if (Array.isArray(opts.riskySections))
-        workflowPatch.riskySections = opts.riskySections;
-    if (opts.taskMode)
-        workflowPatch.taskMode = opts.taskMode;
-    if (opts.findingSensitivity)
-        workflowPatch.findingSensitivity = opts.findingSensitivity;
-    if (Object.keys(workflowPatch).length > 0) {
-        updateWorkflowPolicy(phrenPath, workflowPatch);
-    }
-}
-function writeWalkthroughEnvDefaults(phrenPath, opts) {
-    const envFile = path.join(phrenPath, ".env");
-    let envContent = fs.existsSync(envFile) ? fs.readFileSync(envFile, "utf8") : "# phren feature flags — generated by init\n";
-    const envFlags = [];
-    const autoCaptureChoice = opts._walkthroughAutoCapture;
-    const hasAutoCaptureFlag = /^\s*PHREN_FEATURE_AUTO_CAPTURE=.*$/m.test(envContent);
-    if (typeof autoCaptureChoice === "boolean") {
-        envFlags.push({
-            flag: `PHREN_FEATURE_AUTO_CAPTURE=${autoCaptureChoice ? "1" : "0"}`,
-            label: `Auto-capture ${autoCaptureChoice ? "enabled" : "disabled"}`,
-        });
-    }
-    else if (autoCaptureChoice !== false && !hasAutoCaptureFlag) {
-        // Default to enabled on fresh installs and non-walkthrough init.
-        envFlags.push({ flag: "PHREN_FEATURE_AUTO_CAPTURE=1", label: "Auto-capture enabled" });
-    }
-    if (opts._walkthroughSemanticDedup)
-        envFlags.push({ flag: "PHREN_FEATURE_SEMANTIC_DEDUP=1", label: "Semantic dedup" });
-    if (opts._walkthroughSemanticConflict)
-        envFlags.push({ flag: "PHREN_FEATURE_SEMANTIC_CONFLICT=1", label: "Conflict detection" });
-    if (envFlags.length === 0)
-        return [];
-    let changed = false;
-    const enabledLabels = [];
-    for (const { flag, label } of envFlags) {
-        const key = flag.split("=")[0];
-        const lineRe = new RegExp(`^\\s*${key}=.*$`, "m");
-        if (lineRe.test(envContent)) {
-            const before = envContent;
-            envContent = envContent.replace(lineRe, flag);
-            if (envContent !== before) {
-                changed = true;
-                enabledLabels.push(label);
-            }
-        }
-        else {
-            if (!envContent.endsWith("\n"))
-                envContent += "\n";
-            envContent += `${flag}\n`;
-            changed = true;
-            enabledLabels.push(label);
-        }
-    }
-    if (changed) {
-        const tmpPath = `${envFile}.tmp-${crypto.randomUUID()}`;
-        fs.writeFileSync(tmpPath, envContent);
-        fs.renameSync(tmpPath, envFile);
-    }
-    return enabledLabels.map((label) => `${label} (${envFile})`);
-}
-function collectRepairedAssetLabels(repaired) {
-    const repairedAssets = [];
-    if (repaired.createdContextFile)
-        repairedAssets.push("~/.phren-context.md");
-    if (repaired.createdRootMemory)
-        repairedAssets.push("generated MEMORY.md");
-    repairedAssets.push(...repaired.createdGlobalAssets);
-    repairedAssets.push(...repaired.createdRuntimeAssets);
-    repairedAssets.push(...repaired.createdFeatureDefaults);
-    repairedAssets.push(...repaired.createdSkillArtifacts);
-    return repairedAssets;
-}
-function applyProjectStorageBindings(repoRoot, phrenPath) {
-    const updates = [];
-    if (ensureGitignoreEntry(repoRoot, ".phren/")) {
-        updates.push(`${path.join(repoRoot, ".gitignore")} (.phren/)`);
-    }
-    if (upsertProjectEnvVar(repoRoot, "PHREN_PATH", phrenPath)) {
-        updates.push(`${path.join(repoRoot, ".env")} (PHREN_PATH=${phrenPath})`);
-    }
-    return updates;
-}
-async function runProjectLocalInit(opts = {}) {
-    const detectedRoot = detectProjectDir(process.cwd(), path.join(process.cwd(), ".phren")) || process.cwd();
-    const hasWorkspaceMarker = fs.existsSync(path.join(detectedRoot, ".git")) ||
-        fs.existsSync(path.join(detectedRoot, "CLAUDE.md")) ||
-        fs.existsSync(path.join(detectedRoot, "AGENTS.md")) ||
-        fs.existsSync(path.join(detectedRoot, ".claude", "CLAUDE.md"));
-    if (!hasWorkspaceMarker) {
-        throw new Error("project-local mode must be run inside a repo or project root");
-    }
-    const workspaceRoot = path.resolve(detectedRoot);
-    const phrenPath = path.join(workspaceRoot, ".phren");
-    const existingManifest = readRootManifest(phrenPath);
-    if (existingManifest && existingManifest.installMode !== "project-local") {
-        throw new Error(`Refusing to reuse non-local phren root at ${phrenPath}`);
-    }
-    const ownershipDefault = opts.projectOwnershipDefault
-        ?? (existingManifest ? getProjectOwnershipDefault(phrenPath) : "detached");
-    if (!existingManifest && !opts.projectOwnershipDefault) {
-        opts.projectOwnershipDefault = ownershipDefault;
-    }
-    const mcpEnabled = opts.mcp ? opts.mcp === "on" : true;
-    const projectName = path.basename(workspaceRoot).toLowerCase().replace(/[^a-z0-9_-]/g, "-");
-    if (opts.dryRun) {
-        log("\nInit dry run. No files will be written.\n");
-        log(`Mode: project-local`);
-        log(`Workspace root: ${workspaceRoot}`);
-        log(`Phren root: ${phrenPath}`);
-        log(`Project: ${projectName}`);
-        log(`VS Code workspace MCP: ${mcpEnabled ? "on" : "off"}`);
-        log(`Hooks: unsupported in project-local mode`);
-        log("");
-        return;
-    }
-    fs.mkdirSync(phrenPath, { recursive: true });
-    writeRootManifest(phrenPath, {
-        version: 1,
-        installMode: "project-local",
-        syncMode: "workspace-git",
-        workspaceRoot,
-        primaryProject: projectName,
-    });
-    ensureGovernanceFiles(phrenPath);
-    repairPreexistingInstall(phrenPath);
-    fs.mkdirSync(path.join(phrenPath, "global", "skills"), { recursive: true });
-    fs.mkdirSync(path.join(phrenPath, ".runtime"), { recursive: true });
-    fs.mkdirSync(path.join(phrenPath, ".sessions"), { recursive: true });
-    if (!fs.existsSync(path.join(phrenPath, ".gitignore"))) {
-        atomicWriteText(path.join(phrenPath, ".gitignore"), [
-            ".runtime/",
-            ".sessions/",
-            "*.lock",
-            "*.tmp-*",
-            "",
-        ].join("\n"));
-    }
-    if (!fs.existsSync(path.join(phrenPath, "global", "CLAUDE.md"))) {
-        atomicWriteText(path.join(phrenPath, "global", "CLAUDE.md"), "# Global Context\n\nRepo-local Phren instructions shared across this workspace.\n");
-    }
-    const created = bootstrapFromExisting(phrenPath, workspaceRoot, { ownership: ownershipDefault });
-    applyOnboardingPreferences(phrenPath, opts);
-    writeInstallPreferences(phrenPath, {
-        mcpEnabled,
-        hooksEnabled: false,
-        skillsScope: opts.skillsScope ?? "global",
-        installedVersion: VERSION,
-    });
-    try {
-        const vscodeResult = configureVSCode(phrenPath, { mcpEnabled, scope: "workspace" });
-        logMcpTargetStatus("VS Code", vscodeResult, existingManifest ? "Updated" : "Configured");
-    }
-    catch (err) {
-        debugLog(`configureVSCode(workspace) failed: ${errorMessage(err)}`);
-    }
-    log(`\n${existingManifest ? "Updated" : "Created"} project-local phren at ${phrenPath}`);
-    log(`  Workspace root: ${workspaceRoot}`);
-    log(`  Project: ${created.project}`);
-    log(`  Ownership: ${created.ownership}`);
-    log(`  Sync mode: workspace-git`);
-    log(`  Hooks: off (unsupported in project-local mode)`);
-    log(`  VS Code MCP: ${mcpEnabled ? "workspace on" : "workspace off"}`);
-    const verify = runPostInitVerify(phrenPath);
-    log(`\nVerifying setup...`);
-    for (const check of verify.checks) {
-        log(`  ${check.ok ? "pass" : "FAIL"} ${check.name}: ${check.detail}`);
-    }
-}
-/**
- * Configure MCP for all detected AI coding tools (Claude, VS Code, Cursor, Copilot, Codex).
- * @param verb - label used in log messages, e.g. "Updated" or "Configured"
- */
-export function configureMcpTargets(phrenPath, opts, verb = "Configured") {
-    let claudeStatus = "no_settings";
-    try {
-        const status = configureClaude(phrenPath, { mcpEnabled: opts.mcpEnabled, hooksEnabled: opts.hooksEnabled });
-        claudeStatus = status ?? "installed";
-        if (status === "disabled" || status === "already_disabled") {
-            log(`  ${verb} Claude Code hooks (MCP disabled)`);
-        }
-        else {
-            log(`  ${verb} Claude Code MCP + hooks`);
-        }
-    }
-    catch (e) {
-        log(`  Could not configure Claude Code settings (${e}), add manually`);
-    }
-    let vsStatus = "no_vscode";
-    try {
-        vsStatus = configureVSCode(phrenPath, { mcpEnabled: opts.mcpEnabled }) ?? "no_vscode";
-        logMcpTargetStatus("VS Code", vsStatus, verb);
-    }
-    catch (err) {
-        debugLog(`configureVSCode failed: ${errorMessage(err)}`);
-    }
-    let cursorStatus = "no_cursor";
-    try {
-        cursorStatus = configureCursorMcp(phrenPath, { mcpEnabled: opts.mcpEnabled }) ?? "no_cursor";
-        logMcpTargetStatus("Cursor", cursorStatus, verb);
-    }
-    catch (err) {
-        debugLog(`configureCursorMcp failed: ${errorMessage(err)}`);
-    }
-    let copilotStatus = "no_copilot";
-    try {
-        copilotStatus = configureCopilotMcp(phrenPath, { mcpEnabled: opts.mcpEnabled }) ?? "no_copilot";
-        logMcpTargetStatus("Copilot CLI", copilotStatus, verb);
-    }
-    catch (err) {
-        debugLog(`configureCopilotMcp failed: ${errorMessage(err)}`);
-    }
-    let codexStatus = "no_codex";
-    try {
-        codexStatus = configureCodexMcp(phrenPath, { mcpEnabled: opts.mcpEnabled }) ?? "no_codex";
-        logMcpTargetStatus("Codex", codexStatus, verb);
-    }
-    catch (err) {
-        debugLog(`configureCodexMcp failed: ${errorMessage(err)}`);
-    }
-    const allStatuses = [claudeStatus, vsStatus, cursorStatus, copilotStatus, codexStatus];
-    if (allStatuses.some((s) => s === "installed" || s === "already_configured"))
-        return "installed";
-    if (allStatuses.some((s) => s === "disabled" || s === "already_disabled"))
-        return "disabled";
-    return claudeStatus;
-}
-/**
- * Configure hooks if enabled, or log a disabled message.
- * @param verb - label used in log messages, e.g. "Updated" or "Configured"
- */
-function configureHooksIfEnabled(phrenPath, hooksEnabled, verb) {
-    if (hooksEnabled) {
-        try {
-            const hooked = configureAllHooks(phrenPath, { allTools: true });
-            if (hooked.length)
-                log(`  ${verb} hooks: ${hooked.join(", ")}`);
-        }
-        catch (err) {
-            debugLog(`configureAllHooks failed: ${errorMessage(err)}`);
-        }
-    }
-    else {
-        log(`  Hooks are disabled by preference (run: npx phren hooks-mode on)`);
-    }
-    // Install phren CLI wrapper at ~/.local/bin/phren so the bare command works
-    const wrapperInstalled = installPhrenCliWrapper(phrenPath);
-    if (wrapperInstalled) {
-        log(`  ${verb} CLI wrapper: ~/.local/bin/phren`);
-    }
-    else {
-        log(`  Note: phren CLI wrapper not installed (existing non-managed binary, or no entry script found)`);
-    }
-}
 export async function runInit(opts = {}) {
     if ((opts.mode || "shared") === "project-local") {
         await runProjectLocalInit(opts);
@@ -990,7 +113,7 @@ export async function runInit(opts = {}) {
     // doesn't exist yet but the legacy directory does.
     if (!opts._walkthroughStoragePath && !fs.existsSync(phrenPath)) {
         // Pre-rebrand directory name — kept as literal for migration
-        const legacyPath = path.resolve(homePath(".cortex"));
+        const legacyPath = path.resolve((await import("../shared.js")).homePath(".cortex"));
         if (legacyPath !== phrenPath && fs.existsSync(legacyPath) && hasInstallMarkers(legacyPath)) {
             if (!dryRun) {
                 fs.renameSync(legacyPath, phrenPath);
@@ -1523,555 +646,3 @@ export async function runInit(opts = {}) {
     log(`\n  Read ${phrenPath}/README.md for a guided tour of each file.`);
     log(``);
 }
-export async function runMcpMode(modeArg) {
-    const phrenPath = findPhrenPath() || (process.env.PHREN_PATH) || DEFAULT_PHREN_PATH;
-    const manifest = readRootManifest(phrenPath);
-    const normalizedArg = modeArg?.trim().toLowerCase();
-    if (!normalizedArg || normalizedArg === "status") {
-        const current = getMcpEnabledPreference(phrenPath);
-        const hooks = getHooksEnabledPreference(phrenPath);
-        log(`MCP mode: ${current ? "on (recommended)" : "off (hooks-only fallback)"}`);
-        log(`Hooks mode: ${hooks ? "on (active)" : "off (disabled)"}`);
-        log(`Change mode: npx phren mcp-mode on|off`);
-        log(`Hooks toggle: npx phren hooks-mode on|off`);
-        return;
-    }
-    const mode = parseMcpMode(normalizedArg);
-    if (!mode) {
-        throw new Error(`Invalid mode "${modeArg}". Use: on | off | status`);
-    }
-    const enabled = mode === "on";
-    if (manifest?.installMode === "project-local") {
-        const vscodeStatus = configureVSCode(phrenPath, { mcpEnabled: enabled, scope: "workspace" });
-        setMcpEnabledPreference(phrenPath, enabled);
-        log(`MCP mode set to ${mode}.`);
-        log(`VS Code status: ${vscodeStatus}`);
-        log(`Project-local mode only configures workspace VS Code MCP.`);
-        return;
-    }
-    let claudeStatus = "no_settings";
-    let vscodeStatus = "no_vscode";
-    let cursorStatus = "no_cursor";
-    let copilotStatus = "no_copilot";
-    let codexStatus = "no_codex";
-    try {
-        claudeStatus = configureClaude(phrenPath, { mcpEnabled: enabled }) ?? claudeStatus;
-    }
-    catch (err) {
-        debugLog(`mcp-mode: configureClaude failed: ${errorMessage(err)}`);
-    }
-    try {
-        vscodeStatus = configureVSCode(phrenPath, { mcpEnabled: enabled }) ?? vscodeStatus;
-    }
-    catch (err) {
-        debugLog(`mcp-mode: configureVSCode failed: ${errorMessage(err)}`);
-    }
-    try {
-        cursorStatus = configureCursorMcp(phrenPath, { mcpEnabled: enabled }) ?? cursorStatus;
-    }
-    catch (err) {
-        debugLog(`mcp-mode: configureCursorMcp failed: ${errorMessage(err)}`);
-    }
-    try {
-        copilotStatus = configureCopilotMcp(phrenPath, { mcpEnabled: enabled }) ?? copilotStatus;
-    }
-    catch (err) {
-        debugLog(`mcp-mode: configureCopilotMcp failed: ${errorMessage(err)}`);
-    }
-    try {
-        codexStatus = configureCodexMcp(phrenPath, { mcpEnabled: enabled }) ?? codexStatus;
-    }
-    catch (err) {
-        debugLog(`mcp-mode: configureCodexMcp failed: ${errorMessage(err)}`);
-    }
-    // Persist preference only after config writes have been attempted
-    setMcpEnabledPreference(phrenPath, enabled);
-    log(`MCP mode set to ${mode}.`);
-    log(`Claude status: ${claudeStatus}`);
-    log(`VS Code status: ${vscodeStatus}`);
-    log(`Cursor status: ${cursorStatus}`);
-    log(`Copilot CLI status: ${copilotStatus}`);
-    log(`Codex status: ${codexStatus}`);
-    log(`Restart your agent to apply changes.`);
-}
-export async function runHooksMode(modeArg) {
-    const phrenPath = findPhrenPath() || (process.env.PHREN_PATH) || DEFAULT_PHREN_PATH;
-    const manifest = readRootManifest(phrenPath);
-    const normalizedArg = modeArg?.trim().toLowerCase();
-    if (!normalizedArg || normalizedArg === "status") {
-        const current = getHooksEnabledPreference(phrenPath);
-        log(`Hooks mode: ${current ? "on (active)" : "off (disabled)"}`);
-        log(`Change mode: npx phren hooks-mode on|off`);
-        return;
-    }
-    const mode = parseMcpMode(normalizedArg);
-    if (!mode) {
-        throw new Error(`Invalid mode "${modeArg}". Use: on | off | status`);
-    }
-    if (manifest?.installMode === "project-local") {
-        throw new Error("hooks-mode is unsupported in project-local mode");
-    }
-    const enabled = mode === "on";
-    let claudeStatus = "no_settings";
-    try {
-        claudeStatus = configureClaude(phrenPath, {
-            mcpEnabled: getMcpEnabledPreference(phrenPath),
-            hooksEnabled: enabled,
-        }) ?? claudeStatus;
-    }
-    catch (err) {
-        debugLog(`hooks-mode: configureClaude failed: ${errorMessage(err)}`);
-    }
-    if (enabled) {
-        try {
-            const hooked = configureAllHooks(phrenPath, { allTools: true });
-            if (hooked.length)
-                log(`Updated hooks: ${hooked.join(", ")}`);
-        }
-        catch (err) {
-            debugLog(`hooks-mode: configureAllHooks failed: ${errorMessage(err)}`);
-        }
-    }
-    else {
-        log("Hooks will no-op immediately via preference and Claude hooks are removed.");
-    }
-    // Persist preference only after config writes have been attempted
-    setHooksEnabledPreference(phrenPath, enabled);
-    log(`Hooks mode set to ${mode}.`);
-    log(`Claude status: ${claudeStatus}`);
-    log(`Restart your agent to apply changes.`);
-}
-// Agent skill directories to sweep for symlinks during uninstall
-function agentSkillDirs() {
-    const home = homeDir();
-    return [
-        homePath(".claude", "skills"),
-        path.join(home, ".cursor", "skills"),
-        path.join(home, ".copilot", "skills"),
-        path.join(home, ".codex", "skills"),
-    ];
-}
-// Remove skill symlinks that resolve inside phrenPath. Only touches symlinks, never regular files.
-function sweepSkillSymlinks(phrenPath) {
-    const resolvedPhren = path.resolve(phrenPath);
-    for (const dir of agentSkillDirs()) {
-        if (!fs.existsSync(dir))
-            continue;
-        let entries;
-        try {
-            entries = fs.readdirSync(dir, { withFileTypes: true });
-        }
-        catch (err) {
-            debugLog(`sweepSkillSymlinks: readdirSync failed for ${dir}: ${errorMessage(err)}`);
-            continue;
-        }
-        for (const entry of entries) {
-            if (!entry.isSymbolicLink())
-                continue;
-            const fullPath = path.join(dir, entry.name);
-            try {
-                const target = fs.realpathSync(fullPath);
-                if (target.startsWith(resolvedPhren + path.sep) || target === resolvedPhren) {
-                    fs.unlinkSync(fullPath);
-                    log(`  Removed skill symlink: ${fullPath}`);
-                }
-            }
-            catch {
-                // Broken symlink (target no longer exists) — clean it up
-                try {
-                    fs.unlinkSync(fullPath);
-                    log(`  Removed broken skill symlink: ${fullPath}`);
-                }
-                catch (err2) {
-                    debugLog(`sweepSkillSymlinks: could not remove broken symlink ${fullPath}: ${errorMessage(err2)}`);
-                }
-            }
-        }
-        // Remove phren-generated manifest files from the skills parent directory
-        const parentDir = path.dirname(dir);
-        for (const manifestFile of ["skill-manifest.json", "skill-commands.json"]) {
-            const manifestPath = path.join(parentDir, manifestFile);
-            try {
-                if (fs.existsSync(manifestPath)) {
-                    fs.unlinkSync(manifestPath);
-                    log(`  Removed ${manifestFile} (${manifestPath})`);
-                }
-            }
-            catch (err) {
-                debugLog(`sweepSkillSymlinks: could not remove ${manifestPath}: ${errorMessage(err)}`);
-            }
-        }
-    }
-}
-// Filter phren hook entries from an agent hooks file. Returns true if the file was changed.
-// Deletes the file if no hooks remain. `commandField` is the JSON key holding the command
-// string in each hook entry (e.g. "bash" for Copilot, "command" for Codex).
-function filterAgentHooks(filePath, commandField) {
-    if (!fs.existsSync(filePath))
-        return false;
-    try {
-        const raw = JSON.parse(fs.readFileSync(filePath, "utf8"));
-        if (!isRecord(raw) || !isRecord(raw.hooks))
-            return false;
-        const hooks = raw.hooks;
-        let changed = false;
-        for (const event of Object.keys(hooks)) {
-            const entries = hooks[event];
-            if (!Array.isArray(entries))
-                continue;
-            const filtered = entries.filter((e) => !(isRecord(e) && typeof e[commandField] === "string" && isPhrenCommand(e[commandField])));
-            if (filtered.length !== entries.length) {
-                hooks[event] = filtered;
-                changed = true;
-            }
-        }
-        if (!changed)
-            return false;
-        // Remove empty hook event keys
-        for (const event of Object.keys(hooks)) {
-            if (Array.isArray(hooks[event]) && hooks[event].length === 0) {
-                delete hooks[event];
-            }
-        }
-        if (Object.keys(hooks).length === 0) {
-            fs.unlinkSync(filePath);
-        }
-        else {
-            atomicWriteText(filePath, JSON.stringify(raw, null, 2));
-        }
-        return true;
-    }
-    catch (err) {
-        debugLog(`filterAgentHooks: failed for ${filePath}: ${errorMessage(err)}`);
-        return false;
-    }
-}
-async function promptUninstallConfirm(phrenPath) {
-    if (!process.stdin.isTTY || !process.stdout.isTTY)
-        return true;
-    // Show summary of what will be deleted
-    try {
-        const projectDirs = getProjectDirs(phrenPath);
-        const projectCount = projectDirs.length;
-        let findingCount = 0;
-        for (const dir of projectDirs) {
-            const findingsFile = path.join(dir, "FINDINGS.md");
-            if (fs.existsSync(findingsFile)) {
-                const content = fs.readFileSync(findingsFile, "utf8");
-                findingCount += content.split("\n").filter((l) => l.startsWith("- ")).length;
-            }
-        }
-        log(`\n  Will delete: ${phrenPath}`);
-        log(`  Contains: ${projectCount} project(s), ~${findingCount} finding(s)`);
-    }
-    catch (err) {
-        debugLog(`promptUninstallConfirm: summary failed: ${errorMessage(err)}`);
-        log(`\n  Will delete: ${phrenPath}`);
-    }
-    const readline = await import("readline");
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    return new Promise((resolve) => {
-        rl.question(`\nThis will permanently delete ${phrenPath} and all phren data. Type 'yes' to confirm: `, (answer) => {
-            rl.close();
-            resolve(answer.trim().toLowerCase() === "yes");
-        });
-    });
-}
-export async function runUninstall(opts = {}) {
-    const phrenPath = findPhrenPath();
-    const manifest = phrenPath ? readRootManifest(phrenPath) : null;
-    if (manifest?.installMode === "project-local" && phrenPath) {
-        log("\nUninstalling project-local phren...\n");
-        const workspaceRoot = manifest.workspaceRoot || path.dirname(phrenPath);
-        const workspaceMcp = path.join(workspaceRoot, ".vscode", "mcp.json");
-        try {
-            if (removeMcpServerAtPath(workspaceMcp)) {
-                log(`  Removed phren from VS Code workspace MCP config (${workspaceMcp})`);
-            }
-        }
-        catch (err) {
-            debugLog(`uninstall local vscode cleanup failed: ${errorMessage(err)}`);
-        }
-        fs.rmSync(phrenPath, { recursive: true, force: true });
-        log(`  Removed ${phrenPath}`);
-        log("\nProject-local phren uninstalled.");
-        return;
-    }
-    log("\nUninstalling phren...\n");
-    const shouldRemoveGlobalPackage = shouldUninstallCurrentGlobalPackage();
-    // Confirmation prompt (shared-mode only — project-local is low-stakes)
-    if (!opts.yes) {
-        const confirmed = phrenPath
-            ? await promptUninstallConfirm(phrenPath)
-            : (process.stdin.isTTY && process.stdout.isTTY
-                ? await (async () => {
-                    const readline = await import("readline");
-                    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-                    return new Promise((resolve) => {
-                        rl.question("This will remove all phren config and hooks. Type 'yes' to confirm: ", (answer) => {
-                            rl.close();
-                            resolve(answer.trim().toLowerCase() === "yes");
-                        });
-                    });
-                })()
-                : true);
-        if (!confirmed) {
-            log("Uninstall cancelled.");
-            return;
-        }
-    }
-    const home = homeDir();
-    const machineFile = machineFilePath();
-    const settingsPath = hookConfigPath("claude");
-    // Remove from Claude Code ~/.claude.json (where MCP servers are actually read)
-    const claudeJsonPath = homePath(".claude.json");
-    if (fs.existsSync(claudeJsonPath)) {
-        try {
-            if (removeMcpServerAtPath(claudeJsonPath)) {
-                log(`  Removed phren MCP server from ~/.claude.json`);
-            }
-        }
-        catch (e) {
-            log(`  Warning: could not update ~/.claude.json (${e})`);
-        }
-    }
-    // Remove from Claude Code settings.json
-    if (fs.existsSync(settingsPath)) {
-        try {
-            patchJsonFile(settingsPath, (data) => {
-                const hooksMap = isRecord(data.hooks) ? data.hooks : (data.hooks = {});
-                // Remove MCP server
-                if (data.mcpServers?.phren) {
-                    delete data.mcpServers.phren;
-                    log(`  Removed phren MCP server from Claude Code settings`);
-                }
-                // Remove hooks containing phren references
-                for (const hookEvent of ["UserPromptSubmit", "Stop", "SessionStart", "PostToolUse"]) {
-                    const hooks = hooksMap[hookEvent];
-                    if (!Array.isArray(hooks))
-                        continue;
-                    const before = hooks.length;
-                    hooksMap[hookEvent] = hooks.filter((h) => !h.hooks?.some((hook) => typeof hook.command === "string" && isPhrenCommand(hook.command)));
-                    const removed = before - hooksMap[hookEvent].length;
-                    if (removed > 0)
-                        log(`  Removed ${removed} phren hook(s) from ${hookEvent}`);
-                }
-            });
-        }
-        catch (e) {
-            log(`  Warning: could not update Claude Code settings (${e})`);
-        }
-    }
-    else {
-        log(`  Claude Code settings not found at ${settingsPath} — skipping`);
-    }
-    // Remove from VS Code mcp.json
-    const vsCandidates = vscodeMcpCandidates().map((dir) => path.join(dir, "mcp.json"));
-    for (const mcpFile of vsCandidates) {
-        try {
-            if (removeMcpServerAtPath(mcpFile)) {
-                log(`  Removed phren from VS Code MCP config (${mcpFile})`);
-            }
-        }
-        catch (err) {
-            debugLog(`uninstall: cleanup failed for ${mcpFile}: ${errorMessage(err)}`);
-        }
-    }
-    // Remove from Cursor MCP config
-    const cursorCandidates = cursorMcpCandidates();
-    for (const mcpFile of cursorCandidates) {
-        try {
-            if (removeMcpServerAtPath(mcpFile)) {
-                log(`  Removed phren from Cursor MCP config (${mcpFile})`);
-            }
-        }
-        catch (err) {
-            debugLog(`uninstall: cleanup failed for ${mcpFile}: ${errorMessage(err)}`);
-        }
-    }
-    // Remove from Copilot CLI MCP config
-    const copilotCandidates = copilotMcpCandidates();
-    for (const mcpFile of copilotCandidates) {
-        try {
-            if (removeMcpServerAtPath(mcpFile)) {
-                log(`  Removed phren from Copilot CLI MCP config (${mcpFile})`);
-            }
-        }
-        catch (err) {
-            debugLog(`uninstall: cleanup failed for ${mcpFile}: ${errorMessage(err)}`);
-        }
-    }
-    // Remove from Codex MCP config (TOML + JSON)
-    const codexToml = path.join(home, ".codex", "config.toml");
-    try {
-        if (removeTomlMcpServer(codexToml)) {
-            log(`  Removed phren from Codex MCP config (${codexToml})`);
-        }
-    }
-    catch (err) {
-        debugLog(`uninstall: cleanup failed for ${codexToml}: ${errorMessage(err)}`);
-    }
-    const codexCandidates = codexJsonCandidates((process.env.PHREN_PATH) || DEFAULT_PHREN_PATH);
-    for (const mcpFile of codexCandidates) {
-        try {
-            if (removeMcpServerAtPath(mcpFile)) {
-                log(`  Removed phren from Codex MCP config (${mcpFile})`);
-            }
-        }
-        catch (err) {
-            debugLog(`uninstall: cleanup failed for ${mcpFile}: ${errorMessage(err)}`);
-        }
-    }
-    // Remove phren entries from Copilot hooks file (filter, don't bulk-delete)
-    const copilotHooksFile = hookConfigPath("copilot", (process.env.PHREN_PATH) || DEFAULT_PHREN_PATH);
-    try {
-        if (filterAgentHooks(copilotHooksFile, "bash")) {
-            log(`  Removed phren entries from Copilot hooks (${copilotHooksFile})`);
-        }
-    }
-    catch (err) {
-        debugLog(`uninstall: cleanup failed for ${copilotHooksFile}: ${errorMessage(err)}`);
-    }
-    // Remove phren entries from Cursor hooks file (may contain non-phren entries)
-    const cursorHooksFile = hookConfigPath("cursor", (process.env.PHREN_PATH) || DEFAULT_PHREN_PATH);
-    try {
-        if (fs.existsSync(cursorHooksFile)) {
-            const raw = JSON.parse(fs.readFileSync(cursorHooksFile, "utf8"));
-            let changed = false;
-            for (const key of ["sessionStart", "beforeSubmitPrompt", "stop"]) {
-                if (raw[key]?.command && typeof raw[key].command === "string" && isPhrenCommand(raw[key].command)) {
-                    delete raw[key];
-                    changed = true;
-                }
-            }
-            if (changed) {
-                atomicWriteText(cursorHooksFile, JSON.stringify(raw, null, 2));
-                log(`  Removed phren entries from Cursor hooks (${cursorHooksFile})`);
-            }
-        }
-    }
-    catch (err) {
-        debugLog(`uninstall: cleanup failed for ${cursorHooksFile}: ${errorMessage(err)}`);
-    }
-    // Remove phren entries from Codex hooks file (filter, don't bulk-delete)
-    const uninstallPhrenPath = (process.env.PHREN_PATH) || DEFAULT_PHREN_PATH;
-    const codexHooksFile = hookConfigPath("codex", uninstallPhrenPath);
-    try {
-        if (filterAgentHooks(codexHooksFile, "command")) {
-            log(`  Removed phren entries from Codex hooks (${codexHooksFile})`);
-        }
-    }
-    catch (err) {
-        debugLog(`uninstall: cleanup failed for ${codexHooksFile}: ${errorMessage(err)}`);
-    }
-    // Remove session wrapper scripts (written by installSessionWrapper) and CLI wrapper
-    const localBinDir = path.join(home, ".local", "bin");
-    for (const tool of ["copilot", "cursor", "codex", "phren"]) {
-        const wrapperPath = path.join(localBinDir, tool);
-        try {
-            if (fs.existsSync(wrapperPath)) {
-                // Only remove if it's a phren wrapper (check for PHREN_PATH marker)
-                const content = fs.readFileSync(wrapperPath, "utf8");
-                if (content.includes("PHREN_PATH") && content.includes("phren")) {
-                    fs.unlinkSync(wrapperPath);
-                    log(`  Removed ${tool} session wrapper (${wrapperPath})`);
-                }
-            }
-        }
-        catch (err) {
-            debugLog(`uninstall: cleanup failed for ${wrapperPath}: ${errorMessage(err)}`);
-        }
-    }
-    try {
-        if (fs.existsSync(machineFile)) {
-            fs.unlinkSync(machineFile);
-            log(`  Removed machine alias (${machineFile})`);
-        }
-    }
-    catch (err) {
-        debugLog(`uninstall: cleanup failed for ${machineFile}: ${errorMessage(err)}`);
-    }
-    const contextFile = homePath(".phren-context.md");
-    try {
-        if (fs.existsSync(contextFile)) {
-            fs.unlinkSync(contextFile);
-            log(`  Removed machine context file (${contextFile})`);
-        }
-    }
-    catch (err) {
-        debugLog(`uninstall: cleanup failed for ${contextFile}: ${errorMessage(err)}`);
-    }
-    // Remove global CLAUDE.md symlink (created by linkGlobal -> ~/.claude/CLAUDE.md)
-    const globalClaudeLink = homePath(".claude", "CLAUDE.md");
-    try {
-        if (fs.lstatSync(globalClaudeLink).isSymbolicLink()) {
-            fs.unlinkSync(globalClaudeLink);
-            log(`  Removed global CLAUDE.md symlink (${globalClaudeLink})`);
-        }
-    }
-    catch {
-        // Does not exist or not a symlink — nothing to do
-    }
-    // Remove copilot-instructions.md symlink (created by linkGlobal -> ~/.github/copilot-instructions.md)
-    const copilotInstrLink = homePath(".github", "copilot-instructions.md");
-    try {
-        if (fs.lstatSync(copilotInstrLink).isSymbolicLink()) {
-            fs.unlinkSync(copilotInstrLink);
-            log(`  Removed copilot-instructions.md symlink (${copilotInstrLink})`);
-        }
-    }
-    catch {
-        // Does not exist or not a symlink — nothing to do
-    }
-    // Sweep agent skill directories for symlinks pointing into the phren store
-    if (phrenPath) {
-        try {
-            sweepSkillSymlinks(phrenPath);
-        }
-        catch (err) {
-            debugLog(`uninstall: skill symlink sweep failed: ${errorMessage(err)}`);
-        }
-    }
-    if (phrenPath && fs.existsSync(phrenPath)) {
-        try {
-            fs.rmSync(phrenPath, { recursive: true, force: true });
-            log(`  Removed phren root (${phrenPath})`);
-        }
-        catch (err) {
-            debugLog(`uninstall: cleanup failed for ${phrenPath}: ${errorMessage(err)}`);
-            log(`  Warning: could not remove phren root (${phrenPath})`);
-        }
-    }
-    if (shouldRemoveGlobalPackage) {
-        uninstallCurrentGlobalPackage();
-    }
-    // Remove VS Code extension if installed
-    try {
-        const codeResult = execFileSync("code", ["--list-extensions"], {
-            encoding: "utf8",
-            stdio: ["ignore", "pipe", "ignore"],
-            timeout: 10_000,
-        });
-        const phrenExts = codeResult.split("\n").filter((ext) => ext.toLowerCase().includes("phren"));
-        for (const ext of phrenExts) {
-            const trimmed = ext.trim();
-            if (!trimmed)
-                continue;
-            try {
-                execFileSync("code", ["--uninstall-extension", trimmed], {
-                    stdio: ["ignore", "pipe", "ignore"],
-                    timeout: 15_000,
-                });
-                log(`  Removed VS Code extension (${trimmed})`);
-            }
-            catch (err) {
-                debugLog(`uninstall: VS Code extension removal failed for ${trimmed}: ${errorMessage(err)}`);
-            }
-        }
-    }
-    catch {
-        // code CLI not available — skip
-    }
-    log(`\nPhren config, hooks, and installed data removed.`);
-    log(`Restart your agent(s) to apply changes.\n`);
-}