@phren/cli 0.0.1

package/mcp/dist/skill-registry.js

@@ -0,0 +1,279 @@
+import * as fs from "fs";
+import * as path from "path";
+import { getProjectDirs } from "./shared.js";
+import { parseSkillFrontmatter } from "./link-skills.js";
+import { isSkillEnabled } from "./skill-state.js";
+function normalizeCommand(raw, fallbackName) {
+    const value = typeof raw === "string" && raw.trim() ? raw.trim() : `/${fallbackName}`;
+    return value.startsWith("/") ? value : `/${value}`;
+}
+function normalizeAliases(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    const seen = new Set();
+    const aliases = [];
+    for (const value of raw) {
+        if (typeof value !== "string" || !value.trim())
+            continue;
+        const normalized = value.trim().startsWith("/") ? value.trim() : `/${value.trim()}`;
+        const key = normalized.toLowerCase();
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        aliases.push(normalized);
+    }
+    return aliases;
+}
+function collectSkills(phrenPath, root, sourceLabel, scopeType, sourceKind, seen) {
+    if (!fs.existsSync(root))
+        return [];
+    const results = [];
+    for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+        const isFolder = entry.isDirectory();
+        const filePath = isFolder
+            ? path.join(root, entry.name, "SKILL.md")
+            : entry.name.endsWith(".md") ? path.join(root, entry.name) : null;
+        if (!filePath || seen.has(filePath) || !fs.existsSync(filePath))
+            continue;
+        seen.add(filePath);
+        const name = isFolder ? entry.name : entry.name.replace(/\.md$/, "");
+        const { frontmatter } = parseSkillFrontmatter(fs.readFileSync(filePath, "utf8"));
+        results.push({
+            name,
+            source: sourceLabel,
+            scopeType,
+            sourceKind,
+            format: isFolder ? "folder" : "flat",
+            path: filePath,
+            root: isFolder ? path.dirname(filePath) : filePath,
+            description: frontmatter?.description,
+            enabled: isSkillEnabled(phrenPath, sourceLabel, name),
+            command: normalizeCommand(frontmatter?.command, name),
+            aliases: normalizeAliases(frontmatter?.aliases),
+        });
+    }
+    return results;
+}
+function getGlobalSkills(phrenPath) {
+    const seen = new Set();
+    return collectSkills(phrenPath, path.join(phrenPath, "global", "skills"), "global", "global", "canonical", seen);
+}
+function getProjectLocalSkills(phrenPath, project) {
+    const seen = new Set();
+    const projectDir = path.join(phrenPath, project);
+    return collectSkills(phrenPath, path.join(projectDir, "skills"), project, "project", "canonical", seen);
+}
+function skillPriority(skill) {
+    if (skill.scopeType === "project" && skill.sourceKind === "canonical")
+        return 400;
+    if (skill.scopeType === "global" && skill.sourceKind === "canonical")
+        return 200;
+    return 100;
+}
+function choosePreferredSkill(skills) {
+    return [...skills].sort((left, right) => {
+        const priority = skillPriority(right) - skillPriority(left);
+        if (priority !== 0)
+            return priority;
+        return left.path.localeCompare(right.path);
+    })[0];
+}
+function buildResolvedSkills(raw, mirrorDir) {
+    const grouped = new Map();
+    for (const skill of raw) {
+        const key = skill.name.toLowerCase();
+        const bucket = grouped.get(key) || [];
+        bucket.push(skill);
+        grouped.set(key, bucket);
+    }
+    const skills = [];
+    for (const [key, candidates] of grouped.entries()) {
+        const chosen = choosePreferredSkill(candidates);
+        const overrides = candidates
+            .filter((candidate) => candidate.path !== chosen.path)
+            .map((candidate) => ({
+            source: candidate.source,
+            path: candidate.path,
+            sourceKind: candidate.sourceKind,
+        }));
+        const destName = chosen.format === "folder" ? chosen.name : path.basename(chosen.path);
+        skills.push({
+            path: chosen.path,
+            format: chosen.format,
+            root: chosen.root,
+            name: chosen.name,
+            source: chosen.source,
+            enabled: chosen.enabled,
+            description: chosen.description,
+            command: chosen.command,
+            aliases: chosen.aliases,
+            scopeType: chosen.scopeType,
+            sourceKind: chosen.sourceKind,
+            visibleToAgents: chosen.enabled,
+            commandRegistered: true,
+            overrides,
+            mirrorTargets: mirrorDir ? [path.join(mirrorDir, destName)] : [],
+        });
+        grouped.delete(key);
+    }
+    skills.sort((left, right) => left.name.localeCompare(right.name));
+    const commandOwners = new Map();
+    for (const skill of skills) {
+        if (!skill.visibleToAgents)
+            continue;
+        for (const command of [skill.command, ...skill.aliases]) {
+            const key = command.toLowerCase();
+            const owners = commandOwners.get(key) || [];
+            owners.push({ skillId: skill.name, command });
+            commandOwners.set(key, owners);
+        }
+    }
+    const problems = [];
+    const collisionKeys = new Set();
+    for (const [key, owners] of commandOwners.entries()) {
+        if (owners.length < 2)
+            continue;
+        collisionKeys.add(key);
+        problems.push({
+            code: "command-collision",
+            command: owners[0]?.command,
+            skillIds: owners.map((owner) => owner.skillId),
+            message: `Command ${owners[0]?.command || key} resolves ambiguously across ${owners.map((owner) => owner.skillId).join(", ")}.`,
+        });
+    }
+    const commands = [];
+    for (const skill of skills) {
+        const commandEntries = [
+            { command: skill.command, kind: "primary" },
+            ...skill.aliases.map((alias) => ({ command: alias, kind: "alias" })),
+        ];
+        skill.commandRegistered = skill.visibleToAgents && !collisionKeys.has(skill.command.toLowerCase());
+        for (const entry of commandEntries) {
+            commands.push({
+                command: entry.command,
+                type: "skill",
+                skillId: skill.name,
+                source: skill.source,
+                path: skill.path,
+                kind: entry.kind,
+                registered: skill.visibleToAgents && !collisionKeys.has(entry.command.toLowerCase()),
+            });
+        }
+    }
+    return {
+        scope: "global",
+        generatedAt: new Date().toISOString(),
+        skills,
+        commands,
+        problems,
+    };
+}
+function toResolvedSkill(skill) {
+    return {
+        path: skill.path,
+        format: skill.format,
+        root: skill.root,
+        name: skill.name,
+        source: skill.source,
+        enabled: skill.enabled,
+        description: skill.description,
+        command: skill.command,
+        aliases: skill.aliases,
+        scopeType: skill.scopeType,
+        sourceKind: skill.sourceKind,
+        visibleToAgents: skill.enabled,
+        commandRegistered: skill.enabled,
+        overrides: [],
+        mirrorTargets: [],
+    };
+}
+export function getAllSkills(phrenPath, profile) {
+    const all = getGlobalSkills(phrenPath);
+    for (const dir of getProjectDirs(phrenPath, profile)) {
+        const source = path.basename(dir);
+        if (source === "global")
+            continue;
+        all.push(...getProjectLocalSkills(phrenPath, source));
+    }
+    return all;
+}
+export function getLocalSkills(phrenPath, scope) {
+    if (scope.toLowerCase() === "global")
+        return getGlobalSkills(phrenPath);
+    return getProjectLocalSkills(phrenPath, scope);
+}
+export function buildSkillManifest(phrenPath, profile, scope, mirrorDir) {
+    const manifest = scope.toLowerCase() === "global"
+        ? buildResolvedSkills(getGlobalSkills(phrenPath), mirrorDir)
+        : buildResolvedSkills([...getGlobalSkills(phrenPath), ...getProjectLocalSkills(phrenPath, scope)], mirrorDir);
+    manifest.scope = scope;
+    manifest.project = scope.toLowerCase() === "global" ? undefined : scope;
+    manifest.generatedAt = new Date().toISOString();
+    return manifest;
+}
+export function getScopedSkills(phrenPath, profile, project) {
+    if (!project)
+        return getAllSkills(phrenPath, profile).map(toResolvedSkill);
+    return buildSkillManifest(phrenPath, profile, project).skills;
+}
+export function findLocalSkill(phrenPath, scope, name) {
+    const needle = name.replace(/\.md$/i, "").toLowerCase();
+    const matches = getLocalSkills(phrenPath, scope).filter((skill) => skill.name.toLowerCase() === needle);
+    if (matches.length === 0)
+        return null;
+    return toResolvedSkill(choosePreferredSkill(matches));
+}
+export function findSkill(phrenPath, profile, project, name) {
+    const needle = name.replace(/\.md$/i, "").toLowerCase();
+    if (project) {
+        const matches = buildSkillManifest(phrenPath, profile, project).skills.filter((skill) => skill.name.toLowerCase() === needle);
+        return matches[0] || null;
+    }
+    const matches = getAllSkills(phrenPath, profile).filter((skill) => skill.name.toLowerCase() === needle);
+    if (matches.length === 0)
+        return null;
+    if (matches.length > 1) {
+        return { error: `Skill '${name}' exists in multiple scopes: ${matches.map((match) => match.source).join(", ")}. Pass project= to disambiguate.` };
+    }
+    return toResolvedSkill(matches[0]);
+}
+export function renderSkillInstructionsSection(manifest) {
+    const visible = manifest.skills.filter((skill) => skill.visibleToAgents);
+    const disabled = manifest.skills.filter((skill) => !skill.visibleToAgents);
+    const lines = [
+        "<!-- phren:generated-skills -->",
+        "## Available Phren skills",
+        "",
+        "These skills are resolved from Phren source files and mirrored into `.claude/skills/` for agent discovery.",
+        "",
+    ];
+    if (!visible.length) {
+        lines.push("No enabled skills are resolved for this scope.");
+    }
+    else {
+        lines.push("| Command | Skill | Scope | Source |");
+        lines.push("| --- | --- | --- | --- |");
+        for (const skill of visible) {
+            lines.push(`| \`${skill.command}\` | \`${skill.name}\` | \`${skill.source}\` | \`${skill.path}\` |`);
+        }
+    }
+    if (disabled.length) {
+        lines.push("");
+        lines.push("Disabled skills:");
+        for (const skill of disabled) {
+            lines.push(`- \`${skill.name}\` (${skill.source})`);
+        }
+    }
+    if (manifest.problems.length) {
+        lines.push("");
+        lines.push("Skill registry problems:");
+        for (const problem of manifest.problems) {
+            lines.push(`- ${problem.message}`);
+        }
+    }
+    lines.push("");
+    lines.push("Generated artifacts:");
+    lines.push("- `.claude/skill-manifest.json`");
+    lines.push("- `.claude/skill-commands.json`");
+    return lines.join("\n");
+}

