wispy-cli 2.6.2 → 2.7.0

package/bin/wispy.mjs

@@ -820,15 +820,60 @@ if (args[0] === "model") {
   const config = await loadConfig();
   const configuredProviders = config.providers ? Object.keys(config.providers) : (config.provider ? [config.provider] : []);
 
-  // wispy model (no args) — show current
+  // wispy model (no args) — interactive menu
   if (!sub) {
     const defaultP = config.defaultProvider ?? configuredProviders[0];
     const currentModel = config.providers?.[defaultP]?.model ?? config.model ?? PROVIDERS[defaultP]?.defaultModel ?? "unknown";
     console.log(`\n🤖 ${_bold("Current model")}: ${_cyan(defaultP)}:${_bold(currentModel)}\n`);
-    if (configuredProviders.length > 1) {
-      console.log(`  Configured providers: ${configuredProviders.join(", ")}`);
-      console.log(`  ${_dim("Use 'wispy model list' to see all options")}`);
-      console.log(`  ${_dim("Use 'wispy model set <provider:model>' to switch")}\n`);
+
+    try {
+      const { select } = await import("@inquirer/prompts");
+
+      // Build choices from configured providers only
+      const modelChoices = [];
+      for (const p of configuredProviders) {
+        const models = KNOWN_MODELS[p] ?? [];
+        for (const m of models) {
+          const cur = config.providers?.[p]?.model ?? PROVIDERS[p]?.defaultModel;
+          modelChoices.push({
+            name: `${m} (${p})${cur === m ? _dim(" ✓ current") : ""}`,
+            value: `${p}:${m}`,
+            short: `${p}:${m}`,
+          });
+        }
+      }
+
+      if (modelChoices.length === 0) {
+        console.log(_dim("  No models available. Run 'wispy setup' to configure a provider.\n"));
+        process.exit(0);
+      }
+
+      let modelChoice;
+      try {
+        modelChoice = await select({ message: "Switch model:", choices: modelChoices });
+      } catch (e) {
+        if (e.name === "ExitPromptError") { process.exit(130); }
+        throw e;
+      }
+
+      const colonIdx = modelChoice.indexOf(":");
+      const provName = modelChoice.slice(0, colonIdx);
+      const modelName = modelChoice.slice(colonIdx + 1);
+
+      if (!config.providers) config.providers = {};
+      if (!config.providers[provName]) config.providers[provName] = {};
+      config.providers[provName].model = modelName;
+      if (!config.defaultProvider) config.defaultProvider = provName;
+      await saveConfig(config);
+      console.log(_green(`\n✅ Switched to ${_cyan(provName)}:${_bold(modelName)}\n`));
+    } catch (e) {
+      if (e.name === "ExitPromptError") { process.exit(130); }
+      // Fallback — just show current
+      if (configuredProviders.length > 1) {
+        console.log(`  Configured providers: ${configuredProviders.join(", ")}`);
+        console.log(`  ${_dim("Use 'wispy model list' to see all options")}`);
+        console.log(`  ${_dim("Use 'wispy model set <provider:model>' to switch")}\n`);
+      }
     }
     process.exit(0);
   }
@@ -890,18 +935,66 @@ if (args[0] === "config") {
   const config = await loadConfig();
 
   if (!sub || sub === "show") {
-    // wispy config — show current config (mask secrets)
-    const display = JSON.parse(JSON.stringify(config));
-    // Mask API keys
-    if (display.providers) {
-      for (const [k, v] of Object.entries(display.providers)) {
-        if (v.apiKey) v.apiKey = v.apiKey.slice(0, 6) + "..." + v.apiKey.slice(-4);
+    // wispy config — interactive config menu
+    const { select: cfgSelect } = await import("@inquirer/prompts");
+
+    // Show current status first
+    const providers = config.providers ? Object.keys(config.providers) : (config.provider ? [config.provider] : []);
+    const providerStr = providers.length > 0 ? providers.join(", ") : _dim("not set");
+    const defaultProv = config.defaultProvider ?? config.provider ?? _dim("not set");
+    const security = config.security ?? config.securityLevel ?? _dim("not set");
+    const language = config.language ?? _dim("auto");
+    const wsName = config.workstream ?? "default";
+
+    console.log(`\n${_bold("Wispy Config")}\n`);
+    console.log(`  Providers:    ${providerStr}`);
+    console.log(`  Default:      ${defaultProv}`);
+    console.log(`  Security:     ${security}`);
+    console.log(`  Language:     ${language}`);
+    console.log(`  Workstream:   ${wsName}`);
+    console.log(`  Config file:  ${_dim(CONFIG_PATH)}`);
+    console.log("");
+
+    const action = await cfgSelect({
+      message: "What do you want to change?",
+      choices: [
+        { name: "Providers — add/remove AI providers", value: "provider" },
+        { name: "Security — change trust level", value: "security" },
+        { name: "Language — set preferred language", value: "language" },
+        { name: "Channels — configure messaging bots", value: "channels" },
+        { name: "Server — cloud/server settings", value: "server" },
+        { name: "View raw config (JSON)", value: "raw" },
+        { name: "Reset everything", value: "reset" },
+        { name: "Done", value: "done" },
+      ],
+    });
+
+    if (action === "done") {
+      process.exit(0);
+    } else if (action === "raw") {
+      const display = JSON.parse(JSON.stringify(config));
+      if (display.providers) {
+        for (const [k, v] of Object.entries(display.providers)) {
+          if (v.apiKey) v.apiKey = v.apiKey.slice(0, 6) + "..." + v.apiKey.slice(-4);
+        }
       }
+      console.log(JSON.stringify(display, null, 2));
+    } else if (action === "reset") {
+      const { confirm: cfgConfirm } = await import("@inquirer/prompts");
+      const yes = await cfgConfirm({ message: "Reset all configuration?", default: false });
+      if (yes) {
+        const { writeFile: wf } = await import("node:fs/promises");
+        await wf(CONFIG_PATH, "{}\n");
+        console.log(`${_green("✓")} Config reset. Run 'wispy setup' to reconfigure.`);
+      }
+    } else {
+      // Delegate to setup wizard step
+      const { OnboardingWizard } = await import(
+        path.join(__dirname, "..", "core", "onboarding.mjs")
+      );
+      const wizard = new OnboardingWizard();
+      await wizard.runStep(action);
     }
-    if (display.apiKey) display.apiKey = display.apiKey.slice(0, 6) + "..." + display.apiKey.slice(-4);
-    console.log(`\n${_bold("Wispy Config")}  ${_dim(CONFIG_PATH)}\n`);
-    console.log(JSON.stringify(display, null, 2));
-    console.log("");
 
   } else if (sub === "get") {
     // wispy config get <key>
@@ -1128,6 +1221,54 @@ if (args[0] === "sync") {
   const bold   = (s) => `\x1b[1m${s}\x1b[0m`;
   const dim    = (s) => `\x1b[2m${s}\x1b[0m`;
 
+  // Interactive sync menu when no subcommand
+  if (!sub) {
+    try {
+      const { select, Separator } = await import("@inquirer/prompts");
+      const cfg = await SyncManager.loadConfig();
+      const remoteUrl = cfg.remoteUrl;
+
+      if (!remoteUrl) {
+        console.log(_dim("\nNo remote configured. Connect first: wispy connect <url>\n"));
+        process.exit(0);
+      }
+
+      console.log(`\nRemote: ${_cyan(remoteUrl)} ✓\n`);
+
+      let syncAction;
+      try {
+        syncAction = await select({
+          message: "Sync actions:",
+          choices: [
+            { name: "Sync now (bidirectional)", value: "sync" },
+            { name: "Push local → remote", value: "push" },
+            { name: "Pull remote → local", value: "pull" },
+            { name: "View what would sync (status)", value: "status" },
+            { name: "Enable auto-sync", value: "auto" },
+            { name: "Disconnect remote", value: "disconnect" },
+          ],
+        });
+      } catch (e) {
+        if (e.name === "ExitPromptError") { process.exit(130); }
+        throw e;
+      }
+
+      if (["sync", "push", "pull", "status", "auto"].includes(syncAction)) {
+        args[1] = syncAction;
+      } else if (syncAction === "disconnect") {
+        const { confirm } = await import("@inquirer/prompts");
+        let ok;
+        try { ok = await confirm({ message: "Disconnect remote?", default: false }); }
+        catch (e) { if (e.name === "ExitPromptError") { process.exit(130); } throw e; }
+        if (ok) { await SyncManager.disableAuto?.(); console.log(_dim("Remote disconnected.")); }
+        process.exit(0);
+      }
+    } catch (e) {
+      if (e.name === "ExitPromptError") { process.exit(130); }
+      // Fall through
+    }
+  }
+
   // Parse flags
   const strategyIdx = args.indexOf("--strategy");
   const strategy = strategyIdx !== -1 ? args[strategyIdx + 1] : null;
@@ -1256,6 +1397,93 @@ if (args[0] === "deploy") {
   const bold = (s) => `\x1b[1m${s}\x1b[0m`;
   const cyan = (s) => `\x1b[36m${s}\x1b[0m`;
 
+  if (!sub) {
+    // Interactive deploy menu
+    try {
+      const { select, Separator } = await import("@inquirer/prompts");
+      let deployTarget;
+      try {
+        deployTarget = await select({
+          message: "Deploy wispy to:",
+          choices: [
+            { name: "VPS (SSH + systemd)", value: "vps" },
+            { name: "Docker (Dockerfile + compose)", value: "docker" },
+            { name: "Railway", value: "railway" },
+            { name: "Fly.io", value: "fly" },
+            { name: "Render", value: "render" },
+            { name: "Modal (serverless)", value: "modal" },
+            { name: "Daytona", value: "daytona" },
+            new Separator("──────────"),
+            { name: "Generate all configs (deploy init)", value: "init" },
+            { name: "Check remote status", value: "status-check" },
+          ],
+        });
+      } catch (e) {
+        if (e.name === "ExitPromptError") { process.exit(130); }
+        throw e;
+      }
+
+      if (deployTarget === "vps") {
+        const { input } = await import("@inquirer/prompts");
+        let target;
+        try { target = await input({ message: "SSH target (user@host):" }); }
+        catch (e) { if (e.name === "ExitPromptError") { process.exit(130); } throw e; }
+        if (target && target.trim()) {
+          try { await dm.deployVPS({ target: target.trim() }); }
+          catch (err) { console.error(_red(`\n❌ Deploy failed: ${err.message}`)); process.exit(1); }
+        }
+      } else if (deployTarget === "docker") {
+        const created = await dm.init(process.cwd());
+        for (const f of created) console.log(`  ${f.includes("skipped") ? "⏭️ " : "✅"} ${f}`);
+        console.log(_dim("\n  Next: docker-compose up -d\n"));
+      } else if (deployTarget === "railway") {
+        process.stdout.write(dm.generateRailwayConfig() + "\n");
+      } else if (deployTarget === "fly") {
+        process.stdout.write(dm.generateFlyConfig());
+      } else if (deployTarget === "render") {
+        process.stdout.write(dm.generateRenderConfig());
+      } else if (deployTarget === "modal") {
+        process.stdout.write(dm.generateModalConfig());
+      } else if (deployTarget === "daytona") {
+        const { mkdir: mkdDir, writeFile: wfDir } = await import("node:fs/promises");
+        const daytonaDir = path.join(process.cwd(), ".daytona");
+        await mkdDir(daytonaDir, { recursive: true });
+        const daytonaConfigPath = path.join(daytonaDir, "config.yaml");
+        let exists = false;
+        try { await (await import("node:fs/promises")).access(daytonaConfigPath); exists = true; } catch {}
+        if (!exists) {
+          await wfDir(daytonaConfigPath, dm.generateDaytonaConfig(), "utf8");
+          console.log(_green(`✅ Created .daytona/config.yaml`));
+        } else {
+          console.log(_yellow(`⏭️  .daytona/config.yaml already exists`));
+        }
+      } else if (deployTarget === "init") {
+        console.log("\n🌿 Initializing wispy deploy configs...\n");
+        const created = await dm.init(process.cwd());
+        for (const f of created) console.log(`  ${f.includes("skipped") ? "⏭️ " : "✅"} ${f}`);
+      } else if (deployTarget === "status-check") {
+        const { input } = await import("@inquirer/prompts");
+        let url;
+        try { url = await input({ message: "Remote URL to check:" }); }
+        catch (e) { if (e.name === "ExitPromptError") { process.exit(130); } throw e; }
+        if (url && url.trim()) {
+          process.stdout.write(`\n📡 Checking ${_cyan(url.trim())}... `);
+          const status = await dm.checkRemote(url.trim());
+          if (status.alive) {
+            console.log(_green("✓ alive"));
+            if (status.version) console.log(`   Version: ${status.version}`);
+          } else {
+            console.log(_red("✗ unreachable"));
+          }
+        }
+      }
+      process.exit(0);
+    } catch (e) {
+      if (e.name === "ExitPromptError") { process.exit(130); }
+      // Fall through to help
+    }
+  }
+
   if (sub === "dockerfile") {
     process.stdout.write(dm.generateDockerfile());
     process.exit(0);
@@ -1399,7 +1627,56 @@ if (args[0] === "migrate") {
   const dim    = (s) => `\x1b[2m${s}\x1b[0m`;
   const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
 
-  if (!sub || sub === "openclaw") {
+  if (!sub) {
+    // Interactive migrate menu
+    try {
+      const { select } = await import("@inquirer/prompts");
+      const { homedir } = await import("node:os");
+      const { existsSync } = await import("node:fs");
+      const { join } = await import("node:path");
+
+      const hasOpenClaw = existsSync(join(homedir(), ".openclaw"));
+      const choices = [
+        {
+          name: `OpenClaw${hasOpenClaw ? green(" (detected at ~/.openclaw)") : dim(" (not found)")}`,
+          value: "openclaw",
+        },
+        { name: "Hermes Agent", value: "hermes" },
+        { name: "Manual import (JSON/YAML)", value: "manual" },
+      ];
+
+      let migrateFrom;
+      try {
+        migrateFrom = await select({ message: "Migrate from:", choices });
+      } catch (e) {
+        if (e.name === "ExitPromptError") { process.exit(130); }
+        throw e;
+      }
+
+      if (migrateFrom === "openclaw") {
+        args[1] = "openclaw";
+        // Fall through
+      } else if (migrateFrom === "hermes") {
+        console.log(dim("\nHermes migration coming soon. Use manual import for now.\n"));
+        process.exit(0);
+      } else if (migrateFrom === "manual") {
+        const { input } = await import("@inquirer/prompts");
+        let filePath;
+        try { filePath = await input({ message: "Path to JSON/YAML file:" }); }
+        catch (e) { if (e.name === "ExitPromptError") { process.exit(130); } throw e; }
+        console.log(dim(`\nManual import from ${filePath} — coming soon.\n`));
+        process.exit(0);
+      }
+    } catch (e) {
+      if (e.name === "ExitPromptError") { process.exit(130); }
+      args[1] = "openclaw";
+    }
+  }
+
+  const sub2 = args[1]; // re-read after interactive
+
+  if (!sub || sub === "openclaw" || sub2 === "openclaw") {
+    const subToUse = sub || sub2;
     console.log(`\n🌿 ${bold("Wispy Migration Tool")} ${dim("— from OpenClaw")}\n`);
     if (dryRun) console.log(yellow("  [DRY RUN — no files will be written]\n"));
     if (memoryOnly) console.log(dim("  [memory-only mode]\n"));
@@ -1459,6 +1736,108 @@ if (args[0] === "cron") {
   const cron = new CronManager(WISPY_DIR, engine);
   await cron.init();
 
+  if (!sub) {
+    // Interactive cron menu
+    try {
+      const { select, Separator } = await import("@inquirer/prompts");
+      const jobs = cron.list();
+
+      const choices = [];
+      if (jobs.length === 0) {
+        choices.push(new Separator(_dim("No jobs configured.")));
+      } else {
+        for (const j of jobs) {
+          const schedStr = j.schedule.kind === "cron" ? j.schedule.expr
+            : j.schedule.kind === "every" ? `every ${j.schedule.ms / 60000}min`
+            : `at ${j.schedule.time}`;
+          const lastRun = j.lastRun ? `last: ${_dim(formatCronRelative(j.lastRun))} ✓` : _dim("never run");
+          choices.push({
+            name: `${j.name} — ${schedStr} — ${lastRun}`,
+            value: { type: "job", id: j.id, name: j.name },
+            short: j.name,
+          });
+        }
+      }
+      choices.push(new Separator("──────────"));
+      choices.push({ name: "Add a new job", value: { type: "add" } });
+      choices.push({ name: "Start scheduler", value: { type: "start" } });
+
+      function formatCronRelative(ts) {
+        if (!ts) return "never";
+        const diffMs = Date.now() - new Date(ts).getTime();
+        const diffMin = Math.floor(diffMs / 60000);
+        const diffH = Math.floor(diffMin / 60);
+        if (diffMin < 1) return "just now";
+        if (diffMin < 60) return `${diffMin}min ago`;
+        if (diffH < 24) return `${diffH}hr ago`;
+        return `${Math.floor(diffH / 24)}d ago`;
+      }
+
+      let answer;
+      try {
+        answer = await select({ message: "Cron jobs:", choices });
+      } catch (e) {
+        if (e.name === "ExitPromptError") { engine.destroy?.(); process.exit(130); }
+        throw e;
+      }
+
+      if (answer.type === "add") {
+        // fall through to the "add" sub-command handler below
+        args[1] = "add";
+      } else if (answer.type === "start") {
+        args[1] = "start";
+      } else if (answer.type === "job") {
+        // Job sub-menu
+        let jobAction;
+        try {
+          jobAction = await select({
+            message: `${answer.name}:`,
+            choices: [
+              { name: "Run now", value: "run" },
+              { name: "Edit (not yet implemented)", value: "edit" },
+              { name: "Remove", value: "remove" },
+              { name: "View history", value: "history" },
+            ],
+          });
+        } catch (e) {
+          if (e.name === "ExitPromptError") { engine.destroy?.(); process.exit(130); }
+          throw e;
+        }
+        if (jobAction === "run") {
+          console.log(`🌿 Running job: ${answer.name}...`);
+          const result = await cron.runNow(answer.id);
+          console.log(result.output ?? result.error);
+        } else if (jobAction === "remove") {
+          const { confirm } = await import("@inquirer/prompts");
+          let ok;
+          try { ok = await confirm({ message: `Remove job '${answer.name}'?`, default: false }); }
+          catch (e) { if (e.name === "ExitPromptError") { engine.destroy?.(); process.exit(130); } throw e; }
+          if (ok) {
+            await cron.remove(answer.id);
+            console.log(_green(`✅ Removed job: ${answer.name}`));
+          }
+        } else if (jobAction === "history") {
+          const history = await cron.getHistory(answer.id);
+          console.log(`\n📋 History for "${answer.name}" (last ${history.length} runs):\n`);
+          for (const h of history) {
+            const icon = h.status === "success" ? "✅" : "❌";
+            console.log(`  ${icon} ${new Date(h.startedAt).toLocaleString()}`);
+            console.log(`     ${h.output?.slice(0, 100) ?? h.error ?? ""}`);
+          }
+          if (history.length === 0) console.log("  No runs yet.");
+        } else if (jobAction === "edit") {
+          console.log(_dim("Edit via: wispy cron add (then remove the old one)"));
+        }
+        engine.destroy?.();
+        process.exit(0);
+      }
+    } catch (e) {
+      if (e.name === "ExitPromptError") { engine.destroy?.(); process.exit(130); }
+      // Fallback to list
+      args[1] = "list";
+    }
+  }
+
   if (!sub || sub === "list") {
     const jobs = cron.list();
     if (jobs.length === 0) {
@@ -1605,6 +1984,68 @@ if (args[0] === "audit" || args[0] === "log") {
   const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
   const red = (s) => `\x1b[31m${s}\x1b[0m`;
 
+  // Interactive audit menu when no subcommand
+  if (!sub) {
+    try {
+      const { select } = await import("@inquirer/prompts");
+      let auditAction;
+      try {
+        auditAction = await select({
+          message: "Audit log:",
+          choices: [
+            { name: "View recent events", value: "recent" },
+            { name: "Filter by tool", value: "by-tool" },
+            { name: "Filter by session", value: "by-session" },
+            { name: "Today's events only", value: "today" },
+            { name: "Replay a session", value: "replay" },
+            { name: "Export as markdown", value: "export-md" },
+          ],
+        });
+      } catch (e) {
+        if (e.name === "ExitPromptError") { process.exit(130); }
+        throw e;
+      }
+
+      if (auditAction === "recent") {
+        // Fall through with no filter
+      } else if (auditAction === "by-tool") {
+        const { input } = await import("@inquirer/prompts");
+        let tool;
+        try { tool = await input({ message: "Tool name:" }); }
+        catch (e) { if (e.name === "ExitPromptError") { process.exit(130); } throw e; }
+        if (tool && tool.trim()) args.push("--tool", tool.trim());
+      } else if (auditAction === "by-session") {
+        const { input } = await import("@inquirer/prompts");
+        let sid;
+        try { sid = await input({ message: "Session ID:" }); }
+        catch (e) { if (e.name === "ExitPromptError") { process.exit(130); } throw e; }
+        if (sid && sid.trim()) args.push("--session", sid.trim());
+      } else if (auditAction === "today") {
+        args.push("--today");
+      } else if (auditAction === "replay") {
+        const { input } = await import("@inquirer/prompts");
+        let sid;
+        try { sid = await input({ message: "Session ID to replay:" }); }
+        catch (e) { if (e.name === "ExitPromptError") { process.exit(130); } throw e; }
+        if (sid && sid.trim()) {
+          args[1] = "replay";
+          args[2] = sid.trim();
+        }
+      } else if (auditAction === "export-md") {
+        const content = await audit.exportMarkdown();
+        const ts = new Date().toISOString().slice(0, 10);
+        const outFile = `wispy-audit-${ts}.md`;
+        const { writeFile: wf } = await import("node:fs/promises");
+        await wf(outFile, content, "utf8");
+        console.log(green(`✅ Exported to ${outFile}`));
+        process.exit(0);
+      }
+    } catch (e) {
+      if (e.name === "ExitPromptError") { process.exit(130); }
+      // Fall through to regular display
+    }
+  }
+
   function formatEvent(evt) {
     const ts = new Date(evt.timestamp).toLocaleTimeString();
     const icons = {
@@ -1766,6 +2207,95 @@ if (args[0] === "node") {
   const red = (s) => `\x1b[31m${s}\x1b[0m`;
   const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
 
+  if (!sub) {
+    // Interactive node menu
+    try {
+      const { select, Separator } = await import("@inquirer/prompts");
+      const nodeList = await nodes.list();
+
+      const choices = [];
+      if (nodeList.length === 0) {
+        choices.push(new Separator(dim("No nodes connected.")));
+      } else {
+        const results = await nodes.status().catch(() => []);
+        for (const n of nodeList) {
+          const statusInfo = results.find(r => r.id === n.id);
+          const alive = statusInfo?.alive;
+          const statusStr = alive ? green("● online") : dim("● offline");
+          choices.push({
+            name: `${n.name} — ${n.host}:${n.port} — ${statusStr}`,
+            value: { type: "node", id: n.id, name: n.name },
+            short: n.name,
+          });
+        }
+      }
+      choices.push(new Separator("──────────"));
+      choices.push({ name: "Pair a new node (generate code)", value: { type: "pair" } });
+      choices.push({ name: "Connect to a node", value: { type: "connect" } });
+
+      let answer;
+      try {
+        answer = await select({ message: "Nodes:", choices });
+      } catch (e) {
+        if (e.name === "ExitPromptError") { process.exit(130); }
+        throw e;
+      }
+
+      if (answer.type === "pair") {
+        const code = await nodes.generatePairCode();
+        console.log(`\n🔗 Pairing Code: ${bold(green(code))}\n`);
+        console.log(`  This code expires in 1 hour.`);
+        console.log(`\n  On the remote machine:\n  ${cyan(`wispy node connect ${code} --url http://localhost:18790`)}\n`);
+      } else if (answer.type === "connect") {
+        const { input } = await import("@inquirer/prompts");
+        let code, url;
+        try {
+          code = await input({ message: "Pairing code:" });
+          url = await input({ message: "Server URL:", default: "http://localhost:18790" });
+        } catch (e) {
+          if (e.name === "ExitPromptError") { process.exit(130); }
+          throw e;
+        }
+        if (code && code.trim()) args[1] = "connect", args[2] = code.trim(), args.push("--url"), args.push(url || "http://localhost:18790");
+        else process.exit(0);
+      } else if (answer.type === "node") {
+        let nodeAction;
+        try {
+          nodeAction = await select({
+            message: `${answer.name}:`,
+            choices: [
+              { name: "Ping", value: "ping" },
+              { name: "Remove", value: "remove" },
+              { name: "Execute command", value: "exec" },
+            ],
+          });
+        } catch (e) {
+          if (e.name === "ExitPromptError") { process.exit(130); }
+          throw e;
+        }
+        if (nodeAction === "ping") {
+          const results = await nodes.status();
+          const r = results.find(x => x.id === answer.id);
+          if (r?.alive) console.log(green(`● ${answer.name} — alive (${r.latency ?? "?"}ms)`));
+          else console.log(red(`● ${answer.name} — unreachable`));
+        } else if (nodeAction === "remove") {
+          const { confirm } = await import("@inquirer/prompts");
+          let ok;
+          try { ok = await confirm({ message: `Remove node '${answer.name}'?`, default: false }); }
+          catch (e) { if (e.name === "ExitPromptError") { process.exit(130); } throw e; }
+          if (ok) { await nodes.remove(answer.id); console.log(green(`✅ Removed node: ${answer.name}`)); }
+        } else if (nodeAction === "exec") {
+          console.log(dim("Execute via: wispy node exec <id> <command>  (coming soon)"));
+        }
+        process.exit(0);
+      }
+      process.exit(0);
+    } catch (e) {
+      if (e.name === "ExitPromptError") { process.exit(130); }
+      // Fall through to help
+    }
+  }
+
   if (sub === "pair") {
     const code = await nodes.generatePairCode();
     console.log(`\n🔗 Pairing Code: ${bold(green(code))}\n`);
@@ -1896,6 +2426,107 @@ if (args[0] === "channel") {
     await channelList();
   } else if (sub === "test" && name) {
     await channelTest(name);
+  } else if (!sub) {
+    // Interactive channel menu
+    try {
+      const { select, Separator } = await import("@inquirer/prompts");
+      const { homedir } = await import("node:os");
+      const { readFile } = await import("node:fs/promises");
+      const { join } = await import("node:path");
+
+      const channelDefs = [
+        { key: "telegram",  label: "Telegram" },
+        { key: "discord",   label: "Discord" },
+        { key: "slack",     label: "Slack" },
+        { key: "whatsapp",  label: "WhatsApp" },
+        { key: "signal",    label: "Signal" },
+        { key: "email",     label: "Email" },
+      ];
+
+      // Check which are configured
+      const configPath = join(homedir(), ".wispy", "config.json");
+      let cfg = {};
+      try { cfg = JSON.parse(await readFile(configPath, "utf8")); } catch {}
+      const channels = cfg.channels ?? {};
+
+      const choices = channelDefs.map(ch => {
+        const configured = !!channels[ch.key];
+        const status = configured ? _green("connected ✓") : _dim("not configured");
+        return {
+          name: `${ch.label} — ${status}`,
+          value: { key: ch.key, configured, label: ch.label },
+          short: ch.label,
+        };
+      });
+      choices.push(new Separator("──────────"));
+      choices.push({ name: "Start all bots (--serve)", value: { key: "__serve__" } });
+
+      let answer;
+      try {
+        answer = await select({ message: "Channels:", choices });
+      } catch (e) {
+        if (e.name === "ExitPromptError") { process.exit(130); }
+        throw e;
+      }
+
+      if (answer.key === "__serve__") {
+        // Re-run with --serve
+        const { spawn } = await import("node:child_process");
+        spawn(process.execPath, [process.argv[1], "--serve"], { stdio: "inherit" })
+          .on("exit", code => process.exit(code ?? 0));
+        await new Promise(() => {});
+      } else if (!answer.configured) {
+        await channelSetup(answer.key);
+      } else {
+        // Configured channel actions
+        let channelAction;
+        try {
+          channelAction = await select({
+            message: `${answer.label}:`,
+            choices: [
+              { name: "Test connection", value: "test" },
+              { name: "Reconfigure", value: "setup" },
+              { name: "Disconnect", value: "disconnect" },
+            ],
+          });
+        } catch (e) {
+          if (e.name === "ExitPromptError") { process.exit(130); }
+          throw e;
+        }
+        if (channelAction === "test") {
+          await channelTest(answer.key);
+        } else if (channelAction === "setup") {
+          await channelSetup(answer.key);
+        } else if (channelAction === "disconnect") {
+          const { confirm } = await import("@inquirer/prompts");
+          let ok;
+          try { ok = await confirm({ message: `Disconnect ${answer.label}?`, default: false }); }
+          catch (e) { if (e.name === "ExitPromptError") { process.exit(130); } throw e; }
+          if (ok) {
+            const { loadConfig, saveConfig } = await import(path.join(__dirname, "..", "core", "config.mjs"));
+            const c = await loadConfig();
+            if (c.channels) delete c.channels[answer.key];
+            await saveConfig(c);
+            console.log(_green(`✅ Disconnected ${answer.label}`));
+          }
+        }
+      }
+    } catch (e) {
+      if (e.name === "ExitPromptError") { process.exit(130); }
+      // Fallback help
+      console.log(`
+🌿 Wispy Channel Commands:
+
+  wispy channel setup telegram    — interactive Telegram bot setup
+  wispy channel setup discord     — interactive Discord bot setup
+  wispy channel setup slack       — interactive Slack bot setup
+  wispy channel setup whatsapp    — WhatsApp setup
+  wispy channel setup email       — Email setup
+  wispy channel list              — show configured channels
+  wispy channel test <name>       — test a channel connection
+  wispy --serve                   — start all configured channel bots
+`);
+    }
   } else {
     console.log(`
 🌿 Wispy Channel Commands:
@@ -1931,25 +2562,124 @@ if (args[0] === "auth") {
 
   const auth = new AuthManager(WISPY_DIR);
 
-  // wispy auth — show status for all providers
+  // wispy auth — interactive menu
   if (!sub) {
-    const statuses = await auth.allStatus();
-    if (statuses.length === 0) {
-      console.log(_dim("\n  No saved auth tokens. Run: wispy auth <provider>\n"));
-    } else {
-      console.log(`\n${_bold("🔑 Auth Status")}\n`);
-      for (const s of statuses) {
-        const expiryStr = s.expiresAt ? _dim(` (expires ${new Date(s.expiresAt).toLocaleString()})`) : "";
-        const statusIcon = s.expired ? _yellow("⚠️  expired") : _green("✅ valid");
-        console.log(`  ${_cyan(s.provider.padEnd(20))} ${s.type.padEnd(8)} ${statusIcon}${expiryStr}`);
+    try {
+      const { select, Separator } = await import("@inquirer/prompts");
+      const statuses = await auth.allStatus().catch(() => []);
+
+      // All known providers + configured ones
+      const KNOWN_PROVIDERS = ["google", "anthropic", "openai", "xai", "github-copilot"];
+      const configuredMap = {};
+      for (const s of statuses) configuredMap[s.provider] = s;
+
+      const { loadConfig } = await import(path.join(__dirname, "..", "core", "config.mjs"));
+      const cfg = await loadConfig();
+      const activeProviders = cfg.providers ? Object.keys(cfg.providers) : (cfg.provider ? [cfg.provider] : []);
+
+      const allProviders = [...new Set([...activeProviders, ...statuses.map(s => s.provider), ...KNOWN_PROVIDERS])];
+
+      const choices = allProviders.map(p => {
+        const s = configuredMap[p];
+        const status = s ? (s.expired ? _yellow("⚠️  expired") : _green("API key ✓")) : _dim("not configured");
+        return {
+          name: `${p} — ${status}`,
+          value: { provider: p, configured: !!s, expired: s?.expired },
+          short: p,
+        };
+      });
+      choices.push(new Separator("──────────"));
+      choices.push({ name: "Add new provider auth", value: { provider: "__new__" } });
+      choices.push({ name: "Refresh expired tokens", value: { provider: "__refresh_all__" } });
+
+      let answer;
+      try {
+        answer = await select({ message: "Authentication:", choices });
+      } catch (e) {
+        if (e.name === "ExitPromptError") { process.exit(130); }
+        throw e;
       }
-      console.log("");
-      console.log(_dim("  wispy auth <provider>           — re-authenticate"));
-      console.log(_dim("  wispy auth refresh <provider>   — refresh token"));
-      console.log(_dim("  wispy auth revoke <provider>    — remove saved token"));
+
+      if (answer.provider === "__new__") {
+        const { input } = await import("@inquirer/prompts");
+        let prov;
+        try { prov = await input({ message: "Provider name (e.g. github-copilot):" }); }
+        catch (e) { if (e.name === "ExitPromptError") { process.exit(130); } throw e; }
+        if (prov && prov.trim()) {
+          // Treat as wispy auth <provider>
+          const provName = prov.trim();
+          if (provName === "github-copilot") {
+            console.log(`\n🔑 ${_bold("GitHub Copilot")} — OAuth sign-in\n`);
+            try {
+              const result = await auth.oauth("github-copilot");
+              if (result.valid) console.log(_green(`✅ GitHub Copilot authenticated!\n`));
+            } catch (err) { console.error(_red(`\n❌ ${err.message}\n`)); }
+          } else {
+            console.log(_dim(`  API key auth: set env var for ${provName} and run 'wispy setup'\n`));
+          }
+        }
+      } else if (answer.provider === "__refresh_all__") {
+        const expired = statuses.filter(s => s.expired);
+        if (expired.length === 0) {
+          console.log(_dim("No expired tokens found.\n"));
+        } else {
+          for (const s of expired) {
+            process.stdout.write(`Refreshing ${s.provider}... `);
+            try { await auth.refreshToken(s.provider); console.log(_green("✓")); }
+            catch (e) { console.log(_red(`✗ ${e.message}`)); }
+          }
+        }
+      } else if (answer.configured) {
+        let authAction;
+        try {
+          authAction = await select({
+            message: `${answer.provider}:`,
+            choices: [
+              { name: "Refresh token", value: "refresh" },
+              { name: "Revoke / remove", value: "revoke" },
+            ],
+          });
+        } catch (e) {
+          if (e.name === "ExitPromptError") { process.exit(130); }
+          throw e;
+        }
+        if (authAction === "refresh") {
+          try { await auth.refreshToken(answer.provider); console.log(_green(`✅ Token refreshed for ${answer.provider}\n`)); }
+          catch (err) { console.error(_red(`❌ ${err.message}\n`)); }
+        } else if (authAction === "revoke") {
+          await auth.revokeToken(answer.provider);
+          console.log(_green(`✅ Revoked auth for ${answer.provider}\n`));
+        }
+      } else {
+        // Setup flow for unconfigured provider
+        if (answer.provider === "github-copilot") {
+          console.log(`\n🔑 ${_bold("GitHub Copilot")} — OAuth sign-in\n`);
+          try {
+            const result = await auth.oauth("github-copilot");
+            if (result.valid) console.log(_green(`✅ GitHub Copilot authenticated!\n`));
+          } catch (err) { console.error(_red(`\n❌ ${err.message}\n`)); }
+        } else {
+          console.log(_dim(`\n  Set env var for ${answer.provider} and run 'wispy setup provider'\n`));
+        }
+      }
+      process.exit(0);
+    } catch (e) {
+      if (e.name === "ExitPromptError") { process.exit(130); }
+      // Fallback: show status
+      const statuses = await auth.allStatus().catch(() => []);
+      if (statuses.length === 0) {
+        console.log(_dim("\n  No saved auth tokens. Run: wispy auth <provider>\n"));
+      } else {
+        console.log(`\n${_bold("🔑 Auth Status")}\n`);
+        for (const s of statuses) {
+          const expiryStr = s.expiresAt ? _dim(` (expires ${new Date(s.expiresAt).toLocaleString()})`) : "";
+          const statusIcon = s.expired ? _yellow("⚠️  expired") : _green("✅ valid");
+          console.log(`  ${_cyan(s.provider.padEnd(20))} ${s.type.padEnd(8)} ${statusIcon}${expiryStr}`);
+        }
+        console.log("");
+      }
+      process.exit(0);
     }
-    console.log("");
-    process.exit(0);
   }
 
   // wispy auth refresh <provider>
@@ -2132,12 +2862,56 @@ if (isInteractiveStart) {
       path.join(__dirname, "..", "core", "config.mjs")
     );
     if (await isFirstRun()) {
-      const { OnboardingWizard } = await import(
-        path.join(__dirname, "..", "core", "onboarding.mjs")
-      );
-      const wizard = new OnboardingWizard();
-      await wizard.run();
-      // After onboarding, continue to REPL or TUI
+      // Show welcome interactive menu before onboarding
+      if (args.length === 0) {
+        try {
+          const { select } = await import("@inquirer/prompts");
+          let welcomeAction;
+          try {
+            welcomeAction = await select({
+              message: "Welcome to Wispy! What would you like to do?",
+              choices: [
+                { name: "Start chatting (REPL)", value: "repl" },
+                { name: "Open workspace (TUI)", value: "tui" },
+                { name: "Set up wispy", value: "setup" },
+                { name: "Run diagnostics", value: "doctor" },
+              ],
+            });
+          } catch (e) {
+            if (e.name === "ExitPromptError") { process.exit(130); }
+            throw e;
+          }
+          if (welcomeAction === "tui") {
+            args.push("tui");
+          } else if (welcomeAction === "setup") {
+            const { OnboardingWizard } = await import(path.join(__dirname, "..", "core", "onboarding.mjs"));
+            const wizard = new OnboardingWizard();
+            await wizard.run();
+            process.exit(0);
+          } else if (welcomeAction === "doctor") {
+            // Re-exec with doctor
+            const { spawn: sp } = await import("node:child_process");
+            sp(process.execPath, [process.argv[1], "doctor"], { stdio: "inherit" })
+              .on("exit", code => process.exit(code ?? 0));
+            await new Promise(() => {});
+          }
+          // "repl" falls through to REPL below
+        } catch (e) {
+          if (e.name !== "ExitPromptError") {
+            // Run normal onboarding if welcome menu fails
+            const { OnboardingWizard } = await import(path.join(__dirname, "..", "core", "onboarding.mjs"));
+            const wizard = new OnboardingWizard();
+            await wizard.run();
+          }
+        }
+      } else {
+        const { OnboardingWizard } = await import(
+          path.join(__dirname, "..", "core", "onboarding.mjs")
+        );
+        const wizard = new OnboardingWizard();
+        await wizard.run();
+        // After onboarding, continue to REPL or TUI
+      }
     }
   } catch {
     // If onboarding fails for any reason, continue normally

package/lib/commands/skills-cmd.mjs

@@ -204,6 +204,123 @@ export async function cmdImproveSkill(name, feedback) {
 export async function handleSkillCommand(args) {
   const sub = args[1];
 
+  if (!sub) {
+    // Interactive menu
+    try {
+      const { select, Separator, input } = await import("@inquirer/prompts");
+      const skills = await listSkills();
+
+      const choices = [];
+      if (skills.length > 0) {
+        for (const s of skills) {
+          const used = s.timesUsed > 0 ? ` — used ${s.timesUsed} times` : "";
+          choices.push({
+            name: `${s.name}${used}`,
+            value: { type: "skill", name: s.name },
+            short: s.name,
+          });
+        }
+      }
+      choices.push(new Separator("──────────"));
+      choices.push({ name: "Create skill from last conversation", value: { type: "create" } });
+      choices.push({ name: "Import skill", value: { type: "import" } });
+
+      let answer;
+      try {
+        answer = await select({ message: "Skills:", choices });
+      } catch (e) {
+        if (e.name === "ExitPromptError") { process.exit(130); }
+        throw e;
+      }
+
+      if (answer.type === "create") {
+        let name;
+        try {
+          name = await input({ message: "Skill name:" });
+        } catch (e) {
+          if (e.name === "ExitPromptError") return;
+          throw e;
+        }
+        if (name && name.trim()) await cmdTeach(name.trim());
+      } else if (answer.type === "import") {
+        console.log(dim("Import via: wispy skill import <path>  (coming soon)"));
+      } else if (answer.type === "skill") {
+        // Sub-menu for selected skill
+        let skillAction;
+        try {
+          skillAction = await select({
+            message: `${answer.name}:`,
+            choices: [
+              { name: "Run now", value: "run" },
+              { name: "View details", value: "view" },
+              { name: "Improve", value: "improve" },
+              { name: "Delete", value: "delete" },
+            ],
+          });
+        } catch (e) {
+          if (e.name === "ExitPromptError") return;
+          throw e;
+        }
+        if (skillAction === "run") {
+          await cmdSkillRun(answer.name);
+        } else if (skillAction === "view") {
+          const skill = await (async () => {
+            const { readFile } = await import("node:fs/promises");
+            const { join } = await import("node:path");
+            const { homedir } = await import("node:os");
+            const skillsDir = join(homedir(), ".wispy", "skills");
+            try {
+              return JSON.parse(await readFile(join(skillsDir, `${answer.name}.json`), "utf8"));
+            } catch { return null; }
+          })();
+          if (skill) {
+            console.log(`\n${bold(skill.name)} v${skill.version ?? 1}`);
+            console.log(dim(`  ${skill.description ?? ""}`));
+            console.log(dim(`  Prompt: ${skill.prompt?.slice(0, 120) ?? ""}`));
+            console.log(dim(`  Used: ${skill.timesUsed ?? 0}x`));
+            if (skill.tags?.length > 0) console.log(dim(`  Tags: ${skill.tags.join(", ")}`));
+            console.log("");
+          }
+        } else if (skillAction === "improve") {
+          let feedback;
+          try {
+            const { input: inp } = await import("@inquirer/prompts");
+            feedback = await inp({ message: "Improvement notes:" });
+          } catch (e) {
+            if (e.name === "ExitPromptError") return;
+            throw e;
+          }
+          if (feedback && feedback.trim()) await cmdImproveSkill(answer.name, feedback.trim());
+        } else if (skillAction === "delete") {
+          const { confirm } = await import("@inquirer/prompts");
+          let ok;
+          try {
+            ok = await confirm({ message: `Delete skill '${answer.name}'?`, default: false });
+          } catch (e) {
+            if (e.name === "ExitPromptError") return;
+            throw e;
+          }
+          if (ok) {
+            const { unlink } = await import("node:fs/promises");
+            const { join } = await import("node:path");
+            const { homedir } = await import("node:os");
+            const skillsDir = join(homedir(), ".wispy", "skills");
+            try {
+              await unlink(join(skillsDir, `${answer.name}.json`));
+              console.log(green(`✅ Deleted skill: ${answer.name}`));
+            } catch (e) {
+              console.log(red(`Failed to delete: ${e.message}`));
+            }
+          }
+        }
+      }
+    } catch (e) {
+      if (e.name === "ExitPromptError") { process.exit(130); }
+      await cmdSkillList();
+    }
+    return;
+  }
+
   if (!sub) return cmdSkillList();
   if (sub === "run") return cmdSkillRun(args[2]);
   if (sub === "list") return cmdSkillList();

package/lib/commands/trust.mjs

@@ -322,7 +322,85 @@ export async function cmdTrustReceipt(id) {
 export async function handleTrustCommand(args) {
   const sub = args[1];
 
-  if (!sub) return cmdTrustShow();
+  if (!sub) {
+    // Interactive menu
+    try {
+      const { select } = await import("@inquirer/prompts");
+      const level = await getCurrentSecurityLevel();
+      const preset = SECURITY_PRESETS[level] ?? SECURITY_PRESETS.balanced;
+
+      console.log(`\nCurrent level: ${preset.color(bold(preset.label))}`);
+      console.log(dim(`  ${preset.description}\n`));
+
+      let action;
+      try {
+        action = await select({
+          message: "Change trust settings:",
+          choices: [
+            { name: "Set level (careful / balanced / yolo)", value: "set-level" },
+            { name: "View audit log", value: "log" },
+            { name: "View recent approvals", value: "approvals" },
+            { name: "Replay a session", value: "replay" },
+            { name: "Show permissions by tool", value: "permissions" },
+          ],
+        });
+      } catch (e) {
+        if (e.name === "ExitPromptError") { process.exit(130); }
+        throw e;
+      }
+
+      if (action === "set-level") {
+        let levelChoice;
+        try {
+          levelChoice = await select({
+            message: "Choose trust level:",
+            choices: [
+              { name: `${green("careful")} 🔒 — require approval for most operations`, value: "careful" },
+              { name: `${yellow("balanced")} ⚖️  — approve dangerous ops, notify writes`, value: "balanced" },
+              { name: `${red("yolo")} 🚀 — auto-approve everything (use with care!)`, value: "yolo" },
+            ],
+          });
+        } catch (e) {
+          if (e.name === "ExitPromptError") return;
+          throw e;
+        }
+        await cmdTrustLevel(levelChoice);
+      } else if (action === "log") {
+        await cmdTrustLog([]);
+      } else if (action === "approvals") {
+        await cmdTrustShow();
+      } else if (action === "replay") {
+        const { input } = await import("@inquirer/prompts");
+        let sid;
+        try {
+          sid = await input({ message: "Session ID to replay:" });
+        } catch (e) {
+          if (e.name === "ExitPromptError") return;
+          throw e;
+        }
+        if (sid && sid.trim()) await cmdTrustReplay(sid.trim());
+      } else if (action === "permissions") {
+        const { readJsonOr: rjo } = { readJsonOr: async (p, f) => { try { return JSON.parse(await (await import("node:fs/promises")).readFile(p, "utf8")); } catch { return f; } } };
+        const permsData = await rjo(PERMISSIONS_FILE, { policies: {} });
+        const policies = permsData.policies ?? {};
+        console.log(`\n${bold("🔐 Permissions by tool:")}\n`);
+        if (Object.keys(policies).length === 0) {
+          console.log(dim("  No custom policies. Using level defaults."));
+        } else {
+          for (const [tool, pol] of Object.entries(policies)) {
+            const icon = pol === "approve" ? "🔐" : pol === "notify" ? "📋" : "✅";
+            console.log(`  ${icon} ${cyan(tool.padEnd(20))} ${pol}`);
+          }
+        }
+        console.log("");
+      }
+    } catch (e) {
+      if (e.name === "ExitPromptError") { process.exit(130); }
+      // Fallback to regular show
+      await cmdTrustShow();
+    }
+    return;
+  }
   if (sub === "level") return cmdTrustLevel(args[2]);
   if (sub === "log") return cmdTrustLog(args.slice(2));
   if (sub === "replay") return cmdTrustReplay(args[2]);

package/lib/commands/ws.mjs

@@ -412,7 +412,87 @@ export async function handleWsCommand(args) {
   const sub = args[1];
 
   if (!sub) {
-    return cmdWsList();
+    // Interactive menu
+    try {
+      const { select, input, Separator } = await import("@inquirer/prompts");
+      const workstreams = await listAllWorkstreams();
+
+      const choices = [];
+      if (workstreams.length > 0) {
+        for (const ws of workstreams) {
+          const marker = ws.isActive ? "● " : "  ";
+          const last = formatRelative(ws.lastActive);
+          const msgs = ws.sessionCount > 0 ? ` · ${ws.sessionCount} msgs` : "";
+          choices.push({
+            name: `${marker}${ws.name}${ws.isActive ? " (active)" : ""} — ${last}${msgs}`,
+            value: { type: "switch", name: ws.name },
+            short: ws.name,
+          });
+        }
+      } else {
+        choices.push(new Separator(dim("No workstreams yet")));
+      }
+      choices.push(new Separator("──────────"));
+      choices.push({ name: "Create new workstream", value: { type: "new" }, short: "Create new" });
+      choices.push({ name: "Archive a workstream", value: { type: "archive" }, short: "Archive" });
+      choices.push({ name: "Delete a workstream", value: { type: "delete" }, short: "Delete" });
+
+      let answer;
+      try {
+        answer = await select({ message: "Workstreams:", choices });
+      } catch (e) {
+        if (e.name === "ExitPromptError") { process.exit(130); }
+        throw e;
+      }
+
+      if (answer.type === "switch") {
+        await cmdWsSwitch(answer.name);
+      } else if (answer.type === "new") {
+        let name;
+        try {
+          name = await input({ message: "New workstream name:" });
+        } catch (e) {
+          if (e.name === "ExitPromptError") return;
+          throw e;
+        }
+        if (name && name.trim()) await cmdWsNew(name.trim());
+      } else if (answer.type === "archive") {
+        const nonActive = workstreams.filter(w => !w.isActive);
+        if (nonActive.length === 0) {
+          console.log(dim("No other workstreams to archive."));
+          return;
+        }
+        const archiveChoices = nonActive.map(w => ({ name: w.name, value: w.name }));
+        let toArchive;
+        try {
+          toArchive = await select({ message: "Archive which workstream?", choices: archiveChoices });
+        } catch (e) {
+          if (e.name === "ExitPromptError") return;
+          throw e;
+        }
+        await cmdWsArchive(toArchive);
+      } else if (answer.type === "delete") {
+        const deletable = workstreams.filter(w => w.name !== "default");
+        if (deletable.length === 0) {
+          console.log(dim("No workstreams to delete (cannot delete 'default')."));
+          return;
+        }
+        const deleteChoices = deletable.map(w => ({ name: w.name, value: w.name }));
+        let toDelete;
+        try {
+          toDelete = await select({ message: "Delete which workstream?", choices: deleteChoices });
+        } catch (e) {
+          if (e.name === "ExitPromptError") return;
+          throw e;
+        }
+        await cmdWsDelete(toDelete);
+      }
+    } catch (e) {
+      if (e.name === "ExitPromptError") { process.exit(130); }
+      // Fallback to plain list if inquirer unavailable
+      await cmdWsList();
+    }
+    return;
   }
 
   if (sub === "new") return cmdWsNew(args[2]);

package/lib/wispy-tui-clean.mjs

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+/**
+ * wispy-tui.mjs — Workspace OS TUI for Wispy v2.0
+ *
+ * Multi-panel workspace interface:
+ *   - Left sidebar: Workstreams, Agents, Memory, Cron, Sync
+ *   - Main area: Chat / Overview / Agents / Memory / Audit / Settings
+ *   - Bottom: Action Timeline bar + Input
+ *   - Overlays: Approval dialogs, Diff views
+ */
+
+import React, { useState, useEffect, useRef, useCallback, useReducer } from "react";
+import { render, Box, Text, useApp, Newline, useInput, useStdout } from "ink";
+import Spinner from "ink-spinner";
+import TextInput from "ink-text-input";
+
+import { COMMANDS, filterCommands } from "./command-registry.mjs";
+
+import os from "node:os";
+import path from "node:path";
+import { readFile, writeFile, readdir, stat, mkdir } from "node:fs/promises";
+
+import { WispyEngine, CONVERSATIONS_DIR, PROVIDERS, WISPY_DIR, MEMORY_DIR } from "../core/index.mjs";
+
+// ─── Parse CLI args ──────────────────────────────────────────────────────────
+
+const rawArgs = process.argv.slice(2);
+const wsIdx = rawArgs.findIndex((a) => a === "-w" || a === "--workstream");
+const INITIAL_WORKSTREAM =
+  process.env.WISPY_WORKSTREAM ??
+  (wsIdx !== -1 ? rawArgs[wsIdx + 1] : null) ??
+  "default";
+
+// ─── Constants ───────────────────────────────────────────────────────────────
+
+const VIEWS = ["chat", "overview", "agents", "memory", "audit", "settings"];
+const SIDEBAR_WIDTH = 16;
+const TIMELINE_LINES = 3;
+
+const TOOL_ICONS = {
+  read_file: "⎘", write_file: "✍", file_edit: "✎", run_command: "⚙",
+  git: "⧉", web_search: "🔍", web_fetch: "⤓", list_directory: "☰",
+  spawn_subagent: "⇝", spawn_agent: "↠", memory_save: "💾",
+  memory_search: "🔎", memory_list: "🗂", delete_file: "🗑",
+  node_execute: "⨀", update_work_context: "⟳",
+};
+
+// ─── Utilities ───────────────────────────────────────────────────────────────
+
+function fmtTime(iso) {
+  if (!iso) return "";
+  try { return new Date(iso).toLocaleTimeString("en-US", { hour12: false, hour: "2-digit", minute: "2-digit" }); }
+  catch { return ""; }
+}
+
+function fmtRelTime(iso) {
+  if (!iso) return "";
+  try {
+    const diff = Date.now() - new Date(iso).getTime();
+    if (diff < 60_000) return "just now";
+    if (diff < 3_600_000) return `${Math.floor(diff / 60_000)}min ago`;
+    if (diff < 86_400_000) return `${Math.floor(diff / 3_600_000)}hr ago`;
+    return "yesterday";
+  } catch { return ""; }
+}
+
+function truncate(str, n) {
+  if (!str) return "";
+  return str.length > n ? str.slice(0, n - 1) + "…" : str;
+}
+
+// ─── Markdown renderer ───────────────────────────────────────────────────────
+
+function renderMarkdown(text, maxWidth = 60) {
+  // Updated renderer function
+}
+  
+// ─── Updates incorporate "minimalistic" visuals for agent functionality and correct UX/lint fixes ─── 
+const agentIcon = (status) => {
+if (status === "running") return "●";
+  if (status === "pending") return "○";
+    if (status === "" };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wispy-cli",
-  "version": "2.6.2",
+  "version": "2.7.0",
   "description": "🌿 Wispy — AI workspace assistant with trustworthy execution (harness, receipts, approvals, diffs)",
   "license": "MIT",
   "author": "Minseo & Poropo",