pi-project-switcher 0.5.0 → 0.7.0

package/README.md

@@ -4,12 +4,17 @@ A [pi coding agent](https://github.com/earendil-works/pi) extension to switch be
 
 ## What it does
 
-- **`/project`** — list all projects (direct subdirectories of the base dir) with git branch info, mark the active one
+- **`/project`** — list all projects (direct subdirectories of the base dir) with git branch info, mark the active one. The output adapts to the surface:
+  - **native TUI**: a selection dialog; picking a project switches to it (dismissing shows the plain list)
+  - **Telegram bridge**: the reply in the chat shows one tappable button per project; clicking a button is exactly like typing `/project <name>`
+  - **other surfaces** (rpc/json/print): plain text list
+  - Note: for the Telegram buttons to work, this extension must be loaded **before** `pi-telegram-command-bridge` (package order in `~/.pi/agent/settings.json`) — the switcher needs to see the raw `[telegram] /project` dispatch before the bridge re-dispatches it.
 - **`/project <name>`** — switch the active project:
   - restores the project's last session if one is stored (see below)
   - persists across reloads (session entry)
   - sets the session display name
   - injects the project path into every agent turn's system prompt, so file operations default to the active project
+  - **via the Telegram bridge**: the switch is confirmed in the chat — a short reply with the project, working directory, and session identity, plus buttons (project list, and switch back to the previous project). The confirmation is sent from the new session runtime, so it also works when the switch restores a stored session. No-switch outcomes (already active, cancelled, unknown) are answered in the chat too.
   - **if the project doesn't exist yet**, offers to create the folder and switch to it (confirmation dialog on dialog-capable surfaces; use `/project <name>!` to skip the dialog — e.g. on headless/RPC surfaces). Unsafe names (path segments, `..`, hidden, absolute) are never created.
 - **Session restore** — a machine-local map (`~/.pi/agent/project-switcher-sessions.json`) remembers the most recent session per project. Switching projects returns you to that project's last session; if none exists (or the file is gone), the switch happens in the current session.
 - **Auto-detection** — if pi starts inside `~/dev/<project>`, that project is active automatically
@@ -51,7 +56,7 @@ Single-file TypeScript extension (`index.ts`), loaded directly by pi via jiti
 
 ```bash
 npm install
-npm test        # vitest (17 tests)
+npm test        # vitest (45 tests)
 npm run typecheck
 
 # Run once without installing

package/index.ts

@@ -19,6 +19,7 @@
  */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { SessionManager } from "@earendil-works/pi-coding-agent";
 import { execSync } from "node:child_process";
 import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
@@ -173,6 +174,168 @@ function rememberSessionFile(project: string, absSessionFile: string): void {
 let activeProject: string | null = null;
 let config: Config | null = null;
 
+// ── Telegram origin detection (input event + flag) ───────────────────────────
+
+/**
+ * Matches a first line dispatched from the pi-telegram bridge: a
+ * `[telegram]` tag (optionally with attributes like `[telegram|thread:x]`)
+ * followed by a bare `/project` with no arguments.
+ */
+const TELEGRAM_STATUS_RE = /^\[telegram(?:\|[^\]]*)?\]\s*\/project\s*$/;
+
+/**
+ * Same, but for `/project <name>` (a switch). The command bridge strips
+ * the tag and re-dispatches the bare command line, so a Telegram-originated
+ * switch would otherwise be indistinguishable from a native invocation.
+ * Arguments are captured so the flag matches the command the user sent.
+ */
+const TELEGRAM_SWITCH_RE = /^\[telegram(?:\|[^\]]*)?\]\s*\/project\s+(\S.*)$/;
+
+/** How long an armed flag stays valid (ms). Guards against stale flags
+ *  from dispatches that never reached the command handler. */
+const TELEGRAM_FLAG_TTL_MS = 30_000;
+
+/** Armed-at timestamp of a pending Telegram-originated status request, or null. */
+let telegramStatusFlag: number | null = null;
+
+/** Armed-at timestamp of a pending Telegram-originated switch request, or null. */
+let telegramSwitchFlag: number | null = null;
+
+function armTelegramStatusFlag(): void {
+  telegramStatusFlag = Date.now();
+}
+
+/** Consume the flag: returns true (and clears it) when armed and not expired. */
+function consumeTelegramStatusFlag(): boolean {
+  if (telegramStatusFlag === null) return false;
+  const armed = telegramStatusFlag;
+  telegramStatusFlag = null;
+  return Date.now() - armed <= TELEGRAM_FLAG_TTL_MS;
+}
+
+function armTelegramSwitchFlag(): void {
+  telegramSwitchFlag = Date.now();
+}
+
+/** Consume the switch flag: returns true (and clears it) when armed and not expired. */
+function consumeTelegramSwitchFlag(): boolean {
+  if (telegramSwitchFlag === null) return false;
+  const armed = telegramSwitchFlag;
+  telegramSwitchFlag = null;
+  return Date.now() - armed <= TELEGRAM_FLAG_TTL_MS;
+}
+
+function clearTelegramStatusFlag(): void {
+  telegramStatusFlag = null;
+  telegramSwitchFlag = null;
+}
+
+/**
+ * A project name that could alter button markup or the button prompt is
+ * rendered as plain list text only (never gets a button cell).
+ */
+function isUnsafeButtonName(name: string): boolean {
+  return /[{}|`\\\n]/.test(name);
+}
+
+/**
+ * Build the follow-up prompt for a Telegram-originated status request.
+ * Embeds the authoritative project list and a pre-rendered telegram_button
+ * block the agent copies verbatim into its reply.
+ */
+function buildTelegramStatusPrompt(projects: string[]): string {
+  const ordered = [...projects];
+  if (activeProject) {
+    const idx = ordered.indexOf(activeProject);
+    if (idx > 0) {
+      ordered.splice(idx, 1);
+      ordered.unshift(activeProject);
+    } else if (idx === -1) {
+      ordered.unshift(activeProject);
+    }
+  }
+
+  const listLines = ordered
+    .map((p) => `  ${p}${p === activeProject ? " ◀ active" : ""}`)
+    .join("\n");
+
+  const buttonCells = ordered
+    .filter((p) => !isUnsafeButtonName(p))
+    .map((p) =>
+      p === activeProject
+        ? `{✅ ${p} (active)|/project ${p}}`
+        : `{📁 ${p}|/project ${p}}`,
+    )
+    .join("\n");
+  const buttonBlock =
+    buttonCells.length > 0
+      ? "\n\n```telegram_button\n" + buttonCells + "\n```"
+      : "";
+
+  const current = activeProject ? `Active: ${activeProject}` : "No project active";
+
+  return (
+    `[project-switcher] The user ran /project via Telegram and expects the project list in the chat.\n` +
+    `Authoritative list (do not re-derive, do not add or remove entries):\n` +
+    `${current}\n\n${listLines}\n\n` +
+    `Reply in the chat with exactly this list (keep the active marker) followed by the button block below, ` +
+    `copied verbatim. Do not run any command, do not switch projects yourself, and add nothing else.${buttonBlock}`
+  );
+}
+
+/**
+ * Build the follow-up prompt for a Telegram-originated project switch. The
+ * turn's reply is delivered to the Telegram chat as the visible confirmation
+ * that the switch succeeded (the local UI notification never reaches the
+ * phone). Facts are passed by the extension; the reply shape is prescribed
+ * so the model cannot invent outcomes. `sendFn` is passed in so both switch
+ * paths reuse this: the restore path must send from the fresh withSession
+ * context (never the stale pre-switch pi), the fallback path from the
+ * current runtime.
+ */
+function buildTelegramSwitchConfirmationPrompt(opts: {
+  project: string;
+  path: string;
+  branchStr: string;
+  sessionLine: string;
+  previous: string | null;
+}): string {
+  const { project, path, branchStr, sessionLine, previous } = opts;
+
+  const confirmLine = `✅ Switched to **${project}**${previous ? ` (was: ${previous})` : ""}`;
+  const infoLines = [confirmLine, `📁 ${path}${branchStr ? ` (${branchStr})` : ""}`, sessionLine].join("\n");
+
+  const cells: string[] = ["{📋 Projects|/project}"];
+  if (previous && !isUnsafeButtonName(previous) && previous !== project) {
+    cells.push(`{↩️ Back to ${previous}|/project ${previous}}`);
+  }
+  const buttonBlock =
+    cells.length > 0
+      ? "\n\n```telegram_button\n" + cells.join("\n") + "\n```"
+      : "";
+
+  return (
+    `[project-switcher] The user ran /project ${project} via Telegram and expects a confirmation that the switch succeeded.\n` +
+    `Authoritative switch facts (do not re-derive, do not run any command, do not switch projects yourself):\n` +
+    `${infoLines}\n\n` +
+    `Reply in the chat with exactly the lines above, followed by the button block below, copied verbatim. ` +
+    `Add nothing else.${buttonBlock}`
+  );
+}
+
+/**
+ * Short follow-up for Telegram-originated switch outcomes that changed
+ * nothing (already-active or cancelled): guarantees the chat still gets a
+ * visible reply instead of silence.
+ */
+function buildTelegramNoChangePrompt(text: string): string {
+  return (
+    `[project-switcher] The user ran /project via Telegram.\n` +
+    `Reply in the chat with exactly this line and nothing else: ${text}`
+  );
+}
+
+
 function getConfig(): Config {
   if (!config) {
     config = loadConfig();
@@ -209,9 +372,30 @@ function isSafeProjectName(name: string): boolean {
   return true;
 }
 
+/**
+ * Plain text project list via the local UI notification channel —
+ * the unchanged default output for non-Telegram surfaces.
+ */
+function notifyPlainProjectList(ctx: any, projects: string[]): void {
+  const current = activeProject ? `Active: ${activeProject}` : "No project active";
+  const lines = projects.map((p) => {
+    const branch = getGitBranch(projectPath(p));
+    const branchStr = branch ? ` [${branch}]` : "";
+    const marker = p === activeProject ? " ◀ active" : "";
+    return `  ${p}${branchStr}${marker}`;
+  });
+  ctx.ui.notify(
+    `${current}\n\nProjects under ${getConfig().baseDir}:\n${lines.join("\n")}`,
+    "info"
+  );
+}
+
 export default function (pi: ExtensionAPI) {
   // ── Restore state on session start ──────────────────────────────────────
   pi.on("session_start", async (_event, ctx) => {
+    // Session switches reset any pending Telegram status flag
+    clearTelegramStatusFlag();
+
     for (const entry of ctx.sessionManager.getEntries()) {
       if (
         entry.type === "custom" &&
@@ -244,6 +428,31 @@ export default function (pi: ExtensionAPI) {
     }
   });
 
+  // ── Telegram origin detection (input event) ────────────────────────────────
+  //
+  // Prompts dispatched from the pi-telegram queue arrive with source
+  // "extension" and a `[telegram]`-tagged first line, BEFORE the command
+  // bridge re-dispatches the bare command line. Recognizing the raw
+  // dispatch here is the only reliable origin signal; the re-dispatched
+  // text is indistinguishable from a native TUI invocation.
+  //
+  // Requires this extension to be listed BEFORE the command bridge in the
+  // package order (the bridge's "handled" result would short-circuit the
+  // input chain before this handler runs otherwise). Wrong order degrades
+  // gracefully: the flag is never armed and the status falls back to the
+  // plain list.
+  pi.on("input", async (event) => {
+    if (event.source !== "extension") return;
+    const firstLine = event.text.split("\n", 1)[0];
+    const trimmed = firstLine.trim();
+    if (TELEGRAM_STATUS_RE.test(trimmed)) {
+      armTelegramStatusFlag();
+    } else if (TELEGRAM_SWITCH_RE.test(trimmed)) {
+      armTelegramSwitchFlag();
+    }
+    // Never transform or handle: the command bridge owns the re-dispatch.
+  });
+
   // ── Inject project context into every agent turn ─────────────────────────
   pi.on("before_agent_start", async (event, _ctx) => {
     if (!activeProject || !isValidProject(activeProject)) {
@@ -262,6 +471,226 @@ export default function (pi: ExtensionAPI) {
     };
   });
 
+  // ── Shared switch flow ──────────────────────────────────────────────────
+  //
+  // Single implementation of /project <name> semantics, used by the typed
+  // argument path and the TUI selection dialog. `createOptIn` (trailing
+  // "!") only applies to the typed path; dialog users confirm interactively.
+  const switchToProject = async (rawName: string, ctx: any, createOptIn: boolean): Promise<void> => {
+    const name = rawName;
+    const isTelegramOrigin = consumeTelegramSwitchFlag();
+
+    if (!isValidProject(name)) {
+      // Offer to create the folder and switch to it (never silently)
+      if (isSafeProjectName(name)) {
+        let create = false;
+        if (createOptIn) {
+          create = true;
+        } else if (ctx.hasUI) {
+          try {
+            create = await ctx.ui.confirm(
+              "Create project?",
+              `Project "${name}" does not exist. Create ${join(getConfig().baseDir, name)} and switch to it?`
+            );
+          } catch {
+            create = false;
+          }
+        }
+
+        if (create) {
+          const newPath = projectPath(name);
+          try {
+            mkdirSync(newPath, { recursive: false });
+            ctx.ui.notify(`Created project folder: ${newPath}`, "info");
+          } catch (err: any) {
+            ctx.ui.notify(
+              `Failed to create project folder ${newPath}: ${err?.message ?? err}`,
+              "error"
+            );
+            return;
+          }
+          // fall through: the folder now exists and the switch proceeds below
+        }
+      }
+
+      if (!isValidProject(name)) {
+        const available = discoverProjects(getConfig().baseDir).join(", ");
+        ctx.ui.notify(
+          `Unknown project: "${name}".\nAvailable: ${available || "(none)"}`,
+          "warning"
+        );
+        if (isTelegramOrigin) {
+          await ctx.waitForIdle();
+          pi.sendUserMessage(
+            buildTelegramNoChangePrompt(`⚠️ Unknown project: ${name} — no switch performed.`),
+            { deliverAs: "followUp" }
+          );
+        }
+        return;
+      }
+    }
+
+    if (name === activeProject) {
+      ctx.ui.notify(`Already on project: ${name}`, "info");
+      if (isTelegramOrigin) {
+        await ctx.waitForIdle();
+        pi.sendUserMessage(buildTelegramNoChangePrompt(`ℹ️ Already on project: **${name}**`), {
+          deliverAs: "followUp",
+        });
+      }
+      return;
+    }
+
+    const previous = activeProject;
+
+    // Remember the current session under the PREVIOUS project before switching
+    const currentSessionFile = ctx.sessionManager.getSessionFile();
+    if (previous && currentSessionFile) {
+      rememberSessionFile(previous, currentSessionFile);
+    }
+
+    // Try to restore the target project's last session
+    const targetSession = getMappedSessionFile(name);
+
+    if (targetSession) {
+      // Pre-write the switch state INTO THE TARGET session file so the
+      // fresh runtime's session_start restores the right project. Writing
+      // it to the current (old) session instead would leave the target
+      // session's own (stale) project entry authoritative.
+      // SessionManager.open() advances the target file's leaf to this entry.
+      // The same entry must also exist in the old session so a later switch
+      // BACK to the previous project still restores it (the old session is
+      // remembered under the previous project below).
+      try {
+        SessionManager.open(targetSession).appendCustomEntry(ENTRY_TYPE, {
+          project: name,
+          switchedAt: new Date().toISOString(),
+        });
+      } catch (err: any) {
+        ctx.ui.notify(
+          `Could not persist switch state to target session: ${err?.message ?? err}`,
+          "warning"
+        );
+      }
+
+      // Persist the switch in the OLD session too (for switching back later).
+      // Still valid: the old runtime has not been invalidated yet.
+      try {
+        pi.appendEntry(ENTRY_TYPE, { project: name, switchedAt: new Date().toISOString() });
+      } catch {
+        // Non-fatal: the target-session entry above is the authoritative one.
+      }
+
+      // Everything after ctx.switchSession() must run in withSession: the
+      // captured `pi` and command `ctx` are stale once the session is
+      // replaced, and using them throws (previously crashed the command
+      // with "stale ctx" errors and killed the whole flow).
+      const branch = getGitBranch(projectPath(name));
+      const branchStr = branch ? ` on branch \`${branch}\`` : "";
+      const result = await ctx.switchSession(targetSession, {
+        withSession: async (newCtx: any) => {
+          // Safety net in case the restored session has no project entry:
+          // session_start has already run for the new runtime; if it
+          // restored a different project from a stale entry, the pre-written
+          // entry above is the LAST project-switcher-state entry in the file
+          // and therefore authoritative — set the in-memory state explicitly.
+          activeProject = name;
+          newCtx.ui.notify(
+            `Switched to ${name} — session restored: ${basename(targetSession)}\n` +
+            `Workdir: ${projectPath(name)}${branchStr ? ` ${branchStr}` : ""}`,
+            "info"
+          );
+          if (isTelegramOrigin) {
+            // Confirmation turn from the FRESH runtime: the reply reaches
+            // the Telegram chat (the local notify above never does). Only
+            // the new context is touched — the pre-switch pi/ctx are stale.
+            // The turn also settles pi-telegram's dispatch queue.
+            await newCtx.waitForIdle();
+            await newCtx.sendUserMessage(
+              buildTelegramSwitchConfirmationPrompt({
+                project: name,
+                path: projectPath(name),
+                branchStr,
+                sessionLine: `🗂 Session restored: ${basename(targetSession)}`,
+                previous,
+              }),
+              { deliverAs: "followUp" }
+            );
+          }
+        },
+      });
+      if (result.cancelled) {
+        // User cancelled; roll back in-memory state. The pre-written target
+        // entry is harmless: it only records that a switch to `name` was
+        // attempted; an explicit later status/switch overrides it.
+        activeProject = previous;
+        ctx.ui.notify(`Switch cancelled. Staying on ${previous ?? "no project"}.`, "info");
+        if (isTelegramOrigin) {
+          await ctx.waitForIdle();
+          pi.sendUserMessage(
+            buildTelegramNoChangePrompt(
+              `⚠️ Switch to ${name} cancelled — staying on ${previous ?? "no project"}.`
+            ),
+            { deliverAs: "followUp" }
+          );
+        }
+        return;
+      }
+
+      // Remember the mapping AFTER a successful switch (withSession has
+      // already run). rememberSessionFile only touches the JSON map on
+      // disk, so calling it here is safe.
+      rememberSessionFile(name, targetSession);
+      return;
+    }
+
+    // ── Fallback: no stored session (or file gone) -> same-session switch ─
+    activeProject = name;
+
+    // Persist to session
+    pi.appendEntry(ENTRY_TYPE, { project: name, switchedAt: new Date().toISOString() });
+
+    // Update session name
+    pi.setSessionName(name);
+
+    const path = projectPath(name);
+    const branch = getGitBranch(path);
+    const branchStr = branch ? ` on branch \`${branch}\`` : "";
+    const fromStr = previous ? ` (was: ${previous})` : "";
+
+    // Current session identity — still valid on this path (no session replacement)
+    const currentFile = currentSessionFile ?? ctx.sessionManager.getSessionFile();
+    const sessionLine = currentFile
+      ? `Continuing session: ${basename(currentFile)}`
+      : "Continuing current session";
+
+    ctx.ui.notify(
+      `Switched to ${name}${fromStr} — first session in this project\n` +
+      `Workdir: ${path}${branchStr ? ` ${branchStr}` : ""}\n` +
+      sessionLine,
+      "info"
+    );
+
+    // Announce to the agent so it operates in the new context — or, for a
+    // Telegram-originated switch, send the chat-visible confirmation turn
+    // (it doubles as the agent context announcement).
+    await ctx.waitForIdle();
+    pi.sendUserMessage(
+      isTelegramOrigin
+        ? buildTelegramSwitchConfirmationPrompt({
+            project: name,
+            path,
+            branchStr,
+            sessionLine: `🗂 First session in this project (${sessionLine})`,
+            previous,
+          })
+        : `[Project switched to **${name}**]\n` +
+          `Working directory: \`${path}\`${branchStr}\n` +
+          `Please keep all file operations within this project from now on.`,
+      { deliverAs: "followUp" }
+    );
+  };
+
   // ── /project command ─────────────────────────────────────────────────────
   pi.registerCommand("project", {
     description: "Show or switch active project (/project [name])",
@@ -283,7 +712,7 @@ export default function (pi: ExtensionAPI) {
         name = name.slice(0, -1).trim();
       }
 
-      // ── No arg: show status ──────────────────────────────────────────────
+      // ── No arg: surface-adaptive status ──────────────────────────────────
       if (!name) {
         const projects = discoverProjects(getConfig().baseDir);
         if (projects.length === 0) {
@@ -293,142 +722,41 @@ export default function (pi: ExtensionAPI) {
           );
           return;
         }
-        const current = activeProject ? `Active: ${activeProject}` : "No project active";
-        const lines = projects.map((p) => {
-          const branch = getGitBranch(projectPath(p));
-          const branchStr = branch ? ` [${branch}]` : "";
-          const marker = p === activeProject ? " ◀ active" : "";
-          return `  ${p}${branchStr}${marker}`;
-        });
-        ctx.ui.notify(`${current}\n\nProjects under ${getConfig().baseDir}:\n${lines.join("\n")}`, "info");
-        return;
-      }
-
-      // ── Switch project ────────────────────────────────────────────────────
-      if (!isValidProject(name)) {
-        // Offer to create the folder and switch to it (never silently)
-        if (isSafeProjectName(name)) {
-          let create = false;
-          if (createOptIn) {
-            create = true;
-          } else if (ctx.hasUI) {
-            try {
-              create = await ctx.ui.confirm(
-                "Create project?",
-                `Project "${name}" does not exist. Create ${join(getConfig().baseDir, name)} and switch to it?`
-              );
-            } catch {
-              create = false;
-            }
-          }
-
-          if (create) {
-            const newPath = projectPath(name);
-            try {
-              mkdirSync(newPath, { recursive: false });
-              ctx.ui.notify(`Created project folder: ${newPath}`, "info");
-            } catch (err: any) {
-              ctx.ui.notify(
-                `Failed to create project folder ${newPath}: ${err?.message ?? err}`,
-                "error"
-              );
-              return;
-            }
-            // fall through: the folder now exists and the switch proceeds below
-          }
-        }
 
-        if (!isValidProject(name)) {
-          const available = discoverProjects(getConfig().baseDir).join(", ");
-          ctx.ui.notify(
-            `Unknown project: "${name}".\nAvailable: ${available || "(none)"}`,
-            "warning"
-          );
+        const isTelegramOrigin = consumeTelegramStatusFlag();
+
+        if (isTelegramOrigin) {
+          // Plain list for the local surface (parity with today) …
+          notifyPlainProjectList(ctx, projects);
+          // … then a follow-up turn whose reply reaches the Telegram chat,
+          // with one button per project. The turn also settles the command
+          // bridge's pending dispatch (its agent_start hook clears the
+          // pending settle entry first).
+          await ctx.waitForIdle();
+          pi.sendUserMessage(buildTelegramStatusPrompt(projects), {
+            deliverAs: "followUp",
+          });
           return;
         }
-      }
-
-      if (name === activeProject) {
-        ctx.ui.notify(`Already on project: ${name}`, "info");
-        return;
-      }
-
-      const previous = activeProject;
 
-      // Remember the current session under the PREVIOUS project before switching
-      const currentSessionFile = ctx.sessionManager.getSessionFile();
-      if (previous && currentSessionFile) {
-        rememberSessionFile(previous, currentSessionFile);
-      }
-
-      // Try to restore the target project's last session
-      const targetSession = getMappedSessionFile(name);
-
-      if (targetSession) {
-        // Persist the switch in the OLD session before replacing it
-        pi.appendEntry(ENTRY_TYPE, { project: name, switchedAt: new Date().toISOString() });
-
-        const result = await ctx.switchSession(targetSession);
-        if (result.cancelled) {
-          // User cancelled; roll back in-memory state
-          activeProject = previous;
-          ctx.ui.notify(`Switch cancelled. Staying on ${previous ?? "no project"}.`, "info");
+        if (ctx.mode === "tui") {
+          // Selection dialog; dismissing falls back to the plain list.
+          const choice = await ctx.ui.select("Switch project", projects);
+          if (choice !== undefined) {
+            await switchToProject(choice, ctx, false);
+            return;
+          }
+          notifyPlainProjectList(ctx, projects);
           return;
         }
 
-        // switchSession fires a new session_start, which restores state from
-        // the target session's entries (or auto-detects). Set it explicitly as
-        // a safety net in case the session has no project entry yet.
-        activeProject = name;
-        pi.setSessionName(name);
-        rememberSessionFile(name, targetSession);
-
-        const path = projectPath(name);
-        const branch = getGitBranch(path);
-        const branchStr = branch ? ` on branch \`${branch}\`` : "";
-        ctx.ui.notify(
-          `Switched to ${name} — session restored: ${basename(targetSession)}\n` +
-          `Workdir: ${path}${branchStr ? ` ${branchStr}` : ""}`,
-          "info"
-        );
+        // rpc/json/print and any other surface: unchanged plain list
+        notifyPlainProjectList(ctx, projects);
         return;
       }
 
-      // ── Fallback: no stored session (or file gone) -> same-session switch ─
-      activeProject = name;
-
-      // Persist to session
-      pi.appendEntry(ENTRY_TYPE, { project: name, switchedAt: new Date().toISOString() });
-
-      // Update session name
-      pi.setSessionName(name);
-
-      const path = projectPath(name);
-      const branch = getGitBranch(path);
-      const branchStr = branch ? ` on branch \`${branch}\`` : "";
-      const fromStr = previous ? ` (was: ${previous})` : "";
-
-      // Current session identity — still valid on this path (no session replacement)
-      const currentFile = currentSessionFile ?? ctx.sessionManager.getSessionFile();
-      const sessionLine = currentFile
-        ? `Continuing session: ${basename(currentFile)}`
-        : "Continuing current session";
-
-      ctx.ui.notify(
-        `Switched to ${name}${fromStr} — first session in this project\n` +
-        `Workdir: ${path}${branchStr ? ` ${branchStr}` : ""}\n` +
-        sessionLine,
-        "info"
-      );
-
-      // Announce to the agent so it operates in the new context
-      await ctx.waitForIdle();
-      pi.sendUserMessage(
-        `[Project switched to **${name}**]\n` +
-          `Working directory: \`${path}\`${branchStr}\n` +
-          `Please keep all file operations within this project from now on.`,
-        { deliverAs: "followUp" }
-      );
+      // ── Switch project ────────────────────────────────────────────────────
+      await switchToProject(name, ctx, createOptIn);
     },
   });
 }

package/package.json

@@ -1 +1 @@
-{"name": "pi-project-switcher", "version": "0.5.0", "description": "pi coding agent extension: switch between projects under a configurable base directory via /project", "main": "index.ts", "type": "module", "scripts": {"test": "vitest run", "test:watch": "vitest", "typecheck": "tsc --noEmit"}, "keywords": ["pi", "pi-package", "pi-extension", "project", "switcher", "project-switching"], "author": "stefclawd", "license": "MIT", "repository": {"type": "git", "url": "git+https://github.com/stefclawd/pi-project-switcher.git"}, "bugs": {"url": "https://github.com/stefclawd/pi-project-switcher/issues"}, "homepage": "https://github.com/stefclawd/pi-project-switcher#readme", "files": ["index.ts", "README.md", "LICENSE"], "engines": {"node": ">=22.19.0"}, "pi": {"extensions": ["./index.ts"]}, "devDependencies": {"@earendil-works/pi-coding-agent": "^0.85.1", "@types/node": "^24.0.0", "typescript": "^5.7.0", "vitest": "^3.0.0"}}
+{"name": "pi-project-switcher", "version": "0.7.0", "description": "pi coding agent extension: switch between projects under a configurable base directory via /project", "main": "index.ts", "type": "module", "scripts": {"test": "vitest run", "test:watch": "vitest", "typecheck": "tsc --noEmit"}, "keywords": ["pi", "pi-package", "pi-extension", "project", "switcher", "project-switching"], "author": "stefclawd", "license": "MIT", "repository": {"type": "git", "url": "git+https://github.com/stefclawd/pi-project-switcher.git"}, "bugs": {"url": "https://github.com/stefclawd/pi-project-switcher/issues"}, "homepage": "https://github.com/stefclawd/pi-project-switcher#readme", "files": ["index.ts", "README.md", "LICENSE"], "engines": {"node": ">=22.19.0"}, "pi": {"extensions": ["./index.ts"]}, "devDependencies": {"@earendil-works/pi-coding-agent": "^0.85.1", "@types/node": "^24.0.0", "typescript": "^5.7.0", "vitest": "^3.0.0"}}