@phren/cli 0.0.28 → 0.0.32

package/mcp/dist/init-uninstall.js

@@ -0,0 +1,482 @@
+/**
+ * Uninstall logic for phren: removes MCP config, hooks, skill symlinks,
+ * and the phren data directory.
+ */
+import * as fs from "fs";
+import * as path from "path";
+import { execFileSync, spawnSync } from "child_process";
+import { isPhrenCommand, removeMcpServerAtPath, removeTomlMcpServer, patchJsonFile, } from "./init/config.js";
+import { atomicWriteText, debugLog, isRecord, homeDir, homePath, findPhrenPath, getProjectDirs, readRootManifest, hookConfigPath, } from "./shared.js";
+import { errorMessage } from "./utils.js";
+import { machineFilePath } from "./machine-identity.js";
+import { codexJsonCandidates, copilotMcpCandidates, cursorMcpCandidates, vscodeMcpCandidates, } from "./provider-adapters.js";
+import { DEFAULT_PHREN_PATH, log } from "./init/shared.js";
+const PHREN_NPM_PACKAGE_NAME = "@phren/cli";
+function getNpmCommand() {
+    return process.platform === "win32" ? "npm.cmd" : "npm";
+}
+const UNINSTALL_TIMEOUT_MS = 30_000;
+function runSyncCommand(command, args) {
+    try {
+        const result = spawnSync(command, args, {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"],
+            timeout: UNINSTALL_TIMEOUT_MS,
+        });
+        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}`);
+}
+// 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) {
+            // Hooks are empty but the config may contain other top-level keys (e.g. version).
+            // Only delete the file if the entire config is effectively empty.
+            const otherKeys = Object.keys(raw).filter((k) => k !== "hooks");
+            if (otherKeys.length === 0) {
+                fs.unlinkSync(filePath);
+            }
+            else {
+                atomicWriteText(filePath, JSON.stringify(raw, null, 2));
+            }
+        }
+        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(phrenPath || 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", phrenPath || 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", phrenPath || 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 codexHooksFile = hookConfigPath("codex", phrenPath || DEFAULT_PHREN_PATH);
+    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)
+    const localBinDir = path.join(home, ".local", "bin");
+    for (const tool of ["copilot", "cursor", "codex"]) {
+        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)}`);
+    }
+    // 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`);
+}

package/mcp/dist/init-update.js

