@mukulaggarwal/pacman 0.1.3 → 0.1.4

package/dist/onboarding-server.js

@@ -9,6 +9,7 @@ import {
   validateProviderConfig
 } from "./chunk-O6T35A4O.js";
 import {
+  WORKSPACE_PATHS,
   createConfigManager,
   createGDriveStorage,
   createLocalStorage
@@ -20,9 +21,9 @@ import {
 
 // src/onboarding-server.ts
 import express from "express";
-import * as path from "path";
-import * as fs from "fs/promises";
-import { exec } from "child_process";
+import * as path2 from "path";
+import * as fs2 from "fs/promises";
+import { execFile } from "child_process";
 import { promisify } from "util";
 
 // ../template-engine/dist/index.js
@@ -427,8 +428,446 @@ function renderTemplate(template, user) {
   return files;
 }
 
+// src/project-structure.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+var MAX_DIR_ENTRIES = 10;
+var README_CANDIDATES = ["README.md", "readme.md", "README.txt", "readme.txt"];
+var OLLAMA_BASE_URL = "http://127.0.0.1:11434";
+async function buildProjectStructurePreview(input) {
+  const baseFiles = renderTemplate(getTemplate(input.profileType), {
+    name: input.name,
+    assistantName: input.assistantName,
+    responsibilities: input.responsibilities
+  });
+  const folderSignals = await Promise.all(
+    input.localFolders.filter((folder) => folder.path.trim()).map((folder) => collectFolderSignal(folder))
+  );
+  const heuristicProjects = buildHeuristicProjects(folderSignals, input.integrations);
+  const ollamaResult = await enrichProjectsWithOllama(
+    heuristicProjects,
+    folderSignals,
+    input.integrations
+  );
+  const projects = ollamaResult?.projects ?? heuristicProjects;
+  const inference = ollamaResult?.inference ?? {
+    strategy: "heuristic",
+    note: "Structured locally from folder tags, folder names, and visible directory signals. No external API calls were made."
+  };
+  return {
+    files: buildTemplateFiles(baseFiles, projects, folderSignals, input.integrations),
+    projects,
+    inference
+  };
+}
+function buildTemplateFiles(baseFiles, projects, folderSignals, integrations) {
+  const files = { ...baseFiles };
+  const integrationNames = integrations.map(formatIntegrationName);
+  files["overview.md"] = [
+    baseFiles["overview.md"] ?? "# Overview",
+    "",
+    "## Confirmed Project Structure",
+    "",
+    projects.length > 0 ? projects.map((project) => `- **${project.name}** \u2014 ${project.primaryFocus || project.summary}`).join("\n") : "- No project groups were inferred yet. Add local folders or integrations and revisit this step."
+  ].join("\n");
+  const sourceLines = [];
+  if (folderSignals.length > 0) {
+    sourceLines.push("## Local Sources", "");
+    sourceLines.push(...folderSignals.map((signal) => `- \`${signal.path}\``));
+    sourceLines.push("");
+  }
+  if (integrationNames.length > 0) {
+    sourceLines.push("## Connected Integrations", "");
+    sourceLines.push(...integrationNames.map((name) => `- ${name}`));
+    sourceLines.push("");
+  }
+  if (sourceLines.length > 0) {
+    files["docs.md"] = [baseFiles["docs.md"] ?? "# Documentation References", "", ...sourceLines].join(
+      "\n"
+    );
+  }
+  if (integrationNames.length > 0) {
+    files["integrations.md"] = [
+      "# Connected Integrations",
+      "",
+      ...integrationNames.map((name) => `- ${name}`),
+      "",
+      "## Notes",
+      "",
+      "These integrations are workspace-level sources. Confirm project-specific mappings after the first sync.",
+      ""
+    ].join("\n");
+  }
+  for (const project of projects) {
+    files[`projects/${project.slug}.md`] = buildProjectFile(project);
+  }
+  return files;
+}
+function buildProjectFile(project) {
+  return [
+    `# ${project.name}`,
+    "",
+    "## Summary",
+    "",
+    project.summary || "<!-- Add a short summary for this project -->",
+    "",
+    "## Primary Focus",
+    "",
+    project.primaryFocus || "<!-- Capture the main problem area, domain, or ownership -->",
+    "",
+    "## Local Sources",
+    "",
+    formatBulletList(
+      project.sourceFolders.map((folder) => `\`${folder}\``),
+      "No local folders linked to this project yet."
+    ),
+    "",
+    "## Connected Integrations",
+    "",
+    formatBulletList(
+      project.connectedIntegrations,
+      "No integrations connected during onboarding."
+    ),
+    "",
+    "## Grouping Signals",
+    "",
+    formatBulletList(project.keySignals, "Add more details after the first sync."),
+    "",
+    "## Notes To Confirm",
+    "",
+    "- Owners:",
+    "- Key repos/docs:",
+    "- Important decisions:",
+    ""
+  ].join("\n");
+}
+function formatBulletList(items, fallback) {
+  if (items.length === 0) {
+    return `- ${fallback}`;
+  }
+  return items.map((item) => `- ${item}`).join("\n");
+}
+async function collectFolderSignal(folder) {
+  const rawPath = folder.path.trim();
+  const resolvedPath = path.resolve(rawPath);
+  const basename2 = path.basename(resolvedPath);
+  const notes = [];
+  const entries = [];
+  let packageName;
+  let readmeHeading;
+  if (folder.project?.trim()) {
+    notes.push(`Tagged as "${folder.project.trim()}" during onboarding`);
+  }
+  try {
+    const dirEntries = await fs.readdir(resolvedPath, { withFileTypes: true });
+    const visibleEntries = dirEntries.filter((entry) => !entry.name.startsWith(".")).slice(0, MAX_DIR_ENTRIES).map((entry) => entry.isDirectory() ? `${entry.name}/` : entry.name);
+    entries.push(...visibleEntries);
+    if (visibleEntries.length > 0) {
+      notes.push(`Top entries: ${visibleEntries.slice(0, 5).join(", ")}`);
+    }
+  } catch {
+    notes.push("Folder contents could not be read during onboarding");
+  }
+  try {
+    const packageJson = await fs.readFile(path.join(resolvedPath, "package.json"), "utf-8");
+    const parsed = JSON.parse(packageJson);
+    if (parsed.name?.trim()) {
+      packageName = parsed.name.trim();
+      notes.push(`package.json name: ${packageName}`);
+    }
+  } catch {
+  }
+  for (const candidate of README_CANDIDATES) {
+    try {
+      const readme = await fs.readFile(path.join(resolvedPath, candidate), "utf-8");
+      const heading = extractReadmeHeading(readme);
+      if (heading) {
+        readmeHeading = heading;
+        notes.push(`README heading: ${heading}`);
+        break;
+      }
+    } catch {
+    }
+  }
+  return {
+    path: rawPath,
+    explicitProject: folder.project?.trim() || void 0,
+    basename: basename2,
+    packageName,
+    readmeHeading,
+    entries,
+    notes
+  };
+}
+function extractReadmeHeading(contents) {
+  for (const rawLine of contents.split("\n").slice(0, 30)) {
+    const line = rawLine.trim();
+    if (!line) continue;
+    if (line.startsWith("#")) {
+      return line.replace(/^#+\s*/, "").trim();
+    }
+    if (line.length <= 80) {
+      return line;
+    }
+  }
+  return void 0;
+}
+function buildHeuristicProjects(folderSignals, integrations) {
+  const integrationNames = integrations.map(formatIntegrationName);
+  const groups = /* @__PURE__ */ new Map();
+  if (folderSignals.length === 0 && integrationNames.length > 0) {
+    return [
+      {
+        slug: "workspace-context",
+        name: "Workspace Context",
+        summary: "Connected integrations are ready, but no local folders were added during onboarding. Confirm the main project boundaries after the first sync.",
+        primaryFocus: "Cross-project workspace context",
+        sourceFolders: [],
+        connectedIntegrations: integrationNames,
+        keySignals: integrationNames.map((name) => `Connected integration: ${name}`)
+      }
+    ];
+  }
+  for (const signal of folderSignals) {
+    const groupName = signal.explicitProject || inferProjectName(signal);
+    const slug = slugify(groupName) || "untitled-project";
+    const existing = groups.get(slug);
+    if (existing) {
+      existing.sourceFolders.push(signal.path);
+      existing.keySignals = unique([...existing.keySignals, ...signal.notes]);
+      continue;
+    }
+    groups.set(slug, {
+      slug,
+      name: groupName,
+      summary: buildHeuristicSummary(groupName, signal, integrationNames),
+      primaryFocus: buildHeuristicFocus(signal),
+      sourceFolders: [signal.path],
+      connectedIntegrations: integrationNames,
+      keySignals: unique(signal.notes)
+    });
+  }
+  return [...groups.values()].sort((left, right) => left.name.localeCompare(right.name));
+}
+function buildHeuristicSummary(projectName, signal, integrationNames) {
+  const integrationSuffix = integrationNames.length > 0 ? ` It will also pull from ${integrationNames.join(", ")} once sync is enabled.` : "";
+  if (signal.readmeHeading) {
+    return `${projectName} appears to center on "${signal.readmeHeading}". Review and tighten this summary before finishing setup.${integrationSuffix}`;
+  }
+  if (signal.packageName) {
+    return `${projectName} was inferred from the local package "${signal.packageName}". Review and tighten this summary before finishing setup.${integrationSuffix}`;
+  }
+  return `${projectName} was inferred from the selected local workspace folder. Review and tighten this summary before finishing setup.${integrationSuffix}`;
+}
+function buildHeuristicFocus(signal) {
+  if (signal.packageName) {
+    return `Owns or contributes to the ${humanizeLabel(signal.packageName)} codebase.`;
+  }
+  if (signal.entries.some((entry) => entry === "docs/" || entry.toLowerCase().includes("docs"))) {
+    return "Mix of implementation and documentation workflows.";
+  }
+  if (signal.entries.some((entry) => entry === "src/" || entry === "app/" || entry.endsWith(".ts"))) {
+    return "Application code, implementation details, and related project context.";
+  }
+  return `Local context collected from the ${humanizeLabel(signal.basename)} workspace folder.`;
+}
+function inferProjectName(signal) {
+  if (signal.packageName) {
+    return humanizeLabel(signal.packageName);
+  }
+  const basename2 = humanizeLabel(signal.basename);
+  return basename2 || "Untitled Project";
+}
+async function enrichProjectsWithOllama(projects, folderSignals, integrations) {
+  if (projects.length === 0) {
+    return null;
+  }
+  const model = await resolveOllamaModel();
+  if (!model) {
+    return null;
+  }
+  const prompt = [
+    "You are organizing local workspace context during onboarding.",
+    "Return strict JSON only in the format:",
+    '{"projects":[{"slug":"","name":"","summary":"","primaryFocus":"","keySignals":[""]}]}',
+    "Rules:",
+    "- Keep the existing slugs exactly as provided.",
+    "- Do not invent repositories, teams, or integrations that are not in the input.",
+    "- Preserve the current project grouping; do not add or remove source folders.",
+    "- Summaries should be concise and grounded in the visible folder signals.",
+    "- Primary focus should be a short sentence.",
+    "",
+    JSON.stringify(
+      {
+        integrations: integrations.map(formatIntegrationName),
+        folders: folderSignals,
+        projects
+      },
+      null,
+      2
+    )
+  ].join("\n");
+  try {
+    const response = await fetch(`${OLLAMA_BASE_URL}/api/generate`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model,
+        prompt,
+        stream: false,
+        format: "json",
+        options: {
+          temperature: 0.2
+        }
+      }),
+      signal: AbortSignal.timeout(15e3)
+    });
+    if (!response.ok) {
+      return null;
+    }
+    const payload = await response.json();
+    if (!payload.response) {
+      return null;
+    }
+    const parsed = JSON.parse(payload.response);
+    const enrichedBySlug = new Map(
+      (parsed.projects ?? []).filter((project) => project.slug?.trim()).map((project) => [project.slug.trim(), project])
+    );
+    const enrichedProjects = projects.map((project) => {
+      const enriched = enrichedBySlug.get(project.slug);
+      if (!enriched) {
+        return project;
+      }
+      return {
+        ...project,
+        name: enriched.name?.trim() || project.name,
+        summary: enriched.summary?.trim() || project.summary,
+        primaryFocus: enriched.primaryFocus?.trim() || project.primaryFocus,
+        keySignals: enriched.keySignals?.map((signal) => signal.trim()).filter(Boolean).slice(0, 5) ?? project.keySignals
+      };
+    });
+    return {
+      projects: enrichedProjects,
+      inference: {
+        strategy: "ollama",
+        model,
+        note: `Structured locally and enriched with Ollama (${model}). No external API calls were made.`
+      }
+    };
+  } catch {
+    return null;
+  }
+}
+async function resolveOllamaModel() {
+  try {
+    const response = await fetch(`${OLLAMA_BASE_URL}/api/tags`, {
+      signal: AbortSignal.timeout(1500)
+    });
+    if (!response.ok) {
+      return null;
+    }
+    const payload = await response.json();
+    const modelNames = (payload.models ?? []).map((model) => model.name?.trim() ?? "").filter(Boolean);
+    if (modelNames.length === 0) {
+      return null;
+    }
+    return modelNames.find((name) => /qwen|llama|mistral|gemma/i.test(name)) ?? modelNames[0];
+  } catch {
+    return null;
+  }
+}
+function formatIntegrationName(id) {
+  const names = {
+    slack: "Slack",
+    github: "GitHub",
+    gitlab: "GitLab",
+    gmail: "Gmail",
+    gdrive: "Google Drive",
+    gchat: "Google Chat"
+  };
+  return names[id] ?? humanizeLabel(id);
+}
+function slugify(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function humanizeLabel(value) {
+  return value.replace(/[-_]+/g, " ").replace(/\s+/g, " ").trim().replace(/\b\w/g, (char) => char.toUpperCase());
+}
+function unique(values) {
+  return [...new Set(values.filter(Boolean))];
+}
+
 // src/onboarding-server.ts
-var execAsync = promisify(exec);
+var execFileAsync = promisify(execFile);
+var PICKER_COPY = {
+  "local-source": {
+    prompt: "Select a local project folder to tag in Pac-Man",
+    title: "Select project source folder"
+  },
+  storage: {
+    prompt: "Select the Pac-Man workspace folder",
+    title: "Select workspace folder"
+  }
+};
+async function resolvePickerStartPath(defaultPath) {
+  const trimmed = defaultPath?.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  const resolvedPath = path2.resolve(trimmed);
+  const candidates = [resolvedPath, path2.dirname(resolvedPath)];
+  for (const candidate of candidates) {
+    try {
+      const stats = await fs2.stat(candidate);
+      if (stats.isDirectory()) {
+        return candidate;
+      }
+    } catch {
+    }
+  }
+  return void 0;
+}
+function escapeAppleScriptString(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+function escapePowerShellString(value) {
+  return value.replace(/'/g, "''");
+}
+function ensureTrailingSeparator(folderPath) {
+  return folderPath.endsWith(path2.sep) ? folderPath : `${folderPath}${path2.sep}`;
+}
+function isPickerCancelledError(err) {
+  const message = String(err).toLowerCase();
+  return message.includes("user canceled") || message.includes("user cancelled") || message.includes("cancel");
+}
+async function openNativeFolderPicker(platform, purpose, startPath) {
+  const copy = PICKER_COPY[purpose];
+  if (platform === "darwin") {
+    const script = startPath ? `POSIX path of (choose folder with prompt "${escapeAppleScriptString(copy.prompt)}" default location POSIX file "${escapeAppleScriptString(startPath)}")` : `POSIX path of (choose folder with prompt "${escapeAppleScriptString(copy.prompt)}")`;
+    const { stdout } = await execFileAsync("osascript", ["-e", script]);
+    return stdout.trim();
+  }
+  if (platform === "linux") {
+    const args = ["--file-selection", "--directory", `--title=${copy.title}`];
+    if (startPath) {
+      args.push(`--filename=${ensureTrailingSeparator(startPath)}`);
+    }
+    const { stdout } = await execFileAsync("zenity", args);
+    return stdout.trim();
+  }
+  if (platform === "win32") {
+    const script = [
+      "Add-Type -AssemblyName System.Windows.Forms",
+      "$dialog = New-Object System.Windows.Forms.FolderBrowserDialog",
+      `$dialog.Description = '${escapePowerShellString(copy.prompt)}'`,
+      ...startPath ? [`$dialog.SelectedPath = '${escapePowerShellString(startPath)}'`] : [],
+      "if ($dialog.ShowDialog() -eq [System.Windows.Forms.DialogResult]::OK) { $dialog.SelectedPath }"
+    ].join("; ");
+    const { stdout } = await execFileAsync("powershell", ["-NoProfile", "-Command", script]);
+    return stdout.trim();
+  }
+  throw new Error("Folder picker not supported on this platform");
+}
 async function startOnboardingServer(port, workspacePath) {
   const app = express();
   app.use(express.json());
@@ -471,20 +910,44 @@ async function startOnboardingServer(port, workspacePath) {
       res.status(400).json({ error: String(err) });
     }
   });
+  app.post("/api/project-structure-preview", async (req, res) => {
+    const {
+      profileType,
+      name,
+      assistantName,
+      responsibilities,
+      localFolders,
+      integrations
+    } = req.body;
+    try {
+      const preview = await buildProjectStructurePreview({
+        profileType,
+        name,
+        assistantName,
+        responsibilities: responsibilities ?? [],
+        localFolders: localFolders ?? [],
+        integrations: integrations ?? []
+      });
+      res.json(preview);
+    } catch (err) {
+      res.status(400).json({ error: String(err) });
+    }
+  });
   app.post("/api/save", async (req, res) => {
     try {
-      const config = req.body;
-      const effectivePath = config.storage.mode === "local" && config.storage.workspacePath ? path.resolve(config.storage.workspacePath) : workspacePath;
-      await fs.mkdir(effectivePath, { recursive: true });
-      const rcPath = path.join(process.env.HOME ?? process.env.USERPROFILE ?? "~", ".personal-assistant-rc.json");
-      await fs.writeFile(rcPath, JSON.stringify({ workspacePath: effectivePath }, null, 2), "utf-8");
+      const payload = req.body;
+      const config = payload;
+      const effectivePath = config.storage.mode === "local" && config.storage.workspacePath ? path2.resolve(config.storage.workspacePath) : workspacePath;
+      await fs2.mkdir(effectivePath, { recursive: true });
+      const rcPath = path2.join(process.env.HOME ?? process.env.USERPROFILE ?? "~", ".personal-assistant-rc.json");
+      await fs2.writeFile(rcPath, JSON.stringify({ workspacePath: effectivePath }, null, 2), "utf-8");
       const localStorage = createLocalStorage(effectivePath);
       const localConfigManager = createConfigManager(localStorage);
       await localConfigManager.saveConfig(config);
       let targetStorage = localStorage;
       if (config.storage.mode === "gdrive") {
         const gdriveConfig = config.storage;
-        const resolvedCachePath = path.isAbsolute(gdriveConfig.cachePath) ? gdriveConfig.cachePath : path.resolve(path.dirname(effectivePath), gdriveConfig.cachePath);
+        const resolvedCachePath = path2.isAbsolute(gdriveConfig.cachePath) ? gdriveConfig.cachePath : path2.resolve(path2.dirname(effectivePath), gdriveConfig.cachePath);
         const gdriveStorage = createGDriveStorage({
           ...gdriveConfig,
           cachePath: resolvedCachePath
@@ -496,13 +959,25 @@ async function startOnboardingServer(port, workspacePath) {
       }
       const contextManager = createContextManager(targetStorage);
       await contextManager.initWorkspace();
-      const template = getTemplate(config.user.profileType);
-      const files = renderTemplate(template, {
+      const files = payload.templateFiles && Object.keys(payload.templateFiles).length > 0 ? payload.templateFiles : renderTemplate(getTemplate(config.user.profileType), {
         name: config.user.name,
         assistantName: config.user.assistantName,
         responsibilities: config.user.responsibilities
       });
       await contextManager.writeCanonicalFiles(files);
+      if (payload.inferredProjects && payload.inferredProjects.length > 0) {
+        await targetStorage.write(
+          WORKSPACE_PATHS.context.derived.suggestions.inferredProjects,
+          JSON.stringify(
+            payload.inferredProjects.map((project, index) => ({
+              name: project.slug ?? project.name ?? `project-${index + 1}`,
+              score: Number((1 - index * 0.1).toFixed(2))
+            })),
+            null,
+            2
+          )
+        );
+      }
       const eventClient = createNoopEventClient();
       await eventClient.emit("onboarding_completed", {
         profile: config.user.profileType,
@@ -613,39 +1088,40 @@ async function startOnboardingServer(port, workspacePath) {
       });
     }
   });
-  app.get("/api/pick-folder", async (_req, res) => {
+  app.post("/api/pick-folder", async (req, res) => {
+    const { defaultPath, purpose = "storage" } = req.body;
+    const pickerPurpose = purpose === "local-source" ? "local-source" : "storage";
+    const requestStartedAt = Date.now();
+    const startPath = await resolvePickerStartPath(defaultPath);
+    console.info(
+      `[onboarding] folder picker requested purpose=${pickerPurpose} start=${startPath ?? "system-default"}`
+    );
     try {
-      let folderPath;
-      const platform = process.platform;
-      if (platform === "darwin") {
-        const { stdout } = await execAsync(
-          `osascript -e 'POSIX path of (choose folder with prompt "Select a folder for your personal assistant context")'`
-        );
-        folderPath = stdout.trim();
-      } else if (platform === "linux") {
-        const { stdout } = await execAsync(
-          'zenity --file-selection --directory --title="Select storage folder"'
-        );
-        folderPath = stdout.trim();
-      } else if (platform === "win32") {
-        const ps = "[System.Reflection.Assembly]::LoadWithPartialName('System.windows.forms') | Out-Null; $f = New-Object System.Windows.Forms.FolderBrowserDialog; $f.Description = 'Select a folder for your personal assistant context'; $f.ShowDialog() | Out-Null; $f.SelectedPath";
-        const { stdout } = await execAsync(`powershell -command "${ps}"`);
-        folderPath = stdout.trim();
-      } else {
-        res.status(400).json({ error: "Folder picker not supported on this platform" });
-        return;
-      }
+      const folderPath = await openNativeFolderPicker(process.platform, pickerPurpose, startPath);
       if (!folderPath) {
-        res.json({ cancelled: true });
+        console.info(
+          `[onboarding] folder picker returned no path after ${Date.now() - requestStartedAt}ms`
+        );
+        res.json({ cancelled: true, durationMs: Date.now() - requestStartedAt });
         return;
       }
-      res.json({ path: folderPath });
+      console.info(
+        `[onboarding] folder picker resolved in ${Date.now() - requestStartedAt}ms path=${folderPath}`
+      );
+      res.json({ path: folderPath, durationMs: Date.now() - requestStartedAt });
     } catch (err) {
-      if (String(err).includes("User canceled") || String(err).includes("cancel")) {
-        res.json({ cancelled: true });
+      if (isPickerCancelledError(err)) {
+        console.info(
+          `[onboarding] folder picker cancelled after ${Date.now() - requestStartedAt}ms`
+        );
+        res.json({ cancelled: true, durationMs: Date.now() - requestStartedAt });
         return;
       }
-      res.status(500).json({ error: String(err) });
+      console.error("[onboarding] folder picker failed", err);
+      res.status(500).json({
+        error: err instanceof Error ? err.message : String(err),
+        durationMs: Date.now() - requestStartedAt
+      });
     }
   });
   app.post("/api/gdrive/auth-start", async (req, res) => {
@@ -823,12 +1299,12 @@ async function startOnboardingServer(port, workspacePath) {
 async function resolveOnboardingStaticPath() {
   const baseDir = import.meta.dirname ?? __dirname;
   const candidates = [
-    path.resolve(baseDir, "./onboarding-web"),
-    path.resolve(baseDir, "../../../apps/onboarding-web/dist")
+    path2.resolve(baseDir, "./onboarding-web"),
+    path2.resolve(baseDir, "../../../apps/onboarding-web/dist")
   ];
   for (const candidate of candidates) {
     try {
-      await fs.access(path.join(candidate, "index.html"));
+      await fs2.access(path2.join(candidate, "index.html"));
       return candidate;
     } catch {
     }
@@ -1035,11 +1511,11 @@ pacman daemon
 pacman slack listen
 
 # Use in Claude Code
-/personal-assistant start &lt;project&gt;
+/pacman start &lt;project&gt;
 
 # Use in Codex
-Ask Codex to load or refresh your Personal Assistant context for &lt;project&gt;</pre>
-        <p style="margin-top:1rem;color:#64748b;font-size:0.85rem;">Restart Claude Code or Codex after installing the MCP server.<br>If <code style="background:#1e293b;padding:0 4px;border-radius:3px;">pacman</code> is not found, link it first. The legacy alias <code style="background:#1e293b;padding:0 4px;border-radius:3px;">personal-assistant</code> also remains available:<br>
+Ask Codex to load or refresh your Pac-Man context for &lt;project&gt;</pre>
+        <p style="margin-top:1rem;color:#64748b;font-size:0.85rem;">Restart Claude Code or Codex after installing the MCP server.<br>If <code style="background:#1e293b;padding:0 4px;border-radius:3px;">pacman</code> is not found, link it first:<br>
         <code style="background:#1e293b;padding:2px 6px;border-radius:3px;">pnpm setup &amp;&amp; source ~/.zshrc &amp;&amp; cd packages/cli &amp;&amp; pnpm link --global</code></p>
       </div>
     </div>
@@ -1113,10 +1589,17 @@ Ask Codex to load or refresh your Personal Assistant context for &lt;project&gt;
 
     async function browseFolder() {
       const btn = document.getElementById('browseBtn');
-      btn.textContent = '\u2026';
+      btn.textContent = 'Opening...';
       btn.disabled = true;
       try {
-        const res = await fetch('/api/pick-folder');
+        const res = await fetch('/api/pick-folder', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            defaultPath: document.getElementById('localPath').value,
+            purpose: 'storage'
+          })
+        });
         const data = await res.json();
         if (!data.cancelled && data.path) {
           document.getElementById('localPath').value = data.path;