package/mcp/dist/skill-state.js

@@ -0,0 +1,28 @@
+import { readInstallPreferences, writeInstallPreferences } from "./init-preferences.js";
+function skillStateKey(scope, name) {
+    return `${scope}:${name.replace(/\.md$/i, "").trim().toLowerCase()}`;
+}
+function readDisabledSkillMap(phrenPath) {
+    const prefs = readInstallPreferences(phrenPath);
+    return prefs.disabledSkills && typeof prefs.disabledSkills === "object"
+        ? { ...prefs.disabledSkills }
+        : {};
+}
+export function isSkillEnabled(phrenPath, scope, name) {
+    const disabled = readDisabledSkillMap(phrenPath);
+    return disabled[skillStateKey(scope, name)] !== true;
+}
+export function setSkillEnabled(phrenPath, scope, name, enabled) {
+    const disabled = readDisabledSkillMap(phrenPath);
+    const key = skillStateKey(scope, name);
+    if (enabled)
+        delete disabled[key];
+    else
+        disabled[key] = true;
+    writeInstallPreferences(phrenPath, {
+        disabledSkills: Object.keys(disabled).length ? disabled : undefined,
+    });
+}
+export function getSkillStateKey(scope, name) {
+    return skillStateKey(scope, name);
+}

package/mcp/dist/startup-embedding.js

