@phren/cli 0.0.1

package/mcp/dist/capabilities/cli.js

@@ -0,0 +1,61 @@
+export const cliManifest = {
+    surface: "cli",
+    version: "1.31.1",
+    actions: {
+        // Finding management
+        "finding.add": { implemented: true, handler: "cli-actions.ts:handleAddFinding" },
+        "finding.remove": { implemented: true, handler: "cli-namespaces.ts:handleFindingNamespace remove" },
+        "finding.list": { implemented: true, handler: "cli.ts:search (findings visible via search)" },
+        "finding.filter_by_date": { implemented: false, reason: "Search has no date filter flag" },
+        "finding.pin": { implemented: true, handler: "cli-actions.ts:handlePin" },
+        // Task management
+        "task.add": { implemented: true, handler: "cli-namespaces.ts:handleTaskNamespace add" },
+        "task.complete": { implemented: true, handler: "cli-namespaces.ts:handleTaskNamespace complete" },
+        "task.remove": { implemented: false, reason: "No dedicated CLI task remove command" },
+        "task.update": { implemented: true, handler: "cli-namespaces.ts:handleTaskNamespace update" },
+        "task.list": { implemented: true, handler: "cli-actions.ts:handleTasks" },
+        "task.pin": { implemented: false, reason: "Pin task is MCP-only" },
+        "task.github_link": { implemented: false, reason: "GitHub link/promote is MCP-only" },
+        // Hook management
+        "hook.list": { implemented: true, handler: "cli-actions.ts:handleHooks list" },
+        "hook.toggle": { implemented: true, handler: "cli-actions.ts:handleHooks enable/disable" },
+        "hook.toggle_per_project": { implemented: false, reason: "Per-project hook toggle not exposed in CLI" },
+        "hook.custom_crud": { implemented: false, reason: "Custom hooks CRUD not exposed in CLI" },
+        "hook.errors": { implemented: false, reason: "Hook errors not exposed in CLI" },
+        // Search
+        "search.fts": { implemented: true, handler: "cli-actions.ts:handleSearch" },
+        "search.fragment": { implemented: true, handler: "cli-actions.ts:handleFragmentSearch" },
+        "search.related_docs": { implemented: true, handler: "cli-actions.ts:handleRelatedDocs" },
+        "search.history": { implemented: true, handler: "cli-actions.ts:handleSearch --history" },
+        // Graph
+        "graph.read": { implemented: true, handler: "cli-graph.ts:handleGraphRead" },
+        "graph.visualize": { implemented: false, reason: "Graph visualization is VS Code / web only" },
+        "graph.link_findings": { implemented: true, handler: "cli-graph.ts:handleGraphLink" },
+        // Config
+        "config.proactivity": { implemented: true, handler: "cli-config.ts:handleProactivity" },
+        "config.task_mode": { implemented: true, handler: "cli-config.ts:handleConfigTaskMode" },
+        "config.retention": { implemented: true, handler: "cli-config.ts:handleRetentionPolicy" },
+        "config.workflow": { implemented: true, handler: "cli-config.ts:handleWorkflowPolicy" },
+        "config.index": { implemented: true, handler: "cli-config.ts:handleIndexPolicy" },
+        // Health / Sync / Session
+        "health.check": { implemented: true, handler: "cli-actions.ts:handleDoctor" },
+        "health.doctor_fix": { implemented: true, handler: "cli-actions.ts:handleDoctor --fix" },
+        "health.sync": { implemented: true, handler: "hook-stop auto-commit" },
+        "session.start": { implemented: true, handler: "cli-hooks-session.ts (hook)" },
+        "session.end": { implemented: true, handler: "cli-hooks-stop.ts (hook)" },
+        // Skill management
+        "skill.list": { implemented: true, handler: "cli-actions.ts:handleSkillList" },
+        "skill.read": { implemented: true, handler: "cli-actions.ts:handleSkills read" },
+        "skill.enable": { implemented: false, reason: "No CLI command for skill enable/disable" },
+        "skill.write": { implemented: false, reason: "No CLI command for skill write" },
+        // Project management
+        "project.list": { implemented: true, handler: "cli-actions.ts:handleProjects list" },
+        "project.manage": { implemented: true, handler: "cli-actions.ts:handleProjects remove" },
+        "project.summary": { implemented: false, reason: "No CLI command for project summary" },
+        "export.project": { implemented: false, reason: "Export/import not exposed in CLI" },
+        "import.project": { implemented: false, reason: "Export/import not exposed in CLI" },
+        // Profile / Machine
+        "profile.switch": { implemented: false, reason: "No CLI command for profile switch" },
+        "profile.list": { implemented: true, handler: "cli-config.ts:config profiles" },
+    },
+};

