youmd 0.6.13 → 0.6.21

package/dist/commands/chat.js

@@ -46,6 +46,7 @@ const config_1 = require("../lib/config");
 const project_1 = require("../lib/project");
 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 onboarding_1 = require("../lib/onboarding");
 const ascii_1 = require("../lib/ascii");
@@ -54,7 +55,7 @@ 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.13";
+const CURRENT_VERSION = "0.6.21";
 function delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -980,13 +981,14 @@ async function runYouLaunchInvestigation(bundleDir, projectCtx, recentProjects)
     const findings = [];
     let strongestMove;
     let strongestCommand;
+    let strongestProject;
     const rotation = setInterval(() => {
         spinner.update(labels[labelIndex % labels.length]);
         labelIndex += 1;
     }, 1100);
     spinner.start();
     try {
-        await delay(160);
+        await delay(600);
         try {
             const hasPreferences = fs.existsSync(path.join(bundleDir, "preferences", "agent.md"));
             const hasDirectives = fs.existsSync(path.join(bundleDir, "directives", "agent.md"));
@@ -1026,6 +1028,15 @@ async function runYouLaunchInvestigation(bundleDir, projectCtx, recentProjects)
                 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",
+                    };
                 }
             }
             catch {
@@ -1044,16 +1055,24 @@ async function runYouLaunchInvestigation(bundleDir, projectCtx, recentProjects)
                 findings.push(`${insights[0].name} already looks pretty well-shaped, so i can go deeper instead of scaffolding basics.`);
             }
             else if (opportunities.length > 0) {
-                strongestMove = opportunities[0].summary;
-                strongestCommand = opportunities[0].suggestedCommand;
+                const strongest = opportunities[0];
+                strongestMove = strongest.summary;
+                strongestCommand = strongest.suggestedCommand;
+                strongestProject = strongest;
             }
         }
         else {
             findings.push("i've got your home bundle loaded, even though we're not inside a project yet.");
         }
-        await delay(220);
+        await delay(900);
         spinner.stop("looked through local context");
