youmd 0.6.19 → 0.6.26

package/dist/commands/chat.js

@@ -44,10 +44,12 @@ const path = __importStar(require("path"));
 const chalk_1 = __importDefault(require("chalk"));
 const config_1 = require("../lib/config");
 const project_1 = require("../lib/project");
+const projectContext_1 = require("../lib/projectContext");
 const compiler_1 = require("../lib/compiler");
 const api_1 = require("../lib/api");
 const skills_1 = require("../lib/skills");
 const render_1 = require("../lib/render");
+const stream_1 = require("../lib/stream");
 const onboarding_1 = require("../lib/onboarding");
 const ascii_1 = require("../lib/ascii");
 const update_1 = require("../lib/update");
@@ -55,122 +57,25 @@ const update_1 = require("../lib/update");
 const config_2 = require("../lib/config");
 const CONVEX_SITE_URL = (0, config_2.getConvexSiteUrl)();
 const STREAM_URL = `${CONVEX_SITE_URL}/api/v1/chat/stream`;
-const CURRENT_VERSION = "0.6.19";
-function delay(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
+const CURRENT_VERSION = "0.6.23";
 // ─── Streaming LLM client ─────────────────────────────────────────────
-async function streamLLM(_apiKey, messages, onToken) {
-    const res = await fetch(STREAM_URL, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ messages }),
-        signal: AbortSignal.timeout(120000),
-    });
-    if (!res.ok) {
-        const body = await res.text();
-        throw new Error(`Stream error (${res.status}): ${body}`);
-    }
-    if (!res.body) {
-        throw new Error("No response body from stream endpoint");
-    }
-    const reader = res.body.getReader();
-    const decoder = new TextDecoder();
-    let fullText = "";
-    let buffer = "";
-    while (true) {
-        const { done, value } = await reader.read();
-        if (done)
-            break;
-        buffer += decoder.decode(value, { stream: true });
-        // Process complete SSE lines
-        const lines = buffer.split("\n");
-        // Keep the last potentially incomplete line in the buffer
-        buffer = lines.pop() || "";
-        for (const line of lines) {
-            const trimmed = line.trim();
-            if (!trimmed)
-                continue;
-            if (trimmed.startsWith("data: ")) {
-                const data = trimmed.slice(6);
-                if (data === "[DONE]") {
-                    continue;
-                }
-                try {
-                    const parsed = JSON.parse(data);
-                    if (parsed.text) {
-                        fullText += parsed.text;
-                        onToken(parsed.text);
-                    }
-                }
-                catch {
-                    // Skip malformed JSON chunks
-                }
-            }
-        }
-    }
-    // Process any remaining buffer
-    if (buffer.trim()) {
-        const trimmed = buffer.trim();
-        if (trimmed.startsWith("data: ")) {
-            const data = trimmed.slice(6);
-            if (data !== "[DONE]") {
-                try {
-                    const parsed = JSON.parse(data);
-                    if (parsed.text) {
-                        fullText += parsed.text;
-                        onToken(parsed.text);
-                    }
-                }
-                catch {
-                    // Skip
-                }
-            }
-        }
-    }
-    return fullText;
-}
 /**
- * Call LLM with streaming, falling back to blocking callLLM on failure.
- * Returns the full response text.
+ * Call LLM with streaming (shared helper: spinner until first token, then
+ * live tokens with ```json directive blocks filtered from the display),
+ * falling back to blocking callLLM on failure.
+ *
+ * Returns the full RAW response text — directive blocks intact — so the
+ * post-stream parsers (parseUpdatesFromResponse, parseMemorySaves,
+ * parsePrivateUpdates, parseProjectUpdates) keep working unchanged.
  */
 async function callLLMWithStreaming(apiKey, messages, spinnerLabel) {
-    const thinkSpinner = new render_1.BrailleSpinner(spinnerLabel);
-    thinkSpinner.start();
-    try {
-        let firstToken = true;
-        const response = await streamLLM(apiKey, messages, (token) => {
-            if (firstToken) {
-                // Clear the spinner line before writing streamed text
-                thinkSpinner.stop();
-                process.stdout.write("  ");
-                firstToken = false;
-            }
-            process.stdout.write(token);
-        });
-        if (!firstToken) {
-            // We streamed something -- add trailing newline
-            process.stdout.write("\n");
-        }
-        else {
-            // No tokens received -- clear spinner
-            thinkSpinner.stop();
-        }
-        return { text: response, streamed: !firstToken };
-    }
-    catch {
-        // Streaming failed -- fall back to blocking call
-        thinkSpinner.update("streaming unavailable, waiting for response");
-        try {
-            const response = await (0, onboarding_1.callLLM)(apiKey, messages);
-            thinkSpinner.stop();
-            return { text: response, streamed: false };
-        }
-        catch (err) {
-            thinkSpinner.fail(err instanceof Error ? err.message : "failed");
-            throw err;
-        }
-    }
+    return (0, stream_1.streamAssistantTurn)({
+        streamUrl: STREAM_URL,
+        messages,
+        spinnerLabel,
+        timeoutMs: 120000,
+        fallback: () => (0, onboarding_1.callLLM)(apiKey, messages),
+    });
 }
 function detectSourcesInMessage(text) {
     const sources = [];
@@ -210,7 +115,7 @@ function detectSourcesInMessage(text) {
     }
     const bareDomainRegex = /(?<![/\w])([a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?\.(?:com|co|io|ai|dev|org|net|app|xyz|me)(?:\/[^\s<>"']*)?)/gi;
     while ((match = bareDomainRegex.exec(text)) !== null) {
-        let domain = match[1].replace(/[.,;:)\]]+$/, "");
+        const domain = match[1].replace(/[.,;:)\]]+$/, "");
         if (domain.includes("x.com") || domain.includes("github.com") || domain.includes("linkedin.com"))
             continue;
         const url = `https://${domain}`;
@@ -541,7 +446,7 @@ function loadCurrentBundle(bundleDir) {
         { dir: "profile", label: "Profile" },
         { dir: "preferences", label: "Preferences" },
     ];
-    for (const { dir, label } of dirs) {
+    for (const { dir } of dirs) {
         const dirPath = path.join(bundleDir, dir);
         if (!fs.existsSync(dirPath))
             continue;
@@ -605,8 +510,8 @@ function showStatus(bundleDir) {
     console.log(chalk_1.default.dim("  authenticated: " + ((0, config_1.isAuthenticated)() ? "yes" : "no")));
     console.log("");
 }
-function showLinkInfo(bundleDir) {
-    // Try to read username from the about.md or config
+function showLinkInfo() {
+    // Try to read username from the config
     const config = (0, config_1.readGlobalConfig)();
     const username = config.username || "your-username";
     console.log("");
@@ -881,9 +786,6 @@ function readDisplayName(bundleDir) {
     }
     return (0, config_1.readGlobalConfig)().username || "friend";
 }
-function getRecentProjectNames(limit = 3) {
-    return (0, project_1.getRecentProjectInsights)(process.cwd(), limit).map((item) => item.name);
-}
 async function printUpdateHint() {
     const latest = await (0, update_1.checkForCliUpdate)(CURRENT_VERSION);
     if (!latest)
@@ -969,6 +871,34 @@ function collectHomeAgentSignals() {
     }
     return findings;
 }
+function scoreProjectActionItem(item) {
+    const lower = item.toLowerCase();
+    let score = 0;
+    if (lower.includes("trusted publishing") || (lower.includes("publish") && lower.includes("blocked")))
+        score += 80;
+    if (lower.includes("configure") || lower.includes("unblock") || lower.includes("blocker"))
+        score += 40;
+    if (lower.includes("publish") || lower.includes("npm"))
+        score += 25;
+    if (lower.includes("verify") || lower.includes("test") || lower.includes("qa"))
+        score += 15;
+    if (lower.includes("build") || lower.includes("proactive") || lower.includes("first-run"))
+        score += 10;
+    return score;
+}
+function rankProjectActionItems(items) {
+    return items
+        .map((item, index) => ({ item, index, score: scoreProjectActionItem(item) }))
+        .sort((a, b) => b.score - a.score || a.index - b.index)
+        .map((entry) => entry.item);
+}
+function shortenActionItem(item, maxChars = 240) {
+    if (item.length <= maxChars)
+        return item;
+    const boundary = item.lastIndexOf(" ", maxChars - 1);
+    const end = boundary > 90 ? boundary : maxChars - 1;
+    return `${item.slice(0, end).trim()}...`;
+}
 async function runYouLaunchInvestigation(bundleDir, projectCtx, recentProjects) {
     const labels = [
         "sipping bitbucks frappaccino while i look around",
@@ -988,7 +918,6 @@ async function runYouLaunchInvestigation(bundleDir, projectCtx, recentProjects)
     }, 1100);
     spinner.start();
     try {
-        await delay(600);
         try {
             const hasPreferences = fs.existsSync(path.join(bundleDir, "preferences", "agent.md"));
             const hasDirectives = fs.existsSync(path.join(bundleDir, "directives", "agent.md"));
@@ -1002,8 +931,6 @@ async function runYouLaunchInvestigation(bundleDir, projectCtx, recentProjects)
         catch {
             // keep scanning other surfaces
         }
-        const homeSignals = collectHomeAgentSignals();
-        findings.push(...homeSignals.slice(0, 3));
         if (projectCtx) {
             try {
                 const hasAgents = fs.existsSync(path.join(projectCtx.root, "AGENTS.md"));
@@ -1025,18 +952,30 @@ async function runYouLaunchInvestigation(bundleDir, projectCtx, recentProjects)
                 else {
                     findings.push(`${projectCtx.name} still wants a real project-context spine.`);
                 }
+                const actionItems = extractProjectActionItems(projectCtx.root);
+                strongestProject = {
+                    name: projectCtx.name,
+                    slug: projectCtx.name,
+                    projectDir: projectCtx.root,
+                    updatedAt: Date.now(),
+                    signals: (0, project_1.getProjectMarkerSignals)(projectCtx.root),
+                    summary: `${projectCtx.name} is the current working repo.`,
+                    suggestedCommand: `cd ${projectCtx.root} && you`,
+                };
                 if (repoNeedsBootstrap(projectCtx.root)) {
                     strongestMove = `${projectCtx.name} still wants cleaner agent wiring and project-context scaffolding.`;
                     strongestCommand = "youmd skill init-project";
-                    strongestProject = {
-                        name: projectCtx.name,
-                        slug: projectCtx.name,
-                        projectDir: projectCtx.root,
-                        updatedAt: Date.now(),
-                        signals: ["still wants cleaner agent wiring and project-context scaffolding"],
-                        summary: `${projectCtx.name} still wants cleaner agent wiring and project-context scaffolding.`,
-                        suggestedCommand: "youmd skill init-project",
-                    };
+                    strongestProject.signals = ["still wants cleaner agent wiring and project-context scaffolding"];
+                    strongestProject.summary = `${projectCtx.name} still wants cleaner agent wiring and project-context scaffolding.`;
+                    strongestProject.suggestedCommand = "youmd skill init-project";
+                }
+                else if (actionItems.length > 0) {
+                    strongestMove = actionItems[0];
+                    strongestProject.signals = actionItems.slice(0, 3);
+                    strongestProject.summary = actionItems[0];
+                }
+                else {
+                    strongestMove = `read ${projectCtx.name}'s project-context and pick the next concrete release-quality fix from actual repo state.`;
                 }
             }
             catch {
@@ -1064,7 +1003,8 @@ async function runYouLaunchInvestigation(bundleDir, projectCtx, recentProjects)
         else {
             findings.push("i've got your home bundle loaded, even though we're not inside a project yet.");
         }
-        await delay(900);
+        const homeSignals = collectHomeAgentSignals();
+        findings.push(...homeSignals.slice(0, 2));
         spinner.stop("looked through local context");
         return {
             findings: findings.slice(0, 3),
@@ -1155,6 +1095,9 @@ function buildYouLaunchIntro(projectCtx, bundleDir, investigation) {
         || (projectCtx && repoNeedsBootstrap(projectCtx.root)
             ? `${projectCtx.name} still wants cleaner agent wiring and project-context scaffolding.`
             : null)
+        || (projectCtx
+            ? `read ${projectCtx.name}'s project-context and pick the next concrete release-quality fix from actual repo state.`
+            : null)
         || (0, project_1.getTopProjectOpportunity)(recentInsights)?.summary
         || null;
     if (strongestMove) {
@@ -1181,6 +1124,19 @@ function isStartThereIntent(input) {
         "start",
     ].includes(lower);
 }
+function isContinueNextMoveIntent(input) {
+    const lower = input.toLowerCase().trim().replace(/[.!?]+$/, "");
+    return [
+        "continue",
+        "keep going",
+        "more",
+        "next",
+        "what next",
+        "what should i do next",
+        "next strongest move",
+        "do the next strongest move",
+    ].includes(lower);
+}
 function isLocalRecentProjectsIntent(input) {
     const lower = input.toLowerCase();
     const mentionsLocalWork = lower.includes("local director") ||
@@ -1330,8 +1286,441 @@ function formatProjectBootstrapToolResult(project, result) {
         `recommended_next_move: read ${project.name}'s project-context and turn the rough docs into a sharper current-state + TODO pass.`,
     ].join("\n");
 }
+function isLocalToolLoopCandidate(input) {
+    if (isStartThereIntent(input) || isContinueNextMoveIntent(input) || isLocalRecentProjectsIntent(input))
+        return true;
+    const lower = input.toLowerCase();
+    return [
+        "local",
+        "workspace",
+        "workspaces",
+        "filesystem",
+        "file system",
+        "recent projects",
+        "recent work",
+        "working on lately",
+        "project-context",
+        "project context",
+        "agent entrypoint",
+        "agent instructions",
+        "scaffold",
+        "bootstrap",
+        "start there",
+        "sync identity",
+        "sync my identity",
+        "publish identity",
+        "publish my identity",
+        "push my identity",
+        "what next",
+        "next strongest move",
+    ].some((phrase) => lower.includes(phrase));
+}
+function userAskedForMutation(input) {
+    const lower = input.toLowerCase();
+    return [
+        "start there",
+        "do it",
+        "go ahead",
+        "scaffold",
+        "bootstrap",
+        "create",
+        "write",
+        "update",
+        "fix",
+        "tighten",
+        "sync",
+        "publish",
+        "push",
+        "upload",
+    ].some((phrase) => lower.includes(phrase));
+}
+function safeJsonObject(text) {
+    const trimmed = text.trim();
+    const fenced = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/i);
+    const candidate = fenced?.[1]?.trim() || trimmed.match(/\{[\s\S]*\}/)?.[0];
+    if (!candidate)
+        return null;
+    try {
+        const parsed = JSON.parse(candidate);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeLocalHostToolCall(value) {
+    if (!value)
+        return null;
+    const tool = value.tool;
+    if (tool !== "discover_projects" &&
+        tool !== "read_project_context" &&
+        tool !== "write_project_context" &&
+        tool !== "sync_identity" &&
+        tool !== "respond") {
+        return null;
+    }
+    const mode = value.mode === "publish" || value.mode === "bootstrap" || value.mode === "status"
+        ? value.mode
+        : undefined;
+    return {
+        tool,
+        project: typeof value.project === "string" ? value.project : undefined,
+        mode,
+        reason: typeof value.reason === "string" ? value.reason : undefined,
+    };
+}
+function inferLocalHostToolCall(input, launchInvestigation) {
+    const lower = input.toLowerCase();
+    if (isStartThereIntent(input) || isContinueNextMoveIntent(input)) {
+        const project = resolveProjectForTool(launchInvestigation.strongestProject?.name, launchInvestigation);
+        if (project && repoNeedsBootstrap(project.projectDir)) {
+            return { tool: "write_project_context", project: project.name, mode: "bootstrap" };
+        }
+        return { tool: "read_project_context", project: project?.name || launchInvestigation.strongestProject?.name };
+    }
+    if (lower.includes("sync") || lower.includes("publish") || lower.includes("push my identity")) {
+        return { tool: "sync_identity", mode: lower.includes("publish") || lower.includes("push") || lower.includes("sync") ? "publish" : "status" };
+    }
+    if (lower.includes("read") || lower.includes("show") || lower.includes("inspect") || lower.includes("context")) {
+        return { tool: "read_project_context", project: launchInvestigation.strongestProject?.name };
+    }
+    if (lower.includes("scaffold") || lower.includes("bootstrap") || lower.includes("create") || lower.includes("write") || lower.includes("update")) {
+        return { tool: "write_project_context", project: launchInvestigation.strongestProject?.name, mode: "bootstrap" };
+    }
+    return { tool: "discover_projects" };
+}
+function collectKnownProjects(launchInvestigation) {
+    const projects = [
+        launchInvestigation.strongestProject,
+        ...scanRecentWorkspaceProjects(12),
+        ...(0, project_1.getRecentProjectInsights)(process.cwd(), 12),
+    ].filter((item) => !!item);
+    const seen = new Set();
+    return projects.filter((project) => {
+        const key = fs.existsSync(project.projectDir)
+            ? fs.realpathSync.native(project.projectDir)
+            : path.resolve(project.projectDir);
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+function resolveProjectForTool(projectRef, launchInvestigation) {
+    const projects = collectKnownProjects(launchInvestigation);
+    if (!projectRef && launchInvestigation.strongestProject)
+        return launchInvestigation.strongestProject;
+    if (!projectRef)
+        return projects[0] || null;
+    const normalized = projectRef.toLowerCase().trim();
+    const byPath = projects.find((project) => path.resolve(project.projectDir) === path.resolve(projectRef));
+    if (byPath)
+        return byPath;
+    return projects.find((project) => project.name.toLowerCase() === normalized ||
+        project.slug.toLowerCase() === normalized ||
+        project.projectDir.toLowerCase().includes(normalized)) || null;
+}
+function readSnippet(filePath, maxChars = 1800) {
+    if (!fs.existsSync(filePath))
+        return null;
+    try {
+        const content = fs.readFileSync(filePath, "utf-8").trim();
+        if (!content)
+            return null;
+        return content.length > maxChars ? `${content.slice(0, maxChars)}\n...` : content;
+    }
+    catch {
+        return null;
+    }
+}
+function extractProjectActionItems(projectDir, maxItems = 5) {
+    // Read paths come from the single project-context engine: repo
+    // project-context/, the generated .you/ layer, then the global overlay.
+    const files = (0, projectContext_1.projectContextReadPaths)(projectDir, [
+        "TODO.md",
+        "CURRENT_STATE.md",
+        "feature-requests-active.md",
+    ]);
+    const seen = new Set();
+    const items = [];
+    for (const { path: fullPath } of files) {
+        const content = readSnippet(fullPath, 12000);
+        if (!content)
+            continue;
+        for (const rawLine of content.split("\n")) {
+            const line = rawLine.trim();
+            if (!line)
+                continue;
+            const openTask = line.match(/^[-*]\s+\[[\s?~-]\]\s+(.+)$/);
+            const statusTask = line.match(/^[-*]\s+(?:TODO|P0|P1|BLOCKED|OPEN|NEXT|IN PROGRESS|ACTIVE)[:\s-]+(.+)$/i);
+            const headingTask = line.match(/^#{2,4}\s+(?:P0|P1|Next|Open|Active|Blocked|Known issue|Current focus)[:\s-]+(.+)$/i);
+            const candidate = (openTask?.[1] || statusTask?.[1] || headingTask?.[1] || "")
+                .replace(/\s+/g, " ")
+                .replace(/\s+#.*$/, "")
+                .trim();
+            if (!candidate || candidate.length < 8)
+                continue;
+            const normalized = candidate.toLowerCase();
+            if (seen.has(normalized))
+                continue;
+            seen.add(normalized);
+            items.push(shortenActionItem(candidate));
+        }
+    }
+    return rankProjectActionItems(items).slice(0, maxItems);
+}
+function formatProjectReadToolResult(project) {
+    const entrypointFiles = [
+        "AGENTS.md",
+        "CLAUDE.md",
+        "package.json",
+        "pyproject.toml",
+        "Cargo.toml",
+        "go.mod",
+    ].map((relativePath) => ({
+        label: relativePath,
+        path: path.join(project.projectDir, relativePath),
+    }));
+    // Context reads route through the single project-context engine (repo
+    // project-context/, .you/ layer, then the global overlay union).
+    const files = [
+        ...entrypointFiles,
+        ...(0, projectContext_1.projectContextReadPaths)(project.projectDir, [
+            "CURRENT_STATE.md",
+            "TODO.md",
+            "PRD.md",
+            "ARCHITECTURE.md",
+        ]),
+    ];
+    const snippets = files
+        .map(({ label, path: fullPath }) => {
+        const snippet = readSnippet(fullPath);
+        return snippet ? `file: ${label}\n${snippet}` : null;
+    })
+        .filter((item) => !!item)
+        .slice(0, 5);
+    const managedContext = (0, project_1.readProjectContext)(project.projectDir);
+    const actionItems = extractProjectActionItems(project.projectDir);
+    const recommendedMove = actionItems.length > 0
+        ? actionItems[0]
+        : `tighten ${project.name}'s current-state and TODO docs from actual repo context.`;
+    return [
+        "tool: read_project_context",
+        "status: ok",
+        `project: ${project.name}`,
+        `project_dir: ${project.projectDir}`,
+        `markers: ${(0, project_1.getProjectMarkerSignals)(project.projectDir).join(", ") || "none"}`,
+        managedContext ? `managed_project_context: ${managedContext.meta.name}` : "managed_project_context: none",
+        actionItems.length > 0 ? `action_items: ${actionItems.join(" | ")}` : "action_items: none found in TODO/current-state files",
+        "",
+        snippets.length > 0 ? snippets.join("\n\n---\n\n") : "no readable project-context or agent entrypoint files found yet.",
+        "",
+        `recommended_next_move: ${recommendedMove}`,
+    ].join("\n");
+}
+async function formatIdentitySyncToolResult(bundleDir, publish) {
+    const result = (0, compiler_1.compileBundle)(bundleDir);
+    (0, compiler_1.writeBundle)(bundleDir, result);
+    const lines = [
+        "tool: sync_identity",
+        "status: ok",
+        `bundle_dir: ${bundleDir}`,
+        `compiled_version: ${result.stats.version}`,
+        `sections: ${result.stats.filledSections}/${result.stats.totalSections}`,
+    ];
+    if (!publish) {
+        lines.push("remote_sync: not requested; local bundle compiled only.");
+        lines.push("recommended_next_move: publish if you want this local identity bundle pushed to you.md.");
+        return lines.join("\n");
+    }
+    if (!(0, config_1.isAuthenticated)()) {
+        return [
+            ...lines,
+            "remote_sync: blocked; not authenticated.",
+            "recommended_next_move: run youmd login, then ask me to sync identity again.",
+        ].join("\n");
+    }
+    const youJson = JSON.parse(fs.readFileSync(path.join(bundleDir, "you.json"), "utf-8"));
+    const youMd = fs.readFileSync(path.join(bundleDir, "you.md"), "utf-8");
+    const manifest = JSON.parse(fs.readFileSync(path.join(bundleDir, "manifest.json"), "utf-8"));
+    const uploadRes = await (0, api_1.uploadBundle)({ manifest, youJson, youMd });
+    if (!uploadRes.ok) {
+        return [
+            ...lines,
+            `remote_sync: upload failed with status ${uploadRes.status}.`,
+            "recommended_next_move: inspect auth/API state before retrying identity sync.",
+        ].join("\n");
+    }
+    const publishRes = await (0, api_1.publishLatest)();
+    if (!publishRes.ok) {
+        return [
+            ...lines,
+            `remote_sync: publish failed with status ${publishRes.status}.`,
+            "recommended_next_move: inspect publish API state before retrying identity sync.",
+        ].join("\n");
+    }
+    lines.push(`remote_sync: published v${publishRes.data.version} as ${publishRes.data.username}.`);
+    lines.push(`url: ${publishRes.data.url || `https://you.md/${publishRes.data.username}`}`);
+    lines.push("recommended_next_move: test the updated identity from another agent surface.");
+    return lines.join("\n");
+}
+async function chooseLocalHostTool(args) {
+    if (isStartThereIntent(args.userInput) || isContinueNextMoveIntent(args.userInput)) {
+        return inferLocalHostToolCall(args.userInput, args.launchInvestigation);
+    }
+    const projects = collectKnownProjects(args.launchInvestigation)
+        .slice(0, 8)
+        .map((project) => `${project.name} | ${project.projectDir} | ${project.signals.slice(0, 4).join(", ")}`)
+        .join("\n");
+    const prompt = [
+        "You are the local host tool router for the you.md CLI. Return ONLY compact JSON. No prose.",
+        "Available tools:",
+        "- discover_projects: scan local filesystem markers for recent project work.",
+        "- read_project_context: read AGENTS/CLAUDE/package/project-context files for a project.",
+        "- write_project_context: bootstrap/tighten project context files for a project. Use only when the user asks to start, scaffold, update, write, fix, or tighten.",
+        "- sync_identity: compile identity locally; use mode publish only when the user asks to sync/publish/push identity.",
+        "- respond: no local tool needed.",
+        "",
+        "JSON shape: {\"tool\":\"discover_projects|read_project_context|write_project_context|sync_identity|respond\",\"project\":\"optional project name/path\",\"mode\":\"status|publish|bootstrap\",\"reason\":\"short\"}",
+        "",
+        "Known projects:",
+        projects || "none yet",
+        "",
+        `User request: ${args.userInput}`,
+    ].join("\n");
+    try {
+        const raw = await (0, onboarding_1.callLLM)(args.apiKey, [
+            { role: "system", content: "Return only valid JSON for local tool routing." },
+            { role: "user", content: prompt },
+        ]);
+        return normalizeLocalHostToolCall(safeJsonObject(raw)) || inferLocalHostToolCall(args.userInput, args.launchInvestigation);
+    }
+    catch {
+        return inferLocalHostToolCall(args.userInput, args.launchInvestigation);
+    }
+}
+async function executeLocalHostTool(toolCall, args) {
+    if (toolCall.tool === "discover_projects") {
+        const insights = scanRecentWorkspaceProjects(10);
+        args.launchInvestigation.strongestProject = insights[0] || args.launchInvestigation.strongestProject;
+        args.launchInvestigation.strongestMove = insights[0]?.summary || args.launchInvestigation.strongestMove;
+        return formatLocalRecentProjectsToolResult(insights);
+    }
+    if (toolCall.tool === "read_project_context") {
+        const project = resolveProjectForTool(toolCall.project, args.launchInvestigation);
+        if (!project) {
+            return "tool: read_project_context\nstatus: blocked\nresult: no real local project target is known yet.\nrecommended_next_move: run discover_projects first.";
+        }
+        args.launchInvestigation.strongestProject = project;
+        return formatProjectReadToolResult(project);
+    }
+    if (toolCall.tool === "write_project_context") {
+        const project = resolveProjectForTool(toolCall.project, args.launchInvestigation);
+        if (!project) {
+            return "tool: write_project_context\nstatus: blocked\nresult: no real local project target is known yet.\nrecommended_next_move: run discover_projects first.";
+        }
+        if (!userAskedForMutation(args.userInput)) {
+            return [
+                "tool: write_project_context",
+                "status: blocked",
+                `project: ${project.name}`,
+                "result: user did not explicitly ask for a filesystem mutation.",
+                `recommended_next_move: say "start there" to bootstrap ${project.name}.`,
+            ].join("\n");
+        }
+        const previousCwd = process.cwd();
+        let result;
+        try {
+            process.chdir(project.projectDir);
+            result = (0, skills_1.initProject)({ mode: "additive" });
+        }
+        finally {
+            process.chdir(previousCwd);
+        }
+        args.launchInvestigation.strongestProject = project;
+        return formatProjectBootstrapToolResult(project, result);
+    }
+    if (toolCall.tool === "sync_identity") {
+        const publish = toolCall.mode === "publish" && userAskedForMutation(args.userInput);
+        return await formatIdentitySyncToolResult(args.bundleDir, publish);
+    }
+    return "tool: respond\nstatus: skipped\nresult: no local host tool needed.";
+}
 async function handleLocalChatIntent(args) {
-    const runToolResultThroughModel = async (toolResult, spinnerLabel) => {
+    const summarizeLocalToolResult = (toolResult) => {
+        const get = (key) => {
+            const match = toolResult.match(new RegExp(`^${key}:\\s*(.+)$`, "m"));
+            return match?.[1]?.trim() || null;
+        };
+        const tool = get("tool") || "local_tool";
+        const status = get("status") || "done";
+        const project = get("project");
+        const projectDir = get("project_dir") || get("recommended_next_project_dir");
+        const recommended = get("recommended_next_move");
+        const markers = get("markers");
+        const changed = get("changed");
+        const filesRead = Array.from(toolResult.matchAll(/^file:\s*(.+)$/gm))
+            .map((match) => match[1].trim())
+            .slice(0, 5);
+        const actionItems = get("action_items");
+        const displayedActionItems = actionItems
+            ?.split(" | ")
+            .slice(0, 3)
+            .join(" | ");
+        if (status === "blocked") {
+            const result = get("result") || "local tool blocked";
+            return [
+                result,
+                "",
+                `next strongest move: ${recommended || "run a read-only local scan before attempting a write."}`,
+            ].join("\n");
+        }
+        if (tool === "read_project_context") {
+            const lines = [
+                project ? `read ${project}.` : "read the local project.",
+                projectDir ? `path: ${projectDir}` : null,
+                markers ? `markers: ${markers}` : null,
+                filesRead.length > 0 ? `files read: ${filesRead.join(", ")}` : null,
+                displayedActionItems && displayedActionItems !== "none found in TODO/current-state files" ? `found: ${displayedActionItems}` : null,
+                "",
+                `next strongest move: ${recommended || "tighten the current-state and TODO docs from the actual repo context."}`,
+            ].filter((line) => !!line);
+            return lines.join("\n");
+        }
+        if (tool === "project_bootstrap") {
+            return [
+                project ? `bootstrapped ${project}.` : "bootstrapped the project context.",
+                changed || "changed: checked existing wiring.",
+                "",
+                `next strongest move: ${recommended || "read the project-context files and sharpen the current-state pass."}`,
+            ].join("\n");
+        }
+        if (tool === "workspace_recent_projects") {
+            return [
+                "scanned local workspace projects.",
+                project ? `strongest target: ${project}` : get("recommended_next_project") ? `strongest target: ${get("recommended_next_project")}` : null,
+                projectDir ? `path: ${projectDir}` : null,
+                "",
+                `next strongest move: ${recommended || "say \"start there\" to read the strongest local project from actual files."}`,
+            ].filter((line) => !!line).join("\n");
+        }
+        if (tool === "sync_identity") {
+            return [
+                "synced local identity context.",
+                get("remote_sync") || "remote_sync: local compile only.",
+                "",
+                `next strongest move: ${recommended || "test the updated identity from another agent surface."}`,
+            ].join("\n");
+        }
+        return [
+            "local tool finished.",
+            "",
+            `next strongest move: ${recommended || "continue from the local result above."}`,
+        ].join("\n");
+    };
+    const recordLocalToolResult = (toolResult) => {
         args.messages.push({ role: "user", content: args.userInput });
         args.messages.push({
             role: "user",
@@ -1345,56 +1734,57 @@ async function handleLocalChatIntent(args) {
                 "Do not ask the user what the local project is if the tool result already names it.",
                 "State what the local host actually found, make one concrete recommendation, and end with the exact phrase `next strongest move: ...`.",
                 "For workspace scans, reuse recommended_next_move as the final next strongest move. The supported follow-up command is `start there`; do not invent commands like `open PROJECT`.",
+                "For read_project_context results, summarize what you actually saw and recommend the next concrete local tool action.",
+                "For sync_identity results, state whether local compile or remote publish happened.",
                 "Do not end with a question. Keep it under 8 lines. No generic help-desk closer.",
             ].join("\n"),
         });
-        const result = await callLLMWithStreaming(args.apiKey, args.messages, spinnerLabel);
-        args.messages.push({ role: "assistant", content: result.text });
-        if (!result.streamed) {
-            printAgentMessage((0, onboarding_1.parseUpdatesFromResponse)(result.text).display);
-        }
+        const summary = summarizeLocalToolResult(toolResult);
+        args.messages.push({ role: "assistant", content: summary });
+        printAgentMessage(summary);
     };
-    if (isLocalRecentProjectsIntent(args.userInput)) {
-        const spinner = new render_1.BrailleSpinner("checking local workspaces");
+    if (isLocalToolLoopCandidate(args.userInput)) {
+        const routeSpinner = new render_1.BrailleSpinner("choosing local tool");
+        routeSpinner.start();
+        const toolCall = await chooseLocalHostTool(args);
+        routeSpinner.stop(`selected ${toolCall.tool}`);
+        if (toolCall.tool === "respond")
+            return false;
+        const labelByTool = {
+            discover_projects: "discovering local projects",
+            read_project_context: "reading project context",
+            write_project_context: "writing project context",
+            sync_identity: "syncing identity context",
+            respond: "thinking",
+        };
+        const spinner = new render_1.BrailleSpinner(labelByTool[toolCall.tool]);
         spinner.start();
-        await delay(700);
-        const insights = scanRecentWorkspaceProjects(8);
-        spinner.stop("local workspace scanned");
-        args.launchInvestigation.strongestProject = insights[0] || args.launchInvestigation.strongestProject;
-        args.launchInvestigation.strongestMove = insights[0]?.summary || args.launchInvestigation.strongestMove;
-        await runToolResultThroughModel(formatLocalRecentProjectsToolResult(insights), "turning local project scan into a useful read");
-        return true;
-    }
-    if (isStartThereIntent(args.userInput)) {
-        const project = args.launchInvestigation.strongestProject ||
-            (0, project_1.getTopProjectOpportunity)((0, project_1.getRecentProjectInsights)(process.cwd(), 8));
-        if (!project || !fs.existsSync(project.projectDir)) {
-            const response = "i don't have a real local target for that yet. ask me to scan local workspaces and i'll pick from actual folders.\n\nnext strongest move: scan local recent projects first.";
+        try {
+            const toolResult = await executeLocalHostTool(toolCall, args);
+            const statusLine = toolResult.match(/^status: (.+)$/m)?.[1] || "done";
+            spinner.stop(statusLine);
+            recordLocalToolResult(toolResult);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : "local tool failed";
+            spinner.fail(message);
+            const response = [
+                `local tool failed: ${message}`,
+                "",
+                "next strongest move: retry with a read-only local scan so i can recover from real filesystem state.",
+            ].join("\n");
             args.messages.push({ role: "user", content: args.userInput });
             args.messages.push({ role: "assistant", content: response });
             printAgentMessage(response);
-            return true;
-        }
-        const spinner = new render_1.BrailleSpinner(`opening ${project.name} from local disk`);
-        spinner.start();
-        await delay(500);
-        const previousCwd = process.cwd();
-        let result;
-        try {
-            process.chdir(project.projectDir);
-            result = (0, skills_1.initProject)({ mode: "additive" });
         }
-        finally {
-            process.chdir(previousCwd);
-        }
-        spinner.stop(`${project.name} updated`);
-        await runToolResultThroughModel(formatProjectBootstrapToolResult(project, result), `summarizing ${project.name} changes`);
         return true;
     }
     return false;
 }
 // ─── Main chat command ────────────────────────────────────────────────
 async function chatCommand() {
+    // Chat is a readline loop — piped/CI stdin would hang or spin
+    (0, render_1.requireInteractiveTTY)();
     const bundleDir = resolveBundleDirForChat();
     if (!bundleDir) {
         console.log("");
@@ -1413,23 +1803,24 @@ async function chatCommand() {
         ? rawProjectCtx
         : null;
     let projectContextBlock = "";
-    let activeProjectDir = null;
+    let activeProjectResolution = null;
     if (projectCtx) {
-        // Try the new file-system project context first
+        // Single project-context engine: managed store + repo project-context/
+        // overlay (repo wins on conflicts; the union feeds the injection).
         const projectsRoot = (0, project_1.findProjectsRoot)();
-        if (projectsRoot) {
-            const detected = (0, project_1.detectCurrentProject)(projectsRoot);
-            if (detected) {
-                activeProjectDir = (0, project_1.getProjectDir)(projectsRoot, detected);
-                const injection = (0, project_1.buildProjectContextInjection)(activeProjectDir);
-                if (injection) {
-                    projectContextBlock = `\n\n--- project context ---\n${injection}`;
-                }
+        const detected = projectsRoot ? (0, project_1.detectCurrentProject)(projectsRoot) : null;
+        const resolved = (0, projectContext_1.resolveProjectContext)(detected ? { projectName: detected } : {});
+        if (detected || resolved.repoContextDir) {
+            activeProjectResolution = resolved;
+            const merged = (0, projectContext_1.readMergedProjectContext)(detected ? { projectName: detected } : {});
+            const injection = merged ? (0, project_1.buildProjectContextInjectionFromContext)(merged) : null;
+            if (injection) {
+                projectContextBlock = `\n\n--- project context ---\n${injection}`;
             }
         }
         // Fallback to legacy project context if new system didn't produce anything
         if (!projectContextBlock) {
-            const projectNotes = (0, config_1.readProjectPrivateNotes)(projectCtx.name);
+            const projectNotes = (0, projectContext_1.readProjectPrivateNotes)(projectCtx.name);
             const parts = [];
             parts.push(`the user is currently working in project: ${projectCtx.name} at ${projectCtx.root}`);
             if (projectCtx.youmdProject?.description) {
@@ -1526,7 +1917,7 @@ async function chatCommand() {
             continue;
         }
         if (lower === "/link") {
-            showLinkInfo(bundleDir);
+            showLinkInfo();
             continue;
         }
         if (lower === "/share") {
@@ -1535,13 +1926,13 @@ async function chatCommand() {
         }
         if (lower === "/memory" || lower === "/memories") {
             try {
-                const { listMemories } = require("../lib/api");
-                const res = await listMemories({ limit: 20 });
-                if (res.ok && Array.isArray(res.data) && res.data.length > 0) {
+                const res = await (0, api_1.listMemories)({ limit: 20 });
+                const memories = res.ok ? res.data?.memories ?? [] : [];
+                if (memories.length > 0) {
                     const grouped = new Map();
-                    for (const m of res.data)
+                    for (const m of memories)
                         grouped.set(m.category, (grouped.get(m.category) || 0) + 1);
-                    console.log(chalk_1.default.dim(`  memory: ${res.data.length} total`));
+                    console.log(chalk_1.default.dim(`  memory: ${memories.length} total`));
                     for (const [cat, count] of grouped) {
                         console.log(chalk_1.default.dim(`    ${cat}s: ${count}`));
                     }
@@ -1559,12 +1950,12 @@ async function chatCommand() {
         if (lower === "/recall" || lower.startsWith("/recall ")) {
             const query = lower.startsWith("/recall ") ? lower.slice(8).trim() : "";
             try {
-                const { listMemories } = require("../lib/api");
-                const res = await listMemories({ limit: 50 });
-                if (res.ok && Array.isArray(res.data)) {
+                const res = await (0, api_1.listMemories)({ limit: 50 });
+                if (res.ok && res.data?.memories) {
+                    const memories = res.data.memories;
                     const matches = query
-                        ? res.data.filter((m) => m.content.toLowerCase().includes(query) || m.category.includes(query))
-                        : res.data.slice(0, 10);
+                        ? memories.filter((m) => m.content.toLowerCase().includes(query) || m.category.includes(query))
+                        : memories.slice(0, 10);
                     if (matches.length > 0) {
                         console.log(chalk_1.default.dim(query ? `  ${matches.length} memories matching "${query}":` : "  recent memories:"));
                         for (const m of matches.slice(0, 10)) {
@@ -1584,8 +1975,7 @@ async function chatCommand() {
         }
         if (lower === "/private") {
             try {
-                const { getPrivateContext } = require("../lib/api");
-                const res = await getPrivateContext();
+                const res = await (0, api_1.getPrivateContext)();
                 if (res.ok && res.data) {
                     const p = res.data;
                     if (p.privateNotes) {
@@ -1707,6 +2097,7 @@ async function chatCommand() {
             messages,
             launchInvestigation,
             apiKey,
+            bundleDir,
         });
         if (handledLocally)
             continue;
@@ -1845,8 +2236,21 @@ async function chatCommand() {
                         console.log(chalk_1.default.green("  [saved private note]"));
                     }
                     else if (pu.field === "privateProjects" && pu.action === "add" && pu.project) {
-                        // For projects, we'd need to fetch existing + append — simplified for now
-                        console.log(chalk_1.default.green(`  [saved private project: ${pu.project.name || "unnamed"}]`));
+                        const existing = await (0, api_1.getPrivateContext)();
+                        const projects = existing.ok ? existing.data?.privateProjects ?? [] : [];
+                        const res = await (0, api_1.updatePrivateContext)({
+                            privateProjects: [...projects, {
+                                    name: pu.project.name || "unnamed",
+                                    description: pu.project.description || "",
+                                    status: pu.project.status || "active",
+                                }],
+                        });
+                        if (res.ok) {
+                            console.log(chalk_1.default.green(`  [saved private project: ${pu.project.name || "unnamed"}]`));
+                        }
+                        else {
+                            console.log(chalk_1.default.yellow("  [private context update failed]"));
+                        }
                     }
                 }
                 catch {
@@ -1854,13 +2258,15 @@ async function chatCommand() {
                 }
             }
         }
-        // Handle project context updates
-        if (activeProjectDir) {
+        // Handle project context updates — the engine routes context/ files to
+        // the repo project-context/ copy when inside the repo, otherwise to the
+        // global ~/.youmd/projects/<name>/ store.
+        if (activeProjectResolution) {
             const projUpdates = (0, project_1.parseProjectUpdates)(response);
             if (projUpdates.length > 0) {
                 for (const pu of projUpdates) {
                     try {
-                        (0, project_1.updateProjectFile)(activeProjectDir, pu.file, pu.content);
+                        (0, projectContext_1.writeProjectUpdate)(activeProjectResolution, pu.file, pu.content);
                         console.log(chalk_1.default.hex("#C46A3A")(`  [updated project context: ${pu.file}]`));
                     }
                     catch {
@@ -1920,8 +2326,7 @@ function printAgentMessage(text) {
     if (!text)
         return;
     // Use rich terminal renderer for structured content
-    const { renderRichResponse } = require("../lib/render");
-    console.log(renderRichResponse(text));
+    console.log((0, render_1.renderRichResponse)(text));
     console.log("");
 }
 //# sourceMappingURL=chat.js.map