@@ -0,0 +1,57 @@
+import { debugLog } from "./shared.js";
+import { decodeStringRow, queryRows } from "./shared-index.js";
+import { errorMessage } from "./utils.js";
+/** Throttle delay between embedding requests in the background embed loop. */
+const BACKGROUND_EMBED_THROTTLE_MS = 50;
+async function loadWarmupDeps() {
+    const { checkOllamaAvailable, embedText, getEmbeddingModel, getOllamaUrl } = await import("./shared-ollama.js");
+    return {
+        checkOllamaAvailable,
+        embedText,
+        getEmbeddingModel,
+        getOllamaUrl,
+        sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+    };
+}
+export function startEmbeddingWarmup(db, cache, deps) {
+    const loadPromise = cache.load().catch((err) => {
+        debugLog(`Embedding cache startup load failed: ${errorMessage(err)}`);
+    });
+    const backgroundPromise = backgroundEmbedMissingDocs(db, cache, deps);
+    return { loadPromise, backgroundPromise };
+}
+export async function backgroundEmbedMissingDocs(db, cache, deps) {
+    try {
+        const resolved = { ...(await loadWarmupDeps()), ...deps };
+        if (!resolved.getOllamaUrl())
+            return 0;
+        if (!await resolved.checkOllamaAvailable())
+            return 0;
+        const rows = queryRows(db, "SELECT path, content FROM docs", []);
+        if (!rows)
+            return 0;
+        const model = resolved.getEmbeddingModel();
+        let count = 0;
+        for (const row of rows) {
+            const [docPath, content] = decodeStringRow(row, 2, "backgroundEmbedMissingDocs");
+            if (cache.get(docPath, model))
+                continue;
+            const vec = await resolved.embedText(content.slice(0, 8000));
+            if (vec) {
+                cache.set(docPath, model, vec);
+                count++;
+                if (count % 10 === 0)
+                    await cache.flush();
+            }
+            await resolved.sleep(BACKGROUND_EMBED_THROTTLE_MS);
+        }
+        if (count > 0)
+            await cache.flush();
+        debugLog(`backgroundEmbedMissingDocs: embedded ${count} new docs`);
+        return count;
+    }
+    catch (err) {
+        debugLog(`backgroundEmbedMissingDocs error: ${errorMessage(err)}`);
+        return 0;
+    }
+}