@@ -0,0 +1,96 @@
+/**
+ * Update logic for existing phren installs.
+ */
+import { hookConfigPath, writeRootManifest, } from "./shared.js";
+import { isVersionNewer } from "./init-npm.js";
+import { readInstallPreferences, writeInstallPreferences, } from "./init/preferences.js";
+import { ensureGovernanceFiles, repairPreexistingInstall, runPostInitVerify, applyStarterTemplateUpdates, ensureLocalGitRepo, } from "./init/setup.js";
+import { getWorkflowPolicy } from "./shared/governance.js";
+import { VERSION, log, confirmPrompt } from "./init/shared.js";
+import { configureMcpTargets } from "./init-mcp.js";
+import { configureHooksIfEnabled } from "./init-hooks.js";
+import { applyOnboardingPreferences, writeWalkthroughEnvDefaults, collectRepairedAssetLabels, } from "./init-env.js";
+import { getPendingBootstrapTarget } from "./init-detect.js";
+import { bootstrapProject } from "./init-bootstrap.js";
+export async function runExistingInstallUpdate(phrenPath, opts, params) {
+    const { mcpEnabled, hooksEnabled, skillsScope, ownershipDefault, syncIntent, shouldBootstrapCurrentProject, bootstrapOwnership, } = params;
+    const mcpLabel = mcpEnabled ? "ON (recommended)" : "OFF (hooks-only fallback)";
+    const hooksLabel = hooksEnabled ? "ON (active)" : "OFF (disabled)";
+    writeRootManifest(phrenPath, {
+        version: 1,
+        installMode: "shared",
+        syncMode: "managed-git",
+    });
+    ensureGovernanceFiles(phrenPath);
+    const repaired = repairPreexistingInstall(phrenPath);
+    applyOnboardingPreferences(phrenPath, opts);
+    const existingGitRepo = ensureLocalGitRepo(phrenPath);
+    log(`\nphren already exists at ${phrenPath}`);
+    log(`Updating configuration...\n`);
+    log(`  MCP mode: ${mcpLabel}`);
+    log(`  Hooks mode: ${hooksLabel}`);
+    log(`  Default project ownership: ${ownershipDefault}`);
+    log(`  Task mode: ${getWorkflowPolicy(phrenPath).taskMode}`);
+    log(`  Git repo: ${existingGitRepo.detail}`);
+    // Confirmation prompt before writing config
+    if (!opts.yes) {
+        const settingsPath = hookConfigPath("claude");
+        const modifications = [];
+        modifications.push(`  ${settingsPath}  (update MCP server + hooks)`);
+        log(`\nWill modify:`);
+        for (const mod of modifications)
+            log(mod);
+        const confirmed = await confirmPrompt("\nProceed?");
+        if (!confirmed) {
+            log("Aborted.");
+            return;
+        }
+    }
+    // Always reconfigure MCP and hooks (picks up new features on upgrade)
+    configureMcpTargets(phrenPath, { mcpEnabled, hooksEnabled }, "Updated");
+    configureHooksIfEnabled(phrenPath, hooksEnabled, "Updated");
+    const prefs = readInstallPreferences(phrenPath);
+    const previousVersion = prefs.installedVersion;
+    if (isVersionNewer(VERSION, previousVersion)) {
+        log(`\n  Starter template update available: v${previousVersion} -> v${VERSION}`);
+        log(`  Run \`npx phren init --apply-starter-update\` to refresh global/CLAUDE.md and global skills.`);
+    }
+    if (opts.applyStarterUpdate) {
+        const updated = applyStarterTemplateUpdates(phrenPath);
+        if (updated.length) {
+            log(`  Applied starter template updates (${updated.length} file${updated.length === 1 ? "" : "s"}).`);
+        }
+        else {
+            log(`  No starter template updates were applied (starter files not found).`);
+        }
+    }
+    writeInstallPreferences(phrenPath, { mcpEnabled, hooksEnabled, skillsScope, installedVersion: VERSION, syncIntent });
+    if (repaired.removedLegacyProjects > 0) {
+        log(`  Removed ${repaired.removedLegacyProjects} legacy starter project entr${repaired.removedLegacyProjects === 1 ? "y" : "ies"} from profiles.`);
+    }
+    const repairedAssets = collectRepairedAssetLabels(repaired);
+    if (repairedAssets.length > 0) {
+        log(`  Recreated missing generated assets: ${repairedAssets.join(", ")}`);
+    }
+    // Post-update verification
+    log(`\nVerifying setup...`);
+    const verify = runPostInitVerify(phrenPath);
+    for (const check of verify.checks) {
+        log(`  ${check.ok ? "pass" : "FAIL"} ${check.name}: ${check.detail}`);
+    }
+    const pendingBootstrap = getPendingBootstrapTarget(phrenPath, opts);
+    if (pendingBootstrap && shouldBootstrapCurrentProject) {
+        bootstrapProject(phrenPath, pendingBootstrap.path, opts.profile, bootstrapOwnership, "Added current project");
+    }
+    for (const envLabel of writeWalkthroughEnvDefaults(phrenPath, opts)) {
+        log(`  ${envLabel}`);
+    }
+    log(`\n\x1b[95m◆\x1b[0m phren updated successfully`);
+    log(`\nNext steps:`);
+    log(`  1. Start a new Claude session in your project directory — phren injects context automatically`);
+    log(`  2. Run \`npx phren doctor\` to verify everything is wired correctly`);
+    log(`  3. Change defaults anytime: \`npx phren config project-ownership\`, \`npx phren config workflow\`, \`npx phren config proactivity.findings\`, \`npx phren config proactivity.tasks\``);
+    log(`  4. After your first week, run phren-discover to surface gaps in your project knowledge`);
+    log(`  5. After working across projects, run phren-consolidate to find cross-project patterns`);
+    log(``);
+}

package/mcp/dist/init-walkthrough-merge.js