package/mcp/dist/capabilities/index.js

@@ -0,0 +1,15 @@
+export { ACTION_KEYS } from "./types.js";
+export { cliManifest } from "./cli.js";
+export { mcpManifest } from "./mcp.js";
+export { vscodeManifest } from "./vscode.js";
+export { webUiManifest } from "./web-ui.js";
+import { cliManifest } from "./cli.js";
+import { mcpManifest } from "./mcp.js";
+import { vscodeManifest } from "./vscode.js";
+import { webUiManifest } from "./web-ui.js";
+export const ALL_MANIFESTS = [
+    cliManifest,
+    mcpManifest,
+    vscodeManifest,
+    webUiManifest,
+];

package/mcp/dist/capabilities/mcp.js

@@ -0,0 +1,61 @@
+export const mcpManifest = {
+    surface: "mcp",
+    version: "1.31.1",
+    actions: {
+        // Finding management
+        "finding.add": { implemented: true, handler: "index.ts:add_finding" },
+        "finding.remove": { implemented: true, handler: "index.ts:remove_finding" },
+        "finding.list": { implemented: true, handler: "index.ts:get_findings" },
+        "finding.filter_by_date": { implemented: false, reason: "get_findings has no date filter parameter" },
+        "finding.pin": { implemented: true, handler: "index.ts:pin_memory" },
+        // Task management
+        "task.add": { implemented: true, handler: "index.ts:add_task" },
+        "task.complete": { implemented: true, handler: "index.ts:complete_task" },
+        "task.remove": { implemented: true, handler: "index.ts:remove_task" },
+        "task.update": { implemented: true, handler: "index.ts:update_task" },
+        "task.list": { implemented: true, handler: "index.ts:get_tasks" },
+        "task.pin": { implemented: true, handler: "index.ts:pin_task" },
+        "task.github_link": { implemented: true, handler: "index.ts:link_task_issue, promote_task_to_issue" },
+        // Hook management
+        "hook.list": { implemented: true, handler: "index.ts:list_hooks" },
+        "hook.toggle": { implemented: true, handler: "index.ts:toggle_hooks" },
+        "hook.toggle_per_project": { implemented: true, handler: "index.ts:toggle_hooks (project param)" },
+        "hook.custom_crud": { implemented: true, handler: "index.ts:add_custom_hook, remove_custom_hook" },
+        "hook.errors": { implemented: true, handler: "index.ts:list_hook_errors" },
+        // Search
+        "search.fts": { implemented: true, handler: "index.ts:search_knowledge" },
+        "search.fragment": { implemented: true, handler: "index.ts:search_fragments" },
+        "search.related_docs": { implemented: true, handler: "index.ts:get_related_docs" },
+        "search.history": { implemented: false, reason: "Search history is CLI-only (search-history.jsonl)" },
+        // Graph
+        "graph.read": { implemented: true, handler: "index.ts:read_graph" },
+        "graph.visualize": { implemented: false, reason: "MCP returns data only; visualization is client-side" },
+        "graph.link_findings": { implemented: true, handler: "index.ts:link_findings" },
+        // Config
+        "config.proactivity": { implemented: false, reason: "No MCP tool for proactivity config" },
+        "config.task_mode": { implemented: false, reason: "No MCP tool for workflow policy" },
+        "config.retention": { implemented: false, reason: "Config tools are CLI-only" },
+        "config.workflow": { implemented: false, reason: "Config tools are CLI-only" },
+        "config.index": { implemented: false, reason: "Config tools are CLI-only" },
+        // Health / Sync / Session
+        "health.check": { implemented: true, handler: "index.ts:health_check" },
+        "health.doctor_fix": { implemented: true, handler: "index.ts:doctor_fix" },
+        "health.sync": { implemented: true, handler: "index.ts:push_changes" },
+        "session.start": { implemented: true, handler: "index.ts:session_start" },
+        "session.end": { implemented: true, handler: "index.ts:session_end" },
+        // Skill management
+        "skill.list": { implemented: true, handler: "index.ts:list_skills" },
+        "skill.read": { implemented: true, handler: "index.ts:read_skill" },
+        "skill.enable": { implemented: true, handler: "index.ts:enable_skill, disable_skill" },
+        "skill.write": { implemented: true, handler: "index.ts:write_skill" },
+        // Project management
+        "project.list": { implemented: true, handler: "index.ts:list_projects" },
+        "project.manage": { implemented: true, handler: "index.ts:manage_project" },
+        "project.summary": { implemented: true, handler: "index.ts:get_project_summary" },
+        "export.project": { implemented: true, handler: "index.ts:export_project" },
+        "import.project": { implemented: true, handler: "index.ts:import_project" },
+        // Profile / Machine
+        "profile.switch": { implemented: false, reason: "No MCP tool for profile switching" },
+        "profile.list": { implemented: false, reason: "No MCP tool for profile listing" },
+    },
+};