package/mcp/dist/status.js

@@ -0,0 +1,323 @@
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
+import { findPhrenPath, getProjectDirs, EXEC_TIMEOUT_QUICK_MS, debugLog, isRecord, hookConfigPath, homeDir, readRootManifest, } from "./shared.js";
+import { buildIndex, detectProject, findFtsCacheForPath, listIndexedDocumentPaths, queryRows } from "./shared-index.js";
+import { getMcpEnabledPreference, getHooksEnabledPreference } from "./init.js";
+import { getTelemetrySummary } from "./telemetry.js";
+import { runGit as runGitShared } from "./utils.js";
+import { readRuntimeHealth, resolveTaskFilePath } from "./data-access.js";
+import { resolveRuntimeProfile } from "./runtime-profile.js";
+import { renderPhrenArt } from "./phren-art.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+function readPackageVersion() {
+    try {
+        const pkgPath = path.resolve(__dirname, "..", "..", "package.json");
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+        return typeof pkg.version === "string" ? pkg.version : "unknown";
+    }
+    catch (err) {
+        if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+            process.stderr.write(`[phren] readPackageVersion: ${err instanceof Error ? err.message : String(err)}\n`);
+        return "unknown";
+    }
+}
+const RESET = "\x1b[0m";
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+const GREEN = "\x1b[32m";
+const YELLOW = "\x1b[33m";
+const RED = "\x1b[31m";
+const CYAN = "\x1b[36m";
+function check(ok) {
+    return ok ? `${GREEN}ok${RESET}` : `${RED}missing${RESET}`;
+}
+function countBullets(filePath) {
+    if (!fs.existsSync(filePath))
+        return 0;
+    const content = fs.readFileSync(filePath, "utf8");
+    return content.split("\n").filter((l) => l.startsWith("- ")).length;
+}
+function countQueueItems(phrenPath, project) {
+    const queueFile = path.join(phrenPath, project, "MEMORY_QUEUE.md");
+    return countBullets(queueFile);
+}
+function runGit(cwd, args) {
+    return runGitShared(cwd, args, EXEC_TIMEOUT_QUICK_MS, debugLog);
+}
+function hasCommandHook(value) {
+    if (!Array.isArray(value))
+        return false;
+    return value.some((entry) => {
+        if (!isRecord(entry) || !Array.isArray(entry.hooks))
+            return false;
+        return entry.hooks.some((hook) => isRecord(hook) && typeof hook.command === "string" && (hook.command.includes("phren") || hook.command.includes("phren")));
+    });
+}
+export async function runStatus() {
+    const phrenPath = findPhrenPath();
+    if (!phrenPath) {
+        console.log(`${RED}phren not found${RESET}. Run ${CYAN}npx phren init${RESET} to set up.`);
+        process.exit(1);
+    }
+    const cwd = process.cwd();
+    const manifest = readRootManifest(phrenPath);
+    const profile = resolveRuntimeProfile(phrenPath);
+    const activeProject = detectProject(phrenPath, cwd, profile);
+    const version = readPackageVersion();
+    console.log("");
+    console.log(renderPhrenArt("  "));
+    console.log(`\n${BOLD}phren${RESET} ${DIM}v${version}${RESET}\n`);
+    // Active project
+    if (activeProject) {
+        console.log(`  ${DIM}project${RESET}  ${activeProject}`);
+    }
+    // Phren path and config
+    console.log(`  ${DIM}path${RESET}     ${phrenPath}`);
+    console.log(`  ${DIM}mode${RESET}     ${manifest?.installMode || "unknown"}`);
+    if (manifest?.workspaceRoot) {
+        console.log(`  ${DIM}workspace${RESET} ${manifest.workspaceRoot}`);
+    }
+    if (manifest?.syncMode) {
+        console.log(`  ${DIM}sync${RESET}     ${manifest.syncMode}`);
+    }
+    if (profile) {
+        console.log(`  ${DIM}profile${RESET}  ${profile}`);
+    }
+    // MCP + hooks status
+    const mcpEnabled = getMcpEnabledPreference(phrenPath);
+    const hooksEnabled = getHooksEnabledPreference(phrenPath);
+    console.log(`  ${DIM}mcp${RESET}      ${mcpEnabled ? `${GREEN}on${RESET}` : `${YELLOW}off${RESET}`}`);
+    console.log(`  ${DIM}hooks${RESET}    ${hooksEnabled ? `${GREEN}on${RESET}` : `${YELLOW}off${RESET}`}`);
+    // Hook health: check ~/.claude/settings.json
+    let hooksInstalled = false;
+    let mcpConfigured = false;
+    if (manifest?.installMode === "project-local" && manifest.workspaceRoot) {
+        const workspaceMcp = path.join(manifest.workspaceRoot, ".vscode", "mcp.json");
+        if (fs.existsSync(workspaceMcp)) {
+            try {
+                const parsed = JSON.parse(fs.readFileSync(workspaceMcp, "utf8"));
+                const settings = isRecord(parsed) ? parsed : {};
+                const servers = isRecord(settings.servers) ? settings.servers : undefined;
+                mcpConfigured = Boolean(servers?.phren || servers?.phren);
+            }
+            catch (err) {
+                if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+                    process.stderr.write(`[phren] statusWorkspaceMcp parse: ${err instanceof Error ? err.message : String(err)}\n`);
+            }
+        }
+    }
+    else {
+        const settingsPath = hookConfigPath("claude");
+        if (fs.existsSync(settingsPath)) {
+            try {
+                const parsed = JSON.parse(fs.readFileSync(settingsPath, "utf8"));
+                const settings = isRecord(parsed) ? parsed : {};
+                const mcpServers = isRecord(settings.mcpServers) ? settings.mcpServers : undefined;
+                const hooks = isRecord(settings.hooks) ? settings.hooks : undefined;
+                mcpConfigured = Boolean(mcpServers?.phren || mcpServers?.phren);
+                const hookEvents = ["UserPromptSubmit", "Stop", "SessionStart"];
+                hooksInstalled = hookEvents.every((event) => hasCommandHook(hooks?.[event]));
+            }
+            catch (err) {
+                if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+                    process.stderr.write(`[phren] statusHooks settingsParse: ${err instanceof Error ? err.message : String(err)}\n`);
+            }
+        }
+    }
+    console.log(`  ${DIM}mcp cfg${RESET}  ${check(mcpConfigured)} ${DIM}(${manifest?.installMode === "project-local" ? ".vscode/mcp.json" : "settings.json"})${RESET}`);
+    if (manifest?.installMode === "project-local") {
+        console.log(`  ${DIM}hooks cfg${RESET} ${DIM}n/a in project-local mode${RESET}`);
+    }
+    else {
+        console.log(`  ${DIM}hooks cfg${RESET} ${check(hooksInstalled)} ${DIM}(settings.json)${RESET}`);
+    }
+    // FTS index health
+    let ftsIndexOk = false;
+    let ftsIndexSize = 0;
+    let ftsDocCount = null;
+    try {
+        const cache = findFtsCacheForPath(phrenPath, profile);
+        ftsIndexOk = cache.exists;
+        ftsIndexSize = cache.sizeBytes ?? 0;
+        if (!ftsIndexOk) {
+            const db = await buildIndex(phrenPath, profile || undefined);
+            const healthRow = queryRows(db, "SELECT count(*) FROM docs", []);
+            const count = Number(healthRow?.[0]?.[0] ?? 0);
+            if (Number.isFinite(count) && count >= 0) {
+                ftsIndexOk = true;
+                ftsDocCount = count;
+            }
+        }
+    }
+    catch (err) {
+        if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+            process.stderr.write(`[phren] statusFtsIndex: ${err instanceof Error ? err.message : String(err)}\n`);
+    }
+    const ftsLabel = ftsIndexOk
+        ? `${GREEN}ok${RESET} ${DIM}(${ftsIndexSize > 0 ? `${(ftsIndexSize / 1024).toFixed(0)} KB` : `${ftsDocCount ?? 0} docs`})${RESET}`
+        : `${YELLOW}not built${RESET} ${DIM}(run a search to build)${RESET}`;
+    console.log(`  ${DIM}fts${RESET}      ${ftsLabel}`);
+    try {
+        const { getOllamaUrl, checkOllamaAvailable, checkModelAvailable, getEmbeddingModel } = await import("./shared-ollama.js");
+        const { getEmbeddingCache, formatEmbeddingCoverage } = await import("./shared-embedding-cache.js");
+        const ollamaUrl = getOllamaUrl();
+        if (!ollamaUrl) {
+            console.log(`  ${DIM}semantic${RESET} ${DIM}disabled (optional)${RESET}`);
+        }
+        else {
+            const available = await checkOllamaAvailable();
+            if (!available) {
+                console.log(`  ${DIM}semantic${RESET} ${YELLOW}offline${RESET} ${DIM}(${ollamaUrl})${RESET}`);
+            }
+            else {
+                const modelReady = await checkModelAvailable();
+                const model = getEmbeddingModel();
+                if (!modelReady) {
+                    console.log(`  ${DIM}semantic${RESET} ${YELLOW}model missing${RESET} ${DIM}(${model})${RESET}`);
+                }
+                else {
+                    const cache = getEmbeddingCache(phrenPath);
+                    await cache.load().catch(() => { });
+                    const coverage = cache.coverage(listIndexedDocumentPaths(phrenPath, profile || undefined));
+                    console.log(`  ${DIM}semantic${RESET} ${GREEN}ready${RESET} ${DIM}(${model}; ${formatEmbeddingCoverage(coverage)})${RESET}`);
+                }
+            }
+        }
+    }
+    catch (err) {
+        if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+            process.stderr.write(`[phren] statusSemantic: ${err instanceof Error ? err.message : String(err)}\n`);
+    }
+    // Agent integration status
+    function hasPhrenEntry(filePath) {
+        if (!fs.existsSync(filePath))
+            return false;
+        try {
+            const raw = fs.readFileSync(filePath, "utf8");
+            return raw.includes('"phren"') || raw.includes("'phren'") || raw.includes('"phren"') || raw.includes("'phren'");
+        }
+        catch (err) {
+            if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+                process.stderr.write(`[phren] hasPhrenEntry: ${err instanceof Error ? err.message : String(err)}\n`);
+            return false;
+        }
+    }
+    function agentConfigured(candidates) {
+        return candidates.some(hasPhrenEntry);
+    }
+    const home = homeDir();
+    const agentChecks = manifest?.installMode === "project-local" && manifest.workspaceRoot ? [
+        {
+            name: "VS Code (workspace)",
+            configured: fs.existsSync(path.join(manifest.workspaceRoot, ".vscode", "mcp.json")),
+        },
+    ] : [
+        {
+            name: "Claude Code",
+            configured: agentConfigured([
+                path.join(home, ".claude.json"),
+                path.join(home, ".claude", "settings.json"),
+            ]),
+        },
+        {
+            name: "Cursor",
+            configured: agentConfigured([
+                path.join(home, ".cursor", "mcp.json"),
+                path.join(home, ".config", "Cursor", "User", "mcp.json"),
+                path.join(home, "Library", "Application Support", "Cursor", "User", "mcp.json"),
+            ]),
+        },
+        {
+            name: "Copilot CLI",
+            configured: agentConfigured([
+                path.join(home, ".copilot", "mcp-config.json"),
+                path.join(home, ".config", "github-copilot", "mcp.json"),
+                path.join(home, "Library", "Application Support", "github-copilot", "mcp.json"),
+            ]),
+        },
+        {
+            name: "Codex",
+            configured: agentConfigured([
+                path.join(home, ".codex", "config.json"),
+                path.join(home, ".codex", "mcp.json"),
+                path.join(home, ".codex", "config.toml"),
+            ]),
+        },
+        {
+            name: "Windsurf",
+            configured: agentConfigured([
+                path.join(home, ".windsurf", "mcp.json"),
+                path.join(home, ".config", "Windsurf", "User", "mcp.json"),
+                path.join(home, "Library", "Application Support", "Windsurf", "User", "mcp.json"),
+            ]),
+        },
+    ];
+    const configuredAgents = agentChecks.filter((a) => a.configured).map((a) => a.name);
+    const missingAgents = agentChecks.filter((a) => !a.configured).map((a) => a.name);
+    if (configuredAgents.length > 0) {
+        console.log(`  ${DIM}agents${RESET}   ${GREEN}${configuredAgents.join(", ")}${RESET}`);
+    }
+    if (missingAgents.length > 0) {
+        console.log(`  ${DIM}          Not configured: ${missingAgents.join(", ")} — run phren init to add${RESET}`);
+    }
+    // Stats
+    const projectDirs = getProjectDirs(phrenPath, profile);
+    let totalFindings = 0;
+    let totalTask = 0;
+    let totalQueue = 0;
+    for (const dir of projectDirs) {
+        const projName = path.basename(dir);
+        totalFindings += countBullets(path.join(phrenPath, projName, "FINDINGS.md"));
+        const taskPath = resolveTaskFilePath(phrenPath, projName);
+        if (taskPath)
+            totalTask += countBullets(taskPath);
+        totalQueue += countQueueItems(phrenPath, projName);
+    }
+    console.log(`\n  ${DIM}phren holds${RESET}  ${projectDirs.length} projects, ${totalFindings} fragments, ${totalTask} tasks, ${totalQueue} queued`);
+    const gitTarget = manifest?.installMode === "project-local" && manifest.workspaceRoot ? manifest.workspaceRoot : phrenPath;
+    const isGitRepo = runGit(gitTarget, ["rev-parse", "--is-inside-work-tree"]) === "true";
+    const hasOriginRemote = isGitRepo && Boolean(runGit(gitTarget, ["remote", "get-url", "origin"]));
+    const runtime = readRuntimeHealth(phrenPath);
+    if (manifest?.installMode === "project-local") {
+        console.log(`\n  ${DIM}sync${RESET}     workspace-managed`);
+        console.log(`           auto-save ${runtime.lastAutoSave?.status || "n/a"}`);
+    }
+    else if (isGitRepo && !hasOriginRemote) {
+        console.log(`\n  ${DIM}sync${RESET}     local-only ${DIM}(no git remote)${RESET}`);
+        console.log(`           auto-save ${runtime.lastAutoSave?.status || "n/a"}`);
+        console.log(`           local commits ${runtime.lastSync?.unsyncedCommits ?? 0}`);
+    }
+    else {
+        console.log(`\n  ${DIM}sync${RESET}     auto-save ${runtime.lastAutoSave?.status || "n/a"}`);
+        console.log(`           last pull ${runtime.lastSync?.lastPullStatus || "n/a"}${runtime.lastSync?.lastPullAt ? ` @ ${runtime.lastSync.lastPullAt}` : ""}`);
+        console.log(`           last push ${runtime.lastSync?.lastPushStatus || "n/a"}${runtime.lastSync?.lastPushAt ? ` @ ${runtime.lastSync.lastPushAt}` : ""}`);
+        console.log(`           unsynced commits ${runtime.lastSync?.unsyncedCommits ?? 0}`);
+        if (runtime.lastSync?.lastPushDetail) {
+            console.log(`           push detail ${runtime.lastSync.lastPushDetail}`);
+        }
+    }
+    // Recent changes (git log)
+    if (isGitRepo) {
+        const log = runGit(gitTarget, ["log", "--oneline", "-5", "--no-decorate"]);
+        if (log) {
+            console.log(`\n  ${DIM}recent${RESET}`);
+            for (const line of log.split("\n")) {
+                console.log(`    ${DIM}${line}${RESET}`);
+            }
+        }
+        const dirty = runGit(gitTarget, ["status", "--porcelain"]);
+        if (dirty) {
+            const count = dirty.split("\n").filter(Boolean).length;
+            console.log(`    ${YELLOW}${count} uncommitted change(s)${RESET}`);
+        }
+    }
+    else {
+        console.log(`\n  ${DIM}${gitTarget} is not a git repo${RESET}`);
+    }
+    // Telemetry
+    const telemetry = getTelemetrySummary(phrenPath);
+    const firstLine = telemetry.split("\n")[0];
+    console.log(`\n  ${BOLD}${firstLine}${RESET}`);
+    console.log("");
+}