@@ -0,0 +1,90 @@
+/**
+ * Merge walkthrough answers back into InitOptions.
+ */
+import { execFileSync } from "child_process";
+import { runWalkthrough } from "./init-walkthrough.js";
+import { resolveInitPhrenPath, hasInstallMarkers } from "./init-detect.js";
+import { log } from "./init/shared.js";
+/**
+ * Run the interactive walkthrough for first-time installs, merging answers into opts.
+ * Mutates opts in-place and returns the (possibly updated) phrenPath and hasExistingInstall.
+ */
+export async function mergeWalkthroughAnswers(phrenPath, hasExisting, opts) {
+    const answers = await runWalkthrough(phrenPath);
+    opts._walkthroughStorageChoice = answers.storageChoice;
+    opts._walkthroughStoragePath = answers.storagePath;
+    opts._walkthroughStorageRepoRoot = answers.storageRepoRoot;
+    const newPhrenPath = resolveInitPhrenPath(opts);
+    const newHasExisting = hasInstallMarkers(newPhrenPath);
+    opts.machine = opts.machine || answers.machine;
+    opts.profile = opts.profile || answers.profile;
+    opts.mcp = opts.mcp || answers.mcp;
+    opts.hooks = opts.hooks || answers.hooks;
+    opts.projectOwnershipDefault = opts.projectOwnershipDefault || answers.projectOwnershipDefault;
+    opts.findingsProactivity = opts.findingsProactivity || answers.findingsProactivity;
+    opts.taskProactivity = opts.taskProactivity || answers.taskProactivity;
+    if (typeof opts.lowConfidenceThreshold !== "number")
+        opts.lowConfidenceThreshold = answers.lowConfidenceThreshold;
+    if (!Array.isArray(opts.riskySections))
+        opts.riskySections = answers.riskySections;
+    opts.taskMode = opts.taskMode || answers.taskMode;
+    if (answers.cloneUrl) {
+        opts._walkthroughCloneUrl = answers.cloneUrl;
+    }
+    if (answers.githubRepo) {
+        opts._walkthroughGithub = { username: answers.githubUsername, repo: answers.githubRepo };
+    }
+    opts._walkthroughDomain = answers.domain;
+    if (answers.inferredScaffold) {
+        opts._walkthroughInferredScaffold = answers.inferredScaffold;
+    }
+    if (!answers.ollamaEnabled) {
+        process.env._PHREN_WALKTHROUGH_OLLAMA_SKIP = "1";
+    }
+    else {
+        opts._walkthroughSemanticSearch = true;
+    }
+    opts._walkthroughAutoCapture = answers.autoCaptureEnabled;
+    if (answers.semanticDedupEnabled) {
+        opts._walkthroughSemanticDedup = true;
+    }
+    if (answers.semanticConflictEnabled) {
+        opts._walkthroughSemanticConflict = true;
+    }
+    if (answers.findingSensitivity && answers.findingSensitivity !== "balanced") {
+        opts.findingSensitivity = answers.findingSensitivity;
+    }
+    opts._walkthroughBootstrapCurrentProject = answers.bootstrapCurrentProject;
+    opts._walkthroughBootstrapOwnership = answers.bootstrapOwnership;
+    return { phrenPath: newPhrenPath, hasExistingInstall: newHasExisting };
+}
+/**
+ * Clone an existing phren from a remote URL.
+ * @returns true if the clone succeeded (existing install), false otherwise
+ */
+export function cloneExistingPhren(phrenPath, cloneUrl) {
+    log(`\nCloning existing phren from ${cloneUrl}...`);
+    try {
+        execFileSync("git", ["clone", cloneUrl, phrenPath], {
+            stdio: ["ignore", "pipe", "pipe"],
+            timeout: 60_000,
+        });
+        log(`  Cloned to ${phrenPath}`);
+        return true;
+    }
+    catch (e) {
+        log(`  Clone failed: ${e instanceof Error ? e.message : String(e)}`);
+        log("");
+        log("  ┌──────────────────────────────────────────────────────────────────┐");
+        log("  │  WARNING: Sync is NOT configured. Your phren data is local-only. │");
+        log("  │                                                                  │");
+        log("  │  To fix later:                                                   │");
+        log(`  │    cd ${phrenPath}`);
+        log("  │    git remote add origin <YOUR_REPO_URL>                         │");
+        log("  │    git push -u origin main                                       │");
+        log("  └──────────────────────────────────────────────────────────────────┘");
+        log("");
+        log(`  Continuing with fresh local-only install.`);
+        return false;
+    }
+}