package/mcp/dist/capabilities/types.js

@@ -0,0 +1,57 @@
+export const ACTION_KEYS = [
+    // Finding management
+    "finding.add",
+    "finding.remove",
+    "finding.list",
+    "finding.filter_by_date",
+    "finding.pin",
+    // Task management
+    "task.add",
+    "task.complete",
+    "task.remove",
+    "task.update",
+    "task.list",
+    "task.pin",
+    "task.github_link",
+    // Hook management
+    "hook.list",
+    "hook.toggle",
+    "hook.toggle_per_project",
+    "hook.custom_crud",
+    "hook.errors",
+    // Search
+    "search.fts",
+    "search.fragment",
+    "search.related_docs",
+    "search.history",
+    // Graph
+    "graph.read",
+    "graph.visualize",
+    "graph.link_findings",
+    // Config
+    "config.proactivity",
+    "config.task_mode",
+    "config.retention",
+    "config.workflow",
+    "config.index",
+    // Health / Sync / Session
+    "health.check",
+    "health.doctor_fix",
+    "health.sync",
+    "session.start",
+    "session.end",
+    // Skill management
+    "skill.list",
+    "skill.read",
+    "skill.enable",
+    "skill.write",
+    // Project management
+    "project.list",
+    "project.manage",
+    "project.summary",
+    "export.project",
+    "import.project",
+    // Profile / Machine
+    "profile.switch",
+    "profile.list",
+];

package/mcp/dist/capabilities/vscode.js

