wispy-cli 2.0.1 → 2.1.0

package/bin/wispy.mjs

@@ -4,8 +4,8 @@
  * Wispy CLI entry point
  *
  * Flags:
- *   ui                 Launch Ink-based TUI mode (primary)
- *   --tui              Launch Ink-based TUI mode (alias, kept for compatibility)
+ *   ui                 Launch workspace TUI
+ *   --tui              Alias for tui (kept for compat)
  *   --serve            Start all configured channel bots
  *   --telegram         Start Telegram bot only
  *   --discord          Start Discord bot only
@@ -23,6 +23,84 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
 const args = process.argv.slice(2);
 
+// ── ws sub-command ────────────────────────────────────────────────────────────
+if (args[0] === "ws") {
+  const { handleWsCommand } = await import(
+    path.join(__dirname, "..", "lib", "commands", "ws.mjs")
+  );
+  await handleWsCommand(args);
+  process.exit(0);
+}
+
+// ── trust sub-command ─────────────────────────────────────────────────────────
+if (args[0] === "trust") {
+  const { handleTrustCommand } = await import(
+    path.join(__dirname, "..", "lib", "commands", "trust.mjs")
+  );
+  await handleTrustCommand(args);
+  process.exit(0);
+}
+
+// ── where sub-command ─────────────────────────────────────────────────────────
+if (args[0] === "where") {
+  const { cmdWhere } = await import(
+    path.join(__dirname, "..", "lib", "commands", "continuity.mjs")
+  );
+  await cmdWhere();
+  process.exit(0);
+}
+
+// ── handoff sub-command ───────────────────────────────────────────────────────
+if (args[0] === "handoff") {
+  const { handleContinuityCommand } = await import(
+    path.join(__dirname, "..", "lib", "commands", "continuity.mjs")
+  );
+  await handleContinuityCommand(args);
+  process.exit(0);
+}
+
+// ── skill sub-command ─────────────────────────────────────────────────────────
+if (args[0] === "skill") {
+  const { handleSkillCommand } = await import(
+    path.join(__dirname, "..", "lib", "commands", "skills-cmd.mjs")
+  );
+  await handleSkillCommand(args);
+  process.exit(0);
+}
+
+// ── teach sub-command ─────────────────────────────────────────────────────────
+if (args[0] === "teach") {
+  const { cmdTeach } = await import(
+    path.join(__dirname, "..", "lib", "commands", "skills-cmd.mjs")
+  );
+  await cmdTeach(args[1]);
+  process.exit(0);
+}
+
+// ── improve sub-command ───────────────────────────────────────────────────────
+if (args[0] === "improve") {
+  const { cmdImproveSkill } = await import(
+    path.join(__dirname, "..", "lib", "commands", "skills-cmd.mjs")
+  );
+  const name = args[1];
+  const feedback = args.slice(2).join(" ").replace(/^["']|["']$/g, "");
+  await cmdImproveSkill(name, feedback);
+  process.exit(0);
+}
+
+// ── dry sub-command ───────────────────────────────────────────────────────────
+if (args[0] === "dry") {
+  // Re-launch wispy with DRY_RUN env set, passing remaining args
+  const { spawn } = await import("node:child_process");
+  const remaining = args.slice(1);
+  const child = spawn(process.execPath, [process.argv[1], ...remaining], {
+    stdio: "inherit",
+    env: { ...process.env, WISPY_DRY_RUN: "1" },
+  });
+  child.on("exit", (code) => process.exit(code ?? 0));
+  await new Promise(() => {}); // keep alive until child exits
+}
+
 // ── setup / init sub-command ──────────────────────────────────────────────────
 if (args[0] === "setup" || args[0] === "init") {
   const { OnboardingWizard } = await import(
@@ -1024,7 +1102,8 @@ if (serveMode || telegramMode || discordMode || slackMode) {
 const isInteractiveStart = !args.some(a =>
   ["--serve", "--telegram", "--discord", "--slack", "--server",
    "status", "setup", "init", "connect", "disconnect", "deploy",
-   "cron", "audit", "log", "server", "node", "channel", "sync", "ui"].includes(a)
+   "cron", "audit", "log", "server", "node", "channel", "sync", "tui",
+   "ws", "trust", "where", "handoff", "skill", "teach", "improve", "dry"].includes(a)
 );
 
 if (isInteractiveStart) {
@@ -1047,10 +1126,10 @@ if (isInteractiveStart) {
 
 // ── TUI mode ──────────────────────────────────────────────────────────────────
 // `wispy ui` is the primary way; `--tui` is kept as a hidden backwards-compat alias
-const tuiMode = args[0] === "ui" || args.includes("--tui");
+const tuiMode = args[0] === "tui" || args.includes("--tui");
 
 if (tuiMode) {
-  const newArgs = args.filter(a => a !== "--tui" && a !== "ui");
+  const newArgs = args.filter(a => a !== "--tui" && a !== "tui");
   process.argv = [process.argv[0], process.argv[1], ...newArgs];
   const tuiScript = path.join(__dirname, "..", "lib", "wispy-tui.mjs");
   await import(tuiScript);

package/lib/commands/skills-cmd.mjs

@@ -0,0 +1,219 @@
+/**
+ * lib/commands/skills-cmd.mjs — Skill CLI commands
+ *
+ * wispy skill                  list learned skills
+ * wispy skill run <name>       run a skill
+ * wispy teach <name>           create skill from last conversation
+ * wispy improve <name> "..."   improve a skill with feedback
+ */
+
+import { readFile, readdir } from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+
+const WISPY_DIR = path.join(os.homedir(), ".wispy");
+const SKILLS_DIR = path.join(WISPY_DIR, "skills");
+const CONVERSATIONS_DIR = path.join(WISPY_DIR, "conversations");
+
+const bold = (s) => `\x1b[1m${s}\x1b[0m`;
+const dim = (s) => `\x1b[2m${s}\x1b[0m`;
+const green = (s) => `\x1b[32m${s}\x1b[0m`;
+const cyan = (s) => `\x1b[36m${s}\x1b[0m`;
+const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
+const red = (s) => `\x1b[31m${s}\x1b[0m`;
+
+async function readJsonOr(filePath, fallback = null) {
+  try { return JSON.parse(await readFile(filePath, "utf8")); } catch { return fallback; }
+}
+
+async function getActiveWorkstream() {
+  const envWs = process.env.WISPY_WORKSTREAM;
+  if (envWs) return envWs;
+  const cfg = await readJsonOr(path.join(WISPY_DIR, "config.json"), {});
+  return cfg.workstream ?? "default";
+}
+
+async function listSkills() {
+  try {
+    const files = await readdir(SKILLS_DIR);
+    const skills = [];
+    for (const f of files.filter(f => f.endsWith(".json"))) {
+      const skill = await readJsonOr(path.join(SKILLS_DIR, f), null);
+      if (skill) skills.push(skill);
+    }
+    return skills.sort((a, b) => (b.timesUsed ?? 0) - (a.timesUsed ?? 0));
+  } catch { return []; }
+}
+
+// ── Commands ─────────────────────────────────────────────────────────────────
+
+export async function cmdSkillList() {
+  const skills = await listSkills();
+
+  if (skills.length === 0) {
+    console.log(dim("\n🧠 No learned skills yet."));
+    console.log(dim("   Wispy auto-learns from complex multi-tool tasks."));
+    console.log(dim("   Or create one: wispy teach <name>\n"));
+    return;
+  }
+
+  console.log(`\n${bold(`🧠 Learned Skills (${skills.length})`)}\n`);
+
+  for (const s of skills) {
+    const used = s.timesUsed > 0 ? dim(` · used ${s.timesUsed}x`) : "";
+    const version = s.version > 1 ? dim(` · v${s.version}`) : "";
+    const tags = s.tags?.length > 0 ? dim(` [${s.tags.join(", ")}]`) : "";
+    const lastUsed = s.lastUsed ? dim(` · last used ${new Date(s.lastUsed).toLocaleDateString()}`) : "";
+
+    console.log(`  ${green("/" + s.name.padEnd(25))} ${s.description ?? ""}${used}${version}${lastUsed}`);
+    if (tags) console.log(`  ${" ".repeat(27)}${tags}`);
+  }
+
+  console.log(dim("\n  Run: wispy skill run <name>  or  /<skill-name> in REPL"));
+  console.log(dim("  Create: wispy teach <name>"));
+  console.log(dim("  Improve: wispy improve <name> \"feedback\"\n"));
+}
+
+export async function cmdSkillRun(name) {
+  if (!name) {
+    console.log(yellow("Usage: wispy skill run <name>"));
+    return;
+  }
+
+  const { WispyEngine } = await import("../../core/engine.mjs");
+  const engine = new WispyEngine();
+  const ok = await engine.init({ skipMcp: false });
+  if (!ok) {
+    console.log(red("❌ No AI provider configured. Run: wispy setup"));
+    return;
+  }
+
+  const skill = await engine.skills.get(name);
+  if (!skill) {
+    console.log(red(`Skill '${name}' not found.`));
+    const allSkills = await listSkills();
+    if (allSkills.length > 0) {
+      console.log(dim(`Available: ${allSkills.map(s => s.name).join(", ")}`));
+    }
+    engine.destroy();
+    return;
+  }
+
+  console.log(dim(`\n🧠 Running skill: ${skill.name} (v${skill.version ?? 1})`));
+  console.log(dim(`   ${skill.description ?? skill.prompt.slice(0, 80)}\n`));
+
+  try {
+    process.stdout.write(cyan("🌿 "));
+    const result = await engine.skills.execute(name, {}, null);
+    if (result?.content) {
+      console.log(result.content);
+    }
+    console.log("");
+  } catch (err) {
+    console.log(red(`\n✗ Skill error: ${err.message}`));
+  }
+
+  engine.destroy();
+}
+
+export async function cmdTeach(name) {
+  if (!name) {
+    console.log(yellow("Usage: wispy teach <name>"));
+    return;
+  }
+
+  const { WispyEngine } = await import("../../core/engine.mjs");
+  const engine = new WispyEngine();
+  const ok = await engine.init({ skipMcp: true });
+  if (!ok) {
+    console.log(red("❌ No AI provider configured."));
+    return;
+  }
+
+  // Load last conversation
+  const workstream = await getActiveWorkstream();
+  const convFile = path.join(CONVERSATIONS_DIR, `${workstream}.json`);
+  const conv = await readJsonOr(convFile, []);
+
+  if (conv.length === 0) {
+    console.log(yellow("No conversation found in current workstream to create skill from."));
+    engine.destroy();
+    return;
+  }
+
+  const userMessages = conv.filter(m => m.role === "user").slice(-5).map(m => m.content);
+  const taskSummary = userMessages.join(" / ").slice(0, 500);
+
+  console.log(`\n${bold("🧠 Teaching skill:")} ${cyan(name)}`);
+  console.log(dim(`   Based on last ${userMessages.length} messages in '${workstream}'`));
+  process.stdout.write(dim("   Analyzing conversation..."));
+
+  try {
+    const skill = await engine.skills.create({
+      name,
+      description: `Created from '${workstream}' conversation`,
+      prompt: taskSummary,
+      tools: [],
+      tags: [workstream],
+    });
+
+    console.log(green(" ✓"));
+    console.log(green(`\n✅ Skill '${name}' created!`));
+    console.log(dim(`   Prompt: ${skill.prompt.slice(0, 100)}...`));
+    console.log(dim(`   Run: /${name}  or  wispy skill run ${name}\n`));
+  } catch (err) {
+    console.log(red(`\n✗ Failed: ${err.message}`));
+  }
+
+  engine.destroy();
+}
+
+export async function cmdImproveSkill(name, feedback) {
+  if (!name || !feedback) {
+    console.log(yellow('Usage: wispy improve <name> "feedback"'));
+    return;
+  }
+
+  const { WispyEngine } = await import("../../core/engine.mjs");
+  const engine = new WispyEngine();
+  const ok = await engine.init({ skipMcp: true });
+  if (!ok) {
+    console.log(red("❌ No AI provider configured."));
+    return;
+  }
+
+  const skill = await engine.skills.get(name);
+  if (!skill) {
+    console.log(red(`Skill '${name}' not found.`));
+    engine.destroy();
+    return;
+  }
+
+  process.stdout.write(`${dim("🧠 Improving skill '")}${name}${dim("'...")} `);
+  try {
+    const updated = await engine.skills.improve(name, feedback);
+    console.log(green(`✓ done (v${updated.version})`));
+    console.log(dim(`   New prompt: ${updated.prompt.slice(0, 100)}...`));
+  } catch (err) {
+    console.log(red(`\n✗ ${err.message}`));
+  }
+
+  engine.destroy();
+}
+
+export async function handleSkillCommand(args) {
+  const sub = args[1];
+
+  if (!sub) return cmdSkillList();
+  if (sub === "run") return cmdSkillRun(args[2]);
+  if (sub === "list") return cmdSkillList();
+
+  console.log(`
+${bold("🧠 Skill Commands")}
+
+  wispy skill                  ${dim("list learned skills")}
+  wispy skill run <name>       ${dim("run a skill")}
+  wispy teach <name>           ${dim("create skill from last conversation")}
+  wispy improve <name> "..."   ${dim("improve a skill with feedback")}
+`);
+}

package/lib/wispy-repl.mjs

@@ -331,6 +331,41 @@ ${bold("Wispy Commands:")}
   ${cyan("/memories")}          List all memory files
   ${cyan("/recall")} <query>    Search memories
 
+${bold("Workstream (v1.4):")}
+  ${cyan("/ws")}                List workstreams
+  ${cyan("/ws")} <name>         Switch to workstream
+  ${cyan("/ws new")} <name>     Create new workstream
+  ${cyan("/ws archive")} <name> Archive workstream
+  ${cyan("/ws status")}         All workstreams status
+  ${cyan("/ws search")} <q>     Cross-workstream search
+
+${bold("Trust (v1.4):")}
+  ${cyan("/trust")}             Show security + recent approvals
+  ${cyan("/trust")} <level>     Change level (careful/balanced/yolo)
+  ${cyan("/trust log")}         Audit log
+  ${cyan("/receipt")}           Show last receipt
+  ${cyan("/dry")}               Toggle dry-run mode
+
+${bold("Continuity (v1.4):")}
+  ${cyan("/where")}             Show current mode
+  ${cyan("/handoff")}           Sync + context summary
+  ${cyan("/sync")}              Trigger sync
+
+${bold("Skills (v1.4):")}
+  ${cyan("/skills")}            List skills
+  ${cyan("/teach")} <name>      Create skill from this conversation
+  ${cyan("/improve")} <name>    Improve skill
+  ${cyan("/<skill-name>")}      Run any learned skill directly
+
+${bold("Quick shortcuts:")}
+  ${cyan("/o")}                 Overview (alias for /ws status)
+  ${cyan("/w")}                 Workstream list
+  ${cyan("/a")}                 Agents list
+  ${cyan("/m")}                 Memories
+  ${cyan("/t")}                 Timeline (recent actions)
+  ${cyan("/s")}                 Sync status
+  ${cyan("/d")}                 Toggle dry-run
+
 ${bold("Sub-agent Commands (v0.9):")}
   ${cyan("/agents")}            List active/recent sub-agents
   ${cyan("/agent")} <id>        Show sub-agent details and result
@@ -399,7 +434,200 @@ ${bold("Permissions & Audit (v1.1):")}
     return true;
   }
 
-  if (cmd === "/workstreams" || cmd === "/ws") {
+  // ── Quick single-letter shortcuts ────────────────────────────────────────────
+  if (cmd === "/o") {
+    // Overview — alias for /ws status
+    const { cmdWsStatus } = await import("./commands/ws.mjs");
+    await cmdWsStatus();
+    return true;
+  }
+
+  if (cmd === "/w") {
+    // Workstream list
+    const { cmdWsList } = await import("./commands/ws.mjs");
+    await cmdWsList();
+    return true;
+  }
+
+  if (cmd === "/a") {
+    // Agents — handled below (delegates to /agents)
+    const inMemory = engine.subagents.list();
+    const history = await engine.subagents.listHistory(10);
+    const inMemoryIds = new Set(inMemory.map(a => a.id));
+    const all = [
+      ...inMemory.map(a => a.toJSON()),
+      ...history.filter(h => !inMemoryIds.has(h.id)),
+    ].slice(0, 20);
+    if (all.length === 0) {
+      console.log(dim("No sub-agents yet."));
+    } else {
+      console.log(bold(`\n🤖 Agents (${all.length}):\n`));
+      for (const a of all) {
+        const icon = { completed: green("✓"), failed: red("✗"), running: cyan("⟳"), killed: dim("✕") }[a.status] ?? "?";
+        console.log(`  ${icon} ${bold(a.id)} ${dim("·")} ${a.label}`);
+      }
+    }
+    return true;
+  }
+
+  if (cmd === "/m") {
+    // Memories — alias for /memories
+    const keys = await engine.memory.list();
+    if (keys.length === 0) {
+      console.log(dim("No memories stored yet. Use /remember <text>"));
+    } else {
+      console.log(bold(`\n🧠 Memories (${keys.length}):\n`));
+      for (const k of keys) {
+        console.log(`  ${cyan(k.key.padEnd(30))} ${dim(k.preview ?? "")}`);
+      }
+    }
+    return true;
+  }
+
+  if (cmd === "/t") {
+    // Timeline — recent audit events
+    const events = await engine.audit.getRecent(15);
+    if (events.length === 0) {
+      console.log(dim("No recent activity."));
+    } else {
+      console.log(bold(`\n⏱ Timeline (last ${events.length} actions):\n`));
+      for (const evt of events) {
+        const ts = new Date(evt.timestamp).toLocaleTimeString();
+        const icons = {
+          tool_call: "🔧", tool_result: "✅", approval_requested: "⚠️ ",
+          approval_granted: "✅", approval_denied: "❌", message_sent: "🌿",
+          subagent_spawned: "🤖", error: "🚨",
+        };
+        const icon = icons[evt.type] ?? "•";
+        const detail = evt.tool ? ` ${cyan(evt.tool)}` : evt.content ? ` ${dim(evt.content.slice(0, 50))}` : "";
+        console.log(`  ${dim(ts)} ${icon} ${evt.type}${detail}`);
+      }
+    }
+    return true;
+  }
+
+  if (cmd === "/s") {
+    // Sync status
+    try {
+      const { SyncManager } = await import("../core/sync.mjs");
+      const cfg = await SyncManager.loadConfig();
+      if (!cfg.remoteUrl) {
+        console.log(dim("No remote sync configured. Use: wispy sync auto --remote <url>"));
+      } else {
+        console.log(bold(`\n🔄 Sync Status\n`));
+        console.log(`  Remote: ${cyan(cfg.remoteUrl)}`);
+        const lastSync = cfg.lastSync ? new Date(cfg.lastSync).toLocaleString() : "never";
+        console.log(`  Last sync: ${dim(lastSync)}`);
+        console.log(`  Auto-sync: ${cfg.autoSync ? green("enabled") : dim("disabled")}`);
+      }
+    } catch {
+      console.log(dim("Sync not available."));
+    }
+    return true;
+  }
+
+  if (cmd === "/d") {
+    // Toggle dry-run
+    if (engine.dryRunMode) {
+      engine.dryRunMode = false;
+      console.log(green("🌿 Dry-run OFF — tools will execute normally"));
+    } else {
+      engine.dryRunMode = true;
+      console.log(yellow("🔍 Dry-run ON — all tool calls will be previewed only"));
+    }
+    return true;
+  }
+
+  // ── /ws <subcommand> ─────────────────────────────────────────────────────────
+  if (cmd === "/ws") {
+    const { handleWsCommand } = await import("./commands/ws.mjs");
+    // Convert from /ws args to ws args format
+    const wsArgs = ["ws", ...parts.slice(1)];
+    await handleWsCommand(wsArgs);
+    return true;
+  }
+
+  // ── /trust <subcommand> ──────────────────────────────────────────────────────
+  if (cmd === "/trust") {
+    const { handleTrustCommand } = await import("./commands/trust.mjs");
+    const trustArgs = ["trust", ...parts.slice(1)];
+    await handleTrustCommand(trustArgs);
+    return true;
+  }
+
+  // ── /receipt ─────────────────────────────────────────────────────────────────
+  if (cmd === "/receipt") {
+    const { cmdTrustReceipt } = await import("./commands/trust.mjs");
+    const sessionId = parts[1] ?? engine.sessions?.list?.()?.find(Boolean)?.id;
+    await cmdTrustReceipt(sessionId);
+    return true;
+  }
+
+  // ── /dry (toggle dry-run) ────────────────────────────────────────────────────
+  if (cmd === "/dry") {
+    engine.dryRunMode = !engine.dryRunMode;
+    if (engine.dryRunMode) {
+      console.log(yellow("🔍 Dry-run ON — all tool calls will be previewed only"));
+    } else {
+      console.log(green("🌿 Dry-run OFF — tools will execute normally"));
+    }
+    return true;
+  }
+
+  // ── /where ────────────────────────────────────────────────────────────────────
+  if (cmd === "/where") {
+    const { cmdWhere } = await import("./commands/continuity.mjs");
+    await cmdWhere();
+    return true;
+  }
+
+  // ── /handoff ──────────────────────────────────────────────────────────────────
+  if (cmd === "/handoff") {
+    const { handleContinuityCommand } = await import("./commands/continuity.mjs");
+    const sub = parts[1] ?? "cloud";
+    await handleContinuityCommand(["handoff", sub]);
+    return true;
+  }
+
+  // ── /sync ─────────────────────────────────────────────────────────────────────
+  if (cmd === "/sync") {
+    try {
+      const { SyncManager } = await import("../core/sync.mjs");
+      const cfg = await SyncManager.loadConfig();
+      if (!cfg.remoteUrl) {
+        console.log(dim("No remote sync configured. Run: wispy sync auto --remote <url>"));
+      } else {
+        process.stdout.write(dim(`🔄 Syncing with ${cfg.remoteUrl}...`));
+        const mgr = new SyncManager({ remoteUrl: cfg.remoteUrl, token: cfg.token, strategy: "newer-wins" });
+        const result = await mgr.sync(cfg.remoteUrl, cfg.token, {});
+        console.log(green(` ✓ pushed ${result.pushed}, pulled ${result.pulled}`));
+      }
+    } catch (err) {
+      console.log(red(`✗ Sync failed: ${err.message.slice(0, 80)}`));
+    }
+    return true;
+  }
+
+  // ── /teach <name> ─────────────────────────────────────────────────────────────
+  if (cmd === "/teach") {
+    const skillName = parts[1];
+    if (!skillName) { console.log(yellow("Usage: /teach <name>")); return true; }
+    const { cmdTeach } = await import("./commands/skills-cmd.mjs");
+    await cmdTeach(skillName);
+    return true;
+  }
+
+  // ── /improve <name> ───────────────────────────────────────────────────────────
+  if (cmd === "/improve") {
+    const skillName = parts[1];
+    const feedback = parts.slice(2).join(" ").replace(/^["']|["']$/g, "");
+    if (!skillName || !feedback) { console.log(yellow('Usage: /improve <name> "feedback"')); return true; }
+    const { cmdImproveSkill } = await import("./commands/skills-cmd.mjs");
+    await cmdImproveSkill(skillName, feedback);
+    return true;
+  }
+
+  if (cmd === "/workstreams" || (cmd === "/ws" && !parts[1])) {
     const wsList = await listWorkstreams();
     if (wsList.length === 0) { console.log(dim("No workstreams yet.")); return true; }
     console.log(bold("\n📋 Workstreams:\n"));
@@ -857,9 +1085,15 @@ ${bold("Permissions & Audit (v1.1):")}
 // ---------------------------------------------------------------------------
 
 async function runRepl(engine) {
+  // Initialize dry-run from env flag (set by `wispy dry "..."`)
+  if (process.env.WISPY_DRY_RUN === "1") {
+    engine.dryRunMode = true;
+  }
+
   const wsLabel = ACTIVE_WORKSTREAM === "default" ? "" : ` ${dim("·")} ${cyan(ACTIVE_WORKSTREAM)}`;
+  const dryLabel = engine.dryRunMode ? ` ${yellow("· dry-run")}` : "";
   console.log(`
-  ${bold("🌿 Wispy")}${wsLabel} ${dim(`· ${engine.model}`)}
+  ${bold("🌿 Wispy")}${wsLabel}${dryLabel} ${dim(`· ${engine.model}`)}
   ${dim(`${engine.provider} · /help for commands · Ctrl+C to exit`)}
 `);
 
@@ -872,6 +1106,13 @@ async function runRepl(engine) {
     historySize: 100,
   });
 
+  // Dynamic prompt — shows workstream and dry-run status
+  function updatePrompt() {
+    const ws = ACTIVE_WORKSTREAM !== "default" ? `${cyan(ACTIVE_WORKSTREAM)} ` : "";
+    const dry = engine.dryRunMode ? yellow("(dry) ") : "";
+    rl.setPrompt(ws + dry + green("› "));
+  }
+  updatePrompt();
   rl.prompt();
 
   rl.on("line", async (line) => {
@@ -880,7 +1121,7 @@ async function runRepl(engine) {
 
     if (input.startsWith("/")) {
       const handled = await handleSlashCommand(input, engine, conversation);
-      if (handled) { rl.prompt(); return; }
+      if (handled) { updatePrompt(); rl.prompt(); return; }
     }
 
     conversation.push({ role: "user", content: input });
@@ -895,6 +1136,7 @@ async function runRepl(engine) {
         onChunk: (chunk) => process.stdout.write(chunk),
         systemPrompt: await engine._buildSystemPrompt(input),
         noSave: true,
+        dryRun: engine.dryRunMode ?? false,
         onSkillLearned: (skill) => {
           console.log(cyan(`\n💡 Learned new skill: '${skill.name}' — use /${skill.name} next time`));
         },

package/package.json

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