-        return { findings: findings.slice(0, 6), strongestMove, strongestCommand };
+        return {
+            findings: findings.slice(0, 3),
+            strongestMove,
+            strongestCommand,
+            strongestProject,
+            recentProjects: recentProjects.slice(0, 3),
+        };
     }
     finally {
         clearInterval(rotation);
@@ -1068,7 +1087,7 @@ async function printChatOpening(bundleDir, projectCtx) {
     const recentInsights = (0, project_1.getRecentProjectInsights)(process.cwd(), 6);
     const recentProjects = (0, project_1.getFeaturedRecentProjectNames)(recentInsights, 6);
     const launchSurface = process.env.YOUMD_LAUNCH_SURFACE;
-    let investigation = { findings: [] };
+    let investigation = { findings: [], recentProjects: recentProjects.slice(0, 3) };
     (0, ascii_1.printYouLogo)();
     let didShowPortrait = false;
     if (launchSurface !== "you") {
@@ -1083,6 +1102,7 @@ async function printChatOpening(bundleDir, projectCtx) {
                 currentProject: projectCtx?.name,
                 recentProjects,
                 portraitLines,
+                compact: true,
             })
             : false;
     }
@@ -1090,74 +1110,46 @@ async function printChatOpening(bundleDir, projectCtx) {
         console.log("");
         console.log("  " + ACCENT("there you are.") + " " + DIM("your portrait is loaded."));
     }
-    if (launchSurface === "you") {
-        console.log("");
-        investigation = await runYouLaunchInvestigation(bundleDir, projectCtx, recentProjects);
-        if (investigation.findings.length > 0) {
-            console.log("");
-            console.log("  " + ACCENT("i checked a few corners."));
-            for (const finding of investigation.findings) {
-                console.log("  " + DIM("· ") + chalk_1.default.white(finding));
-            }
-        }
-    }
     console.log("");
-    if (launchSurface === "you") {
-        console.log("  " + ACCENT("u is here.") + " " + DIM(`good to see you, ${displayName}.`));
-    }
-    else {
-        console.log("  " + ACCENT("u is here.") + " " + DIM(`good to see you, ${user}.`));
-    }
-    if (projectCtx) {
-        console.log("  " + DIM("current project: ") + chalk_1.default.white(projectCtx.name) + DIM(` (${projectCtx.root})`));
-        if (repoNeedsBootstrap(projectCtx.root)) {
-            console.log("  " + ACCENT("i spotted an opening.") + " " + DIM("this repo still wants AGENTS/project-context wiring."));
-            console.log("  " + DIM("say the word or run ") + chalk_1.default.cyan("youmd skill init-project") + DIM(" and i'll set it up."));
+    investigation = await runYouLaunchInvestigation(bundleDir, projectCtx, recentProjects);
+    if (investigation.findings.length > 0) {
+        console.log("");
+        console.log("  " + ACCENT("found:"));
+        for (const finding of investigation.findings.slice(0, 2)) {
+            console.log("  " + DIM("· ") + chalk_1.default.white(finding));
         }
     }
-    else {
-        console.log("  " + DIM("i don't see a repo context here yet, but i can still help with your identity, links, memories, and private context."));
-    }
-    if (recentProjects.length > 0) {
-        console.log("  " + DIM("recently active: ") + recentProjects.map((name) => chalk_1.default.cyan(name)).join(DIM(", ")));
-    }
-    const topOpportunity = !projectCtx ? (0, project_1.getTopProjectOpportunity)(recentInsights) : null;
-    if (topOpportunity) {
-        console.log("  " + ACCENT("next opening i see.") + " " + DIM(topOpportunity.summary));
-        console.log("  " + DIM("run:"));
-        console.log("    " + chalk_1.default.cyan(topOpportunity.suggestedCommand));
-        console.log("  " + DIM("then i'll help tighten it up."));
+    if (launchSurface !== "you") {
+        console.log("");
+        console.log("  " + chalk_1.default.bold("you.md chat"));
+        console.log("  " + DIM(`local context loaded for ${user}.`));
     }
     console.log("");
-    console.log("  " + chalk_1.default.bold("you.md chat"));
-    console.log("  " + DIM("talk naturally. i'll update your identity, spot useful structure, and suggest next moves."));
-    console.log("");
     return investigation;
 }
 function buildYouLaunchIntro(projectCtx, bundleDir, investigation) {
     const displayName = readDisplayName(bundleDir).split(" ")[0];
     const recentInsights = (0, project_1.getRecentProjectInsights)(process.cwd(), 6);
-    const recentProjects = (0, project_1.getFeaturedRecentProjectNames)(recentInsights, 6);
+    const recentProjects = investigation.recentProjects.length > 0
+        ? investigation.recentProjects
+        : (0, project_1.getFeaturedRecentProjectNames)(recentInsights, 3);
     const lines = [];
-    lines.push(`hi ${displayName}. i'm U — i help other agents know you.`);
+    lines.push(`hi ${displayName}. i'm U.`);
     if (projectCtx) {
-        lines.push(`i already clocked that you're inside ${projectCtx.name}.`);
+        lines.push(`i'm inside ${projectCtx.name}.`);
         if (repoNeedsBootstrap(projectCtx.root)) {
-            lines.push("this repo still wants cleaner agent wiring, so i can scaffold that whenever you want.");
+            lines.push("it still wants cleaner agent wiring.");
         }
     }
     else if (recentProjects.length > 0) {
-        lines.push(`recently you've been orbiting ${recentProjects.slice(0, 3).join(", ")}.`);
+        lines.push(`recent orbit: ${recentProjects.slice(0, 3).join(", ")}.`);
         const topOpportunity = (0, project_1.getTopProjectOpportunity)(recentInsights);
         if (topOpportunity) {
-            lines.push(`biggest opening i see: ${topOpportunity.summary}`);
+            lines.push(`strongest opening: ${topOpportunity.summary}`);
         }
     }
     else {
-        lines.push("clean slate. we can still shape your identity, private context, or project structure from here.");
-    }
-    if (investigation.findings.length > 0) {
-        lines.push(`quick read: ${investigation.findings.slice(0, 2).join(" ")}`);
+        lines.push("clean slate. we can shape identity, private context, or project structure from here.");
     }
     const strongestMove = investigation.strongestMove
         || (projectCtx && repoNeedsBootstrap(projectCtx.root)
@@ -1165,19 +1157,547 @@ function buildYouLaunchIntro(projectCtx, bundleDir, investigation) {
             : null)
         || (0, project_1.getTopProjectOpportunity)(recentInsights)?.summary
         || null;
-    const strongestCommand = investigation.strongestCommand
-        || (projectCtx && repoNeedsBootstrap(projectCtx.root) ? "youmd skill init-project" : null)
-        || (0, project_1.getTopProjectOpportunity)(recentInsights)?.suggestedCommand
-        || null;
     if (strongestMove) {
-        lines.push(`the strongest move i can see right now: ${strongestMove}`);
-        lines.push("say \"start there\" and i'll take it, or redirect me.");
+        lines.push(`next strongest move: ${strongestMove}`);
+        lines.push("say \"start there\" and i'll take it.");
     }
     else {
-        lines.push("point me at the next thing and i'll move first instead of waiting around.");
+        lines.push("point me at the next thing and i'll move first.");
     }
     return lines.join("\n\n");
 }
+function isStartThereIntent(input) {
+    const lower = input.toLowerCase().trim().replace(/[.!?]+$/, "");
+    return [
+        "start there",
+        "start there please",
+        "do that",
+        "do it",
+        "take it",
+        "go",
+        "go ahead",
+        "yes",
+        "yep",
+        "start",
+    ].includes(lower);
+}
+function isLocalRecentProjectsIntent(input) {
+    const lower = input.toLowerCase();
+    const mentionsLocalWork = lower.includes("local director") ||
+        lower.includes("local directory") ||
+        lower.includes("local filesystem") ||
+        lower.includes("my local") ||
+        lower.includes("on my computer") ||
+        lower.includes("workspace") ||
+        lower.includes("workspaces");
+    const asksRecentWork = lower.includes("recently touched") ||
+        lower.includes("most recently") ||
+        lower.includes("what i've been working") ||
+        lower.includes("what ive been working") ||
+        lower.includes("working on lately") ||
+        lower.includes("recent projects");
+    return mentionsLocalWork && asksRecentWork;
+}
+function getLocalWorkspaceRoots() {
+    return (0, project_1.getWorkspaceRootCandidates)(process.cwd());
+}
+function getRecentFileMtime(projectDir, maxFiles = 1200) {
+    const skipDirs = new Set([
+        ".git",
+        "node_modules",
+        ".next",
+        "dist",
+        "build",
+        ".turbo",
+        ".vercel",
+        "coverage",
+        ".cache",
+    ]);
+    let latest = 0;
+    let visited = 0;
+    const stack = [{ dir: projectDir, depth: 0 }];
+    while (stack.length > 0 && visited < maxFiles) {
+        const current = stack.pop();
+        if (!current)
+            break;
+        let entries = [];
+        try {
+            entries = fs.readdirSync(current.dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (visited >= maxFiles)
+                break;
+            if (entry.name.startsWith(".") && entry.name !== ".youmd-project")
+                continue;
+            const fullPath = path.join(current.dir, entry.name);
+            try {
+                const stat = fs.statSync(fullPath);
+                latest = Math.max(latest, stat.mtimeMs);
+                visited += 1;
+                if (entry.isDirectory() && current.depth < 3 && !skipDirs.has(entry.name)) {
+                    stack.push({ dir: fullPath, depth: current.depth + 1 });
+                }
+            }
+            catch {
+                // keep scanning; one unreadable file should not break the local read.
+            }
+        }
+    }
+    return latest;
+}
+function scanRecentWorkspaceProjects(limit = 8) {
+    const insights = [];
+    const seen = new Set();
+    for (const root of getLocalWorkspaceRoots()) {
+        let entries = [];
+        try {
+            entries = fs.readdirSync(root, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory() || entry.name.startsWith("."))
+                continue;
+            const projectDir = path.join(root, entry.name);
+            let realDir = projectDir;
+            try {
+                realDir = fs.realpathSync.native(projectDir);
+            }
+            catch {
+                // use unresolved path below
+            }
+            if (seen.has(realDir))
+                continue;
+            seen.add(realDir);
+            const markerSignals = (0, project_1.getProjectMarkerSignals)(projectDir);
+            if (markerSignals.length === 0)
+                continue;
+            const updatedAt = Math.max(getRecentFileMtime(projectDir), statMtimeMs(projectDir) || 0);
+            insights.push({
+                name: entry.name,
+                slug: entry.name,
+                projectDir,
+                updatedAt,
+                signals: markerSignals,
+                summary: `${entry.name} touched ${formatRelativeTimeFromMs(updatedAt)}${markerSignals.length > 0 ? `; found ${markerSignals.slice(0, 3).join(", ")}` : ""}.`,
+                suggestedCommand: `cd ${projectDir} && you`,
+            });
+        }
+    }
+    return insights.sort((a, b) => b.updatedAt - a.updatedAt).slice(0, limit);
+}
+function formatLocalRecentProjectsToolResult(insights) {
+    if (insights.length === 0) {
+        const roots = getLocalWorkspaceRoots();
+        return roots.length === 0
+            ? "tool: workspace_recent_projects\nstatus: empty\nresult: checked common local workspace roots and did not find one. users can set YOUMD_WORKSPACE_ROOTS to add explicit roots."
+            : "tool: workspace_recent_projects\nstatus: empty\nresult: found the workspace root, but no project folders showed up in the first scan.";
+    }
+    const lines = [
+        "tool: workspace_recent_projects",
+        "status: ok",
+        "projects:",
+        ...insights.slice(0, 6).map((item, index) => {
+            const markers = item.signals.length > 0 ? ` — ${item.signals.slice(0, 3).join(", ")}` : "";
+            return `${index + 1}. ${item.name} — ${item.projectDir} — touched ${formatRelativeTimeFromMs(item.updatedAt)}${markers}`;
+        }),
+        "",
+        `recommended_next_project: ${insights[0].name}`,
+        `recommended_next_project_dir: ${insights[0].projectDir}`,
+        `recommended_next_command: cd ${insights[0].projectDir} && you`,
+        `recommended_next_move: say "start there" to open ${insights[0].name} and tighten the agent entrypoint from actual files, not a guessed summary.`,
+    ];
+    return lines.join("\n");
+}
+function formatProjectBootstrapToolResult(project, result) {
+    const changed = result.steps
+        .filter((step) => step.ok && step.detail && !step.detail.includes("unchanged") && !step.detail.includes("already present"))
+        .map((step) => `${step.name}: ${step.detail}`);
+    const checked = result.steps.filter((step) => step.ok).length;
+    return [
+        "tool: project_bootstrap",
+        "status: ok",
+        `project: ${project.name}`,
+        `project_dir: ${project.projectDir}`,
+        changed.length > 0
+            ? `changed: ${changed.slice(0, 6).join("; ")}`
+            : `changed: none; checked ${checked} bootstrap steps; everything important was already present.`,
+        "",
+        `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) || 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",
+    ].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)) {
+        return { tool: "write_project_context", project: launchInvestigation.strongestProject?.name, mode: "bootstrap" };
+    }
+    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 formatProjectReadToolResult(project) {
+    const files = [
+        "AGENTS.md",
+        "CLAUDE.md",
+        "package.json",
+        "pyproject.toml",
+        "Cargo.toml",
+        "go.mod",
+        "project-context/CURRENT_STATE.md",
+        "project-context/TODO.md",
+        "project-context/PRD.md",
+        "project-context/ARCHITECTURE.md",
+        ".you/project-context/CURRENT_STATE.md",
+        ".you/project-context/TODO.md",
+    ];
+    const snippets = files
+        .map((relativePath) => {
+        const snippet = readSnippet(path.join(project.projectDir, relativePath));
+        return snippet ? `file: ${relativePath}\n${snippet}` : null;
+    })
+        .filter((item) => !!item)
+        .slice(0, 5);
+    const managedContext = (0, project_1.readProjectContext)(project.projectDir);
+    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",
+        "",
+        snippets.length > 0 ? snippets.join("\n\n---\n\n") : "no readable project-context or agent entrypoint files found yet.",
+        "",
+        `recommended_next_move: write a sharper current-state + TODO pass for ${project.name} if the user wants this project tightened.`,
+    ].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) {
+    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) => {
+        args.messages.push({ role: "user", content: args.userInput });
+        args.messages.push({
+            role: "user",
+            content: [
+                "--- local host tool result ---",
+                toolResult,
+                "--- instructions ---",
+                "Use this local tool result as ground truth. Do not say you cannot access the filesystem; the CLI host just accessed it for you.",
+                "Use recommended_next_project exactly as the target unless the user explicitly asks for a different project.",
+                "Do not say you are scraping, pulling, reading, opening, or updating anything now unless that completed action appears in the tool result.",
+                "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);
+        }
+    };
+    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();
+        try {
+            const toolResult = await executeLocalHostTool(toolCall, args);
+            const statusLine = toolResult.match(/^status: (.+)$/m)?.[1] || "done";
+            spinner.stop(statusLine);
+            await runToolResultThroughModel(toolResult, `summarizing ${toolCall.tool}`);
+        }
+        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;
+    }
+    return false;
+}
 // ─── Main chat command ────────────────────────────────────────────────
 async function chatCommand() {
     const bundleDir = resolveBundleDirForChat();
@@ -1274,41 +1794,11 @@ async function chatCommand() {
             content: `here is my current identity bundle:\n\n${currentBundle}${directivesContext}${projectContextBlock}\n\n${greetingInstruction}`,
         },
     ];
-    // Initial greeting from agent
-    if (process.env.YOUMD_LAUNCH_SURFACE === "you") {
-        const proactiveIntro = buildYouLaunchIntro(projectCtx, bundleDir, launchInvestigation);
-        messages.push({ role: "assistant", content: proactiveIntro });
-        printAgentMessage(proactiveIntro);
-    }
-    else {
-        let response;
-        let streamed = false;
-        try {
-            const result = await callLLMWithStreaming(apiKey, messages, (0, onboarding_1.randomThinking)());
-            response = result.text;
-            streamed = result.streamed;
-        }
-        catch (err) {
-            console.log(chalk_1.default.red(`  failed to connect: ${err instanceof Error ? err.message : String(err)}`));
-            console.log(chalk_1.default.dim("  chat requires the AI service. try again later."));
-            console.log("");
-            rl.close();
-            return;
-        }
-        messages.push({ role: "assistant", content: response });
-        const initial = (0, onboarding_1.parseUpdatesFromResponse)(response);
-        // Write any updates (unlikely on greeting, but handle it)
-        if (initial.updates.length > 0) {
-            for (const update of initial.updates) {
-                (0, onboarding_1.writeSectionFile)(bundleDir, update.section, update.content);
-            }
-            console.log(chalk_1.default.cyan(`  [updated: ${initial.updates.map((u) => (0, onboarding_1.sectionLabel)(u.section)).join(", ")}]`));
-            console.log("");
-        }
-        if (!streamed) {
-            printAgentMessage(initial.display);
-        }
-    }
+    // Initial greeting is local and action-aware. The remote model should not invent
+    // filesystem capabilities before the CLI has decided what it can actually do.
+    const proactiveIntro = buildYouLaunchIntro(projectCtx, bundleDir, launchInvestigation);
+    messages.push({ role: "assistant", content: proactiveIntro });
+    printAgentMessage(proactiveIntro);
     // ── Conversation loop ──────────────────────────────────────────────
     let response = "";
     let streamed = false;
@@ -1517,6 +2007,15 @@ async function chatCommand() {
             }
             continue;
         }
+        const handledLocally = await handleLocalChatIntent({
+            userInput,
+            messages,
+            launchInvestigation,
+            apiKey,
+            bundleDir,
+        });
+        if (handledLocally)
+            continue;
         // ── Detect dragged/pasted file paths ──
         const detectedFile = detectFilePath(userInput);
         if (detectedFile) {