@@ -0,0 +1,61 @@
+export const vscodeManifest = {
+    surface: "vscode",
+    version: "1.31.1",
+    actions: {
+        // Finding management
+        "finding.add": { implemented: true, handler: "extension.ts:phren.addFinding" },
+        "finding.remove": { implemented: true, handler: "extension.ts:phren.removeFinding" },
+        "finding.list": { implemented: true, handler: "PhrenTreeProvider.ts:findings section" },
+        "finding.filter_by_date": { implemented: true, handler: "extension.ts:phren.filterFindingsByDate" },
+        "finding.pin": { implemented: true, handler: "extension.ts:phren.pinMemory" },
+        // Task management
+        "task.add": { implemented: true, handler: "extension.ts:phren.addTask" },
+        "task.complete": { implemented: true, handler: "extension.ts:phren.completeTask" },
+        "task.remove": { implemented: true, handler: "extension.ts:phren.removeTask" },
+        "task.update": { implemented: false, reason: "No VS Code command for task field updates" },
+        "task.list": { implemented: true, handler: "PhrenTreeProvider.ts:tasks section" },
+        "task.pin": { implemented: false, reason: "No VS Code command for task pinning" },
+        "task.github_link": { implemented: false, reason: "GitHub link/promote is MCP-only" },
+        // Hook management
+        "hook.list": { implemented: true, handler: "extension.ts:phren.hooksStatus" },
+        "hook.toggle": { implemented: true, handler: "extension.ts:phren.toggleHook, phren.toggleHooksCommand" },
+        "hook.toggle_per_project": { implemented: false, reason: "Per-project hook toggle not exposed in VS Code" },
+        "hook.custom_crud": { implemented: false, reason: "Custom hooks CRUD not exposed in VS Code" },
+        "hook.errors": { implemented: false, reason: "Hook errors not exposed in VS Code" },
+        // Search
+        "search.fts": { implemented: true, handler: "searchQuickPick.ts:showSearchQuickPick" },
+        "search.fragment": { implemented: true, handler: "phrenClient.ts:searchFragments" },
+        "search.related_docs": { implemented: true, handler: "phrenClient.ts:getRelatedDocs" },
+        "search.history": { implemented: true, handler: "searchQuickPick.ts:searchHistory (in-memory)" },
+        // Graph
+        "graph.read": { implemented: true, handler: "graphWebview.ts:showGraphWebview" },
+        "graph.visualize": { implemented: true, handler: "graphWebview.ts:showGraphWebview (webview panel)" },
+        "graph.link_findings": { implemented: false, reason: "Link findings is MCP-only" },
+        // Config
+        "config.proactivity": { implemented: false, reason: "Config tools are CLI-only" },
+        "config.task_mode": { implemented: false, reason: "Config tools are CLI-only" },
+        "config.retention": { implemented: false, reason: "Config tools are CLI-only" },
+        "config.workflow": { implemented: false, reason: "Config tools are CLI-only" },
+        "config.index": { implemented: false, reason: "Config tools are CLI-only" },
+        // Health / Sync / Session
+        "health.check": { implemented: true, handler: "extension.ts:phren.doctor" },
+        "health.doctor_fix": { implemented: true, handler: "extension.ts:phren.doctorFix" },
+        "health.sync": { implemented: true, handler: "extension.ts:phren.sync" },
+        "session.start": { implemented: true, handler: "extension.ts:phren.sessionStart" },
+        "session.end": { implemented: true, handler: "extension.ts:phren.sessionEnd" },
+        // Skill management
+        "skill.list": { implemented: true, handler: "PhrenTreeProvider.ts:skills section" },
+        "skill.read": { implemented: true, handler: "skillEditor.ts:showSkillEditor" },
+        "skill.enable": { implemented: true, handler: "extension.ts:phren.toggleSkill" },
+        "skill.write": { implemented: false, reason: "No VS Code command for skill write" },
+        // Project management
+        "project.list": { implemented: true, handler: "PhrenTreeProvider.ts:projects section" },
+        "project.manage": { implemented: true, handler: "extension.ts:phren.manageProject" },
+        "project.summary": { implemented: true, handler: "PhrenTreeProvider.ts:project detail view" },
+        "export.project": { implemented: false, reason: "Export/import not exposed in VS Code" },
+        "import.project": { implemented: false, reason: "Export/import not exposed in VS Code" },
+        // Profile / Machine
+        "profile.switch": { implemented: true, handler: "extension.ts:phren.switchProfile" },
+        "profile.list": { implemented: true, handler: "PhrenTreeProvider.ts:manage section (profiles dir)" },
+    },
+};

package/mcp/dist/capabilities/web-ui.js

@@ -0,0 +1,61 @@
+export const webUiManifest = {
+    surface: "web-ui",
+    version: "1.31.1",
+    actions: {
+        // Finding management
+        "finding.add": { implemented: false, reason: "Web UI is read-only for findings (review queue only)" },
+        "finding.remove": { implemented: false, reason: "Web UI is read-only for findings" },
+        "finding.list": { implemented: true, handler: "memory-ui-server.ts:/api/project-content" },
+        "finding.filter_by_date": { implemented: false, reason: "No date filter in web UI API" },
+        "finding.pin": { implemented: false, reason: "No pin action in web UI" },
+        // Task management
+        "task.add": { implemented: false, reason: "No task creation in web UI" },
+        "task.complete": { implemented: false, reason: "No task completion in web UI" },
+        "task.remove": { implemented: false, reason: "No task deletion in web UI" },
+        "task.update": { implemented: false, reason: "No task update in web UI" },
+        "task.list": { implemented: true, handler: "memory-ui-server.ts:/api/tasks" },
+        "task.pin": { implemented: false, reason: "No task pinning in web UI" },
+        "task.github_link": { implemented: false, reason: "No GitHub link in web UI" },
+        // Hook management
+        "hook.list": { implemented: true, handler: "memory-ui-server.ts:/api/hooks" },
+        "hook.toggle": { implemented: true, handler: "memory-ui-server.ts:/api/hook-toggle" },
+        "hook.toggle_per_project": { implemented: false, reason: "Per-project hook toggle not exposed in web UI" },
+        "hook.custom_crud": { implemented: false, reason: "Custom hooks CRUD not exposed in web UI" },
+        "hook.errors": { implemented: false, reason: "Hook errors not exposed in web UI" },
+        // Search
+        "search.fts": { implemented: true, handler: "memory-ui-server.ts:/api/search" },
+        "search.fragment": { implemented: false, reason: "No fragment search in web UI" },
+        "search.related_docs": { implemented: false, reason: "No related docs in web UI" },
+        "search.history": { implemented: false, reason: "No search history in web UI" },
+        // Graph
+        "graph.read": { implemented: true, handler: "memory-ui-server.ts:/api/graph" },
+        "graph.visualize": { implemented: true, handler: "memory-ui-page.ts:graph tab (Canvas2D + Barnes-Hut engine)" },
+        "graph.link_findings": { implemented: false, reason: "No link findings action in web UI" },
+        // Config
+        "config.proactivity": { implemented: false, reason: "Config is CLI-only" },
+        "config.task_mode": { implemented: true, handler: "memory-ui-server.ts:/api/settings (workflow policy)" },
+        "config.retention": { implemented: false, reason: "Config is CLI-only" },
+        "config.workflow": { implemented: true, handler: "memory-ui-server.ts:/api/settings (workflow policy)" },
+        "config.index": { implemented: false, reason: "Config is CLI-only" },
+        // Health / Sync / Session
+        "health.check": { implemented: true, handler: "memory-ui-server.ts:/api/runtime-health" },
+        "health.doctor_fix": { implemented: false, reason: "Doctor --fix is CLI-only" },
+        "health.sync": { implemented: true, handler: "memory-ui-server.ts:/api/sync" },
+        "session.start": { implemented: false, reason: "Session lifecycle is not web UI driven" },
+        "session.end": { implemented: false, reason: "Session lifecycle is not web UI driven" },
+        // Skill management
+        "skill.list": { implemented: true, handler: "memory-ui-server.ts:/api/skills" },
+        "skill.read": { implemented: true, handler: "memory-ui-server.ts:/api/skill-content" },
+        "skill.enable": { implemented: true, handler: "memory-ui-server.ts:/api/skill-toggle" },
+        "skill.write": { implemented: true, handler: "memory-ui-server.ts:/api/skill-save" },
+        // Project management
+        "project.list": { implemented: true, handler: "memory-ui-server.ts:/api/projects" },
+        "project.manage": { implemented: false, reason: "No archive/unarchive in web UI" },
+        "project.summary": { implemented: true, handler: "memory-ui-server.ts:/api/project-content" },
+        "export.project": { implemented: false, reason: "Export/import not exposed in web UI" },
+        "import.project": { implemented: false, reason: "Export/import not exposed in web UI" },
+        // Profile / Machine
+        "profile.switch": { implemented: false, reason: "No profile switching in web UI" },
+        "profile.list": { implemented: false, reason: "No profile listing in web UI" },
+    },
+};

package/mcp/dist/cli-actions.js

@@ -0,0 +1,302 @@
+import * as fs from "fs";
+import { runtimeFile, getPhrenPath } from "./shared.js";
+import { recordFeedback, flushEntryScores, getWorkflowPolicy, } from "./shared-governance.js";
+import { upsertCanonical } from "./shared-content.js";
+import { errorMessage } from "./utils.js";
+import { addFinding as addFindingCore } from "./core-finding.js";
+import { runDoctor } from "./link.js";
+import { startWebUi } from "./memory-ui.js";
+import { startShell } from "./shell.js";
+import { runPhrenUpdate } from "./update.js";
+import { readRuntimeHealth } from "./data-access.js";
+import { runSearch, runFragmentSearch, parseFragmentSearchArgs, runRelatedDocs, parseRelatedDocsArgs } from "./cli-search.js";
+import { resolveRuntimeProfile } from "./runtime-profile.js";
+export async function handleSearch(opts, profile) {
+    const result = await runSearch(opts, getPhrenPath(), profile);
+    if (result.lines.length > 0) {
+        console.log(result.lines.join("\n"));
+    }
+    if (result.exitCode !== 0)
+        process.exit(result.exitCode);
+}
+export async function handleFragmentSearch(args, profile) {
+    const opts = parseFragmentSearchArgs(args);
+    if (!opts)
+        return;
+    const result = await runFragmentSearch(opts.query, getPhrenPath(), profile, opts);
+    if (result.lines.length > 0) {
+        console.log(result.lines.join("\n"));
+    }
+    if (result.exitCode !== 0)
+        process.exit(result.exitCode);
+}
+export async function handleRelatedDocs(args, profile) {
+    const opts = parseRelatedDocsArgs(args);
+    if (!opts)
+        return;
+    const result = await runRelatedDocs(opts.entity, getPhrenPath(), profile, opts);
+    if (result.lines.length > 0) {
+        console.log(result.lines.join("\n"));
+    }
+    if (result.exitCode !== 0)
+        process.exit(result.exitCode);
+}
+export async function handleAddFinding(project, learning) {
+    if (!project || !learning) {
+        console.error('Usage: phren add-finding <project> "<insight>"');
+        process.exit(1);
+    }
+    try {
+        const result = addFindingCore(getPhrenPath(), project, learning);
+        if (!result.ok) {
+            console.error(result.message);
+            process.exit(1);
+        }
+        console.log(result.message);
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+}
+export async function handlePinCanonical(project, memory) {
+    if (!project || !memory) {
+        console.error('Usage: phren pin <project> "<memory>"');
+        process.exit(1);
+    }
+    const result = upsertCanonical(getPhrenPath(), project, memory);
+    console.log(result.ok ? result.data : result.error);
+}
+export async function handleDoctor(args) {
+    const profile = resolveRuntimeProfile(getPhrenPath());
+    const fix = args.includes("--fix");
+    const checkData = args.includes("--check-data");
+    const agentsOnly = args.includes("--agents");
+    const parityCheck = args.includes("--parity");
+    if (parityCheck) {
+        const { ALL_MANIFESTS, ACTION_KEYS } = await import("./capabilities/index.js");
+        const gaps = [];
+        for (const key of ACTION_KEYS) {
+            for (const manifest of ALL_MANIFESTS) {
+                const entry = manifest.actions[key];
+                if (!entry.implemented) {
+                    gaps.push({ action: key, surface: manifest.surface, reason: entry.reason || "unknown" });
+                }
+            }
+        }
+        const byAction = new Map();
+        for (const gap of gaps) {
+            const arr = byAction.get(gap.action) || [];
+            arr.push({ surface: gap.surface, reason: gap.reason });
+            byAction.set(gap.action, arr);
+        }
+        const total = ACTION_KEYS.length;
+        const implemented = new Map();
+        for (const manifest of ALL_MANIFESTS) {
+            let count = 0;
+            for (const key of ACTION_KEYS) {
+                if (manifest.actions[key].implemented)
+                    count++;
+            }
+            implemented.set(manifest.surface, count);
+        }
+        console.log(`phren doctor --parity: ${total} actions across ${ALL_MANIFESTS.length} surfaces\n`);
+        for (const manifest of ALL_MANIFESTS) {
+            const count = implemented.get(manifest.surface) || 0;
+            console.log(`  ${manifest.surface}: ${count}/${total} implemented (${Math.round(100 * count / total)}%)`);
+        }
+        if (byAction.size > 0) {
+            console.log(`\nGaps (${gaps.length} total):`);
+            for (const [action, entries] of byAction) {
+                const surfaces = entries.map((e) => e.surface).join(", ");
+                console.log(`  ${action}: missing in ${surfaces}`);
+            }
+        }
+        else {
+            console.log("\nNo gaps — full parity across all surfaces.");
+        }
+        process.exit(0);
+    }
+    const result = await runDoctor(getPhrenPath(), fix, checkData);
+    if (agentsOnly) {
+        const agentChecks = result.checks.filter((check) => check.name.includes("cursor") || check.name.includes("copilot") || check.name.includes("codex") || check.name.includes("windsurf"));
+        console.log(`phren doctor --agents: ${agentChecks.every((check) => check.ok) ? "all configured" : "some not configured"}`);
+        for (const check of agentChecks) {
+            console.log(`- ${check.ok ? "ok" : "not configured"} ${check.name}: ${check.detail}`);
+        }
+        if (agentChecks.length === 0) {
+            console.log("No agent integrations detected. Run `phren init` to configure.");
+        }
+        process.exit(agentChecks.every((check) => check.ok) ? 0 : 1);
+    }
+    console.log(`phren doctor: ${result.ok ? "ok" : "issues found"}`);
+    if (result.machine)
+        console.log(`machine: ${result.machine}`);
+    if (result.profile)
+        console.log(`profile: ${result.profile}`);
+    console.log(`tasks: ${getWorkflowPolicy(getPhrenPath()).taskMode} mode`);
+    const renderCheckState = (check) => {
+        if (check.name === "git-remote" &&
+            check.ok &&
+            /no remote configured|local-only/i.test(check.detail)) {
+            return "info";
+        }
+        return check.ok ? "ok" : "fail";
+    };
+    for (const check of result.checks) {
+        console.log(`- ${renderCheckState(check)} ${check.name}: ${check.detail}`);
+    }
+    try {
+        const missFile = runtimeFile(getPhrenPath(), "search-misses.jsonl");
+        if (fs.existsSync(missFile)) {
+            const lines = fs.readFileSync(missFile, "utf8").split("\n").filter(Boolean);
+            if (lines.length > 0) {
+                const tokenCounts = new Map();
+                for (const line of lines) {
+                    try {
+                        const entry = JSON.parse(line);
+                        const tokens = entry.query.toLowerCase().split(/\s+/).filter((token) => token.length > 2);
+                        for (const token of tokens) {
+                            tokenCounts.set(token, (tokenCounts.get(token) ?? 0) + 1);
+                        }
+                    }
+                    catch (err) {
+                        if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+                            process.stderr.write(`[phren] doctor searchMissParse: ${errorMessage(err)}\n`);
+                    }
+                }
+                const topMisses = [...tokenCounts.entries()]
+                    .sort((a, b) => b[1] - a[1])
+                    .slice(0, 10);
+                if (topMisses.length > 0) {
+                    console.log(`\nSearch miss patterns (${lines.length} zero-result queries):`);
+                    for (const [token, count] of topMisses) {
+                        console.log(`  ${token}: ${count} miss(es)`);
+                    }
+                }
+            }
+        }
+    }
+    catch (err) {
+        if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+            process.stderr.write(`[phren] doctor searchMissAnalysis: ${errorMessage(err)}\n`);
+    }
+    try {
+        const { checkOllamaAvailable, checkModelAvailable, getOllamaUrl, getEmbeddingModel } = await import("./shared-ollama.js");
+        const { getEmbeddingCache, formatEmbeddingCoverage } = await import("./shared-embedding-cache.js");
+        const { listIndexedDocumentPaths } = await import("./shared-index.js");
+        const ollamaUrl = getOllamaUrl();
+        if (!ollamaUrl) {
+            console.log("- ok  semantic-search: disabled (optional; enable for fuzzy/paraphrase-heavy retrieval)");
+        }
+        else {
+            const available = await checkOllamaAvailable();
+            if (!available) {
+                console.log(`- warn semantic-search: Ollama not running at ${ollamaUrl} (start Ollama or set PHREN_OLLAMA_URL=off to disable)`);
+            }
+            else {
+                const model = getEmbeddingModel();
+                const modelReady = await checkModelAvailable();
+                if (!modelReady) {
+                    console.log(`- warn semantic-search: model ${model} not pulled (run: ollama pull ${model})`);
+                }
+                else {
+                    const phrenPath = getPhrenPath();
+                    const cache = getEmbeddingCache(phrenPath);
+                    await cache.load().catch(() => { });
+                    const allPaths = listIndexedDocumentPaths(phrenPath, profile || undefined);
+                    const coverage = cache.coverage(allPaths);
+                    console.log(`- ok  semantic-search: ${model} ready, ${formatEmbeddingCoverage(coverage)}`);
+                }
+            }
+        }
+    }
+    catch (err) {
+        if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+            process.stderr.write(`[phren] doctor ollamaStatus: ${errorMessage(err)}\n`);
+    }
+    process.exit(result.ok ? 0 : 1);
+}
+export async function handleStatus() {
+    const phrenPath = getPhrenPath();
+    const profile = resolveRuntimeProfile(phrenPath);
+    const runtime = readRuntimeHealth(phrenPath);
+    console.log("phren status");
+    console.log(`last auto-save: ${runtime.lastAutoSave?.status || "n/a"}${runtime.lastAutoSave?.at ? ` @ ${runtime.lastAutoSave.at}` : ""}`);
+    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}`);
+    try {
+        const { getOllamaUrl, checkOllamaAvailable, checkModelAvailable, getEmbeddingModel } = await import("./shared-ollama.js");
+        const { getEmbeddingCache, formatEmbeddingCoverage } = await import("./shared-embedding-cache.js");
+        const { listIndexedDocumentPaths } = await import("./shared-index.js");
+        const ollamaUrl = getOllamaUrl();
+        if (!ollamaUrl) {
+            console.log("semantic-search: disabled (optional)");
+            return;
+        }
+        const available = await checkOllamaAvailable();
+        if (!available) {
+            console.log(`semantic-search: offline (${ollamaUrl})`);
+            return;
+        }
+        const model = getEmbeddingModel();
+        const modelReady = await checkModelAvailable();
+        if (!modelReady) {
+            console.log(`semantic-search: model missing (${model})`);
+            return;
+        }
+        const cache = getEmbeddingCache(phrenPath);
+        await cache.load().catch(() => { });
+        const coverage = cache.coverage(listIndexedDocumentPaths(phrenPath, profile || undefined));
+        console.log(`semantic-search: ${model} ready, ${formatEmbeddingCoverage(coverage)}`);
+    }
+    catch (err) {
+        if ((process.env.PHREN_DEBUG || process.env.PHREN_DEBUG))
+            process.stderr.write(`[phren] handleStatus semanticSearch: ${errorMessage(err)}\n`);
+    }
+}
+export async function handleQualityFeedback(args) {
+    const key = args.find((arg) => arg.startsWith("--key="))?.slice("--key=".length);
+    const feedback = args.find((arg) => arg.startsWith("--type="))?.slice("--type=".length);
+    if (!key || !feedback || !["helpful", "reprompt", "regression"].includes(feedback)) {
+        console.error("Usage: phren quality-feedback --key=<entry-key> --type=helpful|reprompt|regression");
+        process.exit(1);
+    }
+    recordFeedback(getPhrenPath(), key, feedback);
+    flushEntryScores(getPhrenPath());
+    console.log(`Recorded feedback: ${feedback} for ${key}`);
+}
+export async function handleMemoryUi(args) {
+    const portArg = args.find((arg) => arg.startsWith("--port="));
+    const noOpen = args.includes("--no-open");
+    const port = portArg ? Number.parseInt(portArg.slice("--port=".length), 10) : 3499;
+    const safePort = Number.isNaN(port) ? 3499 : port;
+    await startWebUi(getPhrenPath(), safePort, resolveRuntimeProfile(getPhrenPath()), {
+        autoOpen: !noOpen,
+        allowPortFallback: !portArg,
+    });
+}
+export async function handleShell(args, profile) {
+    if (args.includes("--help") || args.includes("-h")) {
+        console.log("Usage: phren shell");
+        console.log("Interactive shell with views for Projects, Task, Findings, Review Queue, Skills, Hooks, Machines/Profiles, and Health.");
+        return;
+    }
+    await startShell(getPhrenPath(), profile);
+}
+export async function handleUpdate(args) {
+    if (args.includes("--help") || args.includes("-h")) {
+        console.log("Usage: phren update [--refresh-starter]");
+        console.log("Updates phren to the latest version (local git clone when available, otherwise npm global package).");
+        console.log("Pass --refresh-starter to refresh global starter assets in the same flow.");
+        return;
+    }
+    const result = await runPhrenUpdate({ refreshStarter: args.includes("--refresh-starter") });
+    console.log(result.message);
+    if (!result.ok) {
+        process.exitCode = 1;
+    }
+}