wispy-cli 2.0.0 → 2.0.2

package/bin/wispy.mjs

@@ -4,7 +4,8 @@
  * Wispy CLI entry point
  *
  * Flags:
- *   --tui              Launch Ink-based TUI mode
+ *   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
@@ -22,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(
@@ -1023,7 +1102,7 @@ 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"].includes(a)
+   "cron", "audit", "log", "server", "node", "channel", "sync", "tui"].includes(a)
 );
 
 if (isInteractiveStart) {
@@ -1045,10 +1124,11 @@ if (isInteractiveStart) {
 }
 
 // ── TUI mode ──────────────────────────────────────────────────────────────────
-const tuiMode = args.includes("--tui");
+// `wispy ui` is the primary way; `--tui` is kept as a hidden backwards-compat alias
+const tuiMode = args[0] === "tui" || args.includes("--tui");
 
 if (tuiMode) {
-  const newArgs = args.filter(a => a !== "--tui");
+  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/continuity.mjs

@@ -0,0 +1,280 @@
+/**
+ * lib/commands/continuity.mjs — Local↔Cloud continuity commands
+ *
+ * wispy where              show current mode: local/remote, provider, workstream
+ * wispy handoff cloud      sync push + generate context summary + show connect URL
+ * wispy handoff local      sync pull + show what was done remotely
+ */
+
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+
+const WISPY_DIR = path.join(os.homedir(), ".wispy");
+const CONFIG_PATH = path.join(WISPY_DIR, "config.json");
+const REMOTE_FILE = path.join(WISPY_DIR, "remote.json");
+const SYNC_CONFIG = path.join(WISPY_DIR, "sync.json");
+const MEMORY_DIR = path.join(WISPY_DIR, "memory");
+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`;
+
+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(CONFIG_PATH, {});
+  return cfg.workstream ?? "default";
+}
+
+async function getProviderLabel(cfg) {
+  const providerMap = {
+    google: "Google AI (gemini)",
+    anthropic: "Anthropic (Claude)",
+    openai: "OpenAI (GPT)",
+    openrouter: "OpenRouter",
+    groq: "Groq",
+    deepseek: "DeepSeek",
+    ollama: "Ollama (local)",
+  };
+  const model = cfg.model ?? "";
+  const provider = cfg.provider ?? "auto";
+  const label = providerMap[provider] ?? provider;
+  return model ? `${label} / ${model}` : label;
+}
+
+async function getMemoryCount() {
+  try {
+    const { readdir } = await import("node:fs/promises");
+    const files = await readdir(MEMORY_DIR);
+    return files.filter(f => f.endsWith(".md") || f.endsWith(".json")).length;
+  } catch { return 0; }
+}
+
+async function getSessionCount(workstream) {
+  try {
+    const convFile = path.join(CONVERSATIONS_DIR, `${workstream}.json`);
+    const conv = await readJsonOr(convFile, []);
+    return conv.filter(m => m.role === "user").length;
+  } catch { return 0; }
+}
+
+async function getLastSyncTime() {
+  const syncCfg = await readJsonOr(SYNC_CONFIG, null);
+  return syncCfg?.lastSync ?? null;
+}
+
+// ── Commands ─────────────────────────────────────────────────────────────────
+
+export async function cmdWhere() {
+  const cfg = await readJsonOr(CONFIG_PATH, {});
+  const remote = await readJsonOr(REMOTE_FILE, null);
+
+  const mode = remote?.url ? "Remote" : "Local";
+  const modeColor = remote?.url ? yellow : green;
+
+  const workstream = await getActiveWorkstream();
+  const provider = await getProviderLabel(cfg);
+  const secLevel = cfg.securityLevel ?? "balanced";
+  const memCount = await getMemoryCount();
+  const sessionCount = await getSessionCount(workstream);
+
+  // Sync status
+  const lastSync = await getLastSyncTime();
+  const syncCfg = await readJsonOr(SYNC_CONFIG, null);
+  let syncStr = "not configured";
+  if (syncCfg?.remoteUrl) {
+    if (lastSync) {
+      const diffMs = Date.now() - new Date(lastSync).getTime();
+      const diffMin = Math.floor(diffMs / 60000);
+      const diffH = Math.floor(diffMin / 60);
+      const timeStr = diffMin < 60 ? `${diffMin}min ago` : `${diffH}h ago`;
+      syncStr = `${syncCfg.autoSync ? "auto" : "manual"} (last: ${timeStr})`;
+    } else {
+      syncStr = syncCfg.autoSync ? "auto (never synced)" : "configured";
+    }
+  }
+
+  const secIcons = { careful: "🔒", balanced: "⚖️", yolo: "🚀" };
+  const secIcon = secIcons[secLevel] ?? "";
+
+  console.log(`\n${bold("🌿 Wispy Status")}\n`);
+  console.log(`  Mode:        ${modeColor(mode)}${remote?.url ? ` ${dim(remote.url)}` : ""}`);
+  console.log(`  Provider:    ${provider}`);
+  console.log(`  Workstream:  ${cyan(workstream)}`);
+  console.log(`  Security:    ${secLevel} ${secIcon}`);
+  console.log(`  Sync:        ${dim(syncStr)}`);
+  console.log(`  Memory:      ${memCount} files`);
+  console.log(`  Sessions:    ${sessionCount} messages in current workstream`);
+
+  if (remote?.url) {
+    console.log(`\n  ${dim("Remote:")}       ${cyan(remote.url)}`);
+    if (remote.connectedAt) {
+      console.log(`  ${dim("Connected:")}    ${new Date(remote.connectedAt).toLocaleString()}`);
+    }
+  }
+
+  console.log("");
+}
+
+export async function cmdHandoffCloud() {
+  console.log(`\n${bold("☁️  Handoff to Cloud")}\n`);
+
+  // Step 1: Check sync config
+  const syncCfg = await readJsonOr(SYNC_CONFIG, null);
+  const remote = await readJsonOr(REMOTE_FILE, null);
+  const remoteUrl = syncCfg?.remoteUrl ?? remote?.url;
+  const token = syncCfg?.token ?? remote?.token;
+
+  if (!remoteUrl) {
+    console.log(yellow("⚠️  No remote configured."));
+    console.log(dim("   To sync, set up a remote server first:"));
+    console.log(dim("   wispy deploy vps user@host  — deploy to VPS"));
+    console.log(dim("   wispy connect <url> --token <token>  — connect to existing\n"));
+    return;
+  }
+
+  // Step 2: Sync push
+  process.stdout.write(`  1. Pushing data to ${cyan(remoteUrl)}... `);
+  try {
+    const { SyncManager } = await import("../../core/sync.mjs");
+    const mgr = new SyncManager({ remoteUrl, token, strategy: "newer-wins" });
+    const result = await mgr.push(remoteUrl, token, {});
+    console.log(green(`✓ pushed ${result.pushed} files`));
+    if (result.errors.length) {
+      console.log(yellow(`   ⚠ ${result.errors.length} errors`));
+    }
+  } catch (err) {
+    console.log(yellow(`⚠ sync failed: ${err.message.slice(0, 60)}`));
+    console.log(dim("   Continuing with context summary..."));
+  }
+
+  // Step 3: Generate context summary
+  process.stdout.write("  2. Summarizing current work state... ");
+  let summary = "Could not generate summary.";
+  try {
+    const workstream = await getActiveWorkstream();
+    const convFile = path.join(CONVERSATIONS_DIR, `${workstream}.json`);
+    const conv = await readJsonOr(convFile, []);
+    const recentMsgs = conv.slice(-20);
+    const userMsgs = recentMsgs.filter(m => m.role === "user").map(m => m.content).join("\n");
+    const assistantMsgs = recentMsgs.filter(m => m.role === "assistant").map(m => m.content).join("\n");
+
+    if (userMsgs || assistantMsgs) {
+      const cfg = await readJsonOr(CONFIG_PATH, {});
+      // Try to use AI for summary
+      try {
+        const { WispyEngine } = await import("../../core/engine.mjs");
+        const engine = new WispyEngine({ workstream });
+        const ok = await engine.init({ skipMcp: true });
+        if (ok) {
+          const result = await engine.processMessage(null, `Summarize what we were working on in 1-2 sentences. Recent messages:\n\nUser: ${userMsgs.slice(0, 500)}\n\nAssistant: ${assistantMsgs.slice(0, 500)}`, {
+            noSave: true,
+          });
+          summary = result?.content ?? summary;
+          engine.destroy();
+        }
+      } catch {
+        // Fallback: simple summary from last user message
+        const lastUserMsg = conv.filter(m => m.role === "user").pop();
+        if (lastUserMsg) {
+          summary = `Working on: ${lastUserMsg.content.slice(0, 120)}`;
+        }
+      }
+    } else {
+      summary = "No recent conversation activity.";
+    }
+    console.log(green("✓"));
+  } catch {
+    console.log(yellow("⚠ skipped"));
+  }
+
+  // Step 4: Show context + connect command
+  console.log(`\n  ${bold("Context Summary:")}`);
+  console.log(`  ${cyan(summary)}`);
+
+  console.log(`\n  ${bold("Connect from cloud:")}`);
+  const connectCmd = token
+    ? `wispy connect ${remoteUrl} --token ${token.slice(0, 8)}...`
+    : `wispy connect ${remoteUrl}`;
+  console.log(`  ${dim(connectCmd)}`);
+
+  console.log(dim(`\n  Run 'wispy handoff local' to pull changes back.\n`));
+}
+
+export async function cmdHandoffLocal() {
+  console.log(`\n${bold("🏠 Handoff to Local")}\n`);
+
+  // Step 1: Check sync config
+  const syncCfg = await readJsonOr(SYNC_CONFIG, null);
+  const remote = await readJsonOr(REMOTE_FILE, null);
+  const remoteUrl = syncCfg?.remoteUrl ?? remote?.url;
+  const token = syncCfg?.token ?? remote?.token;
+
+  if (!remoteUrl) {
+    console.log(yellow("⚠️  No remote configured."));
+    console.log(dim("   Set up with: wispy connect <url> --token <token>\n"));
+    return;
+  }
+
+  // Step 2: Sync pull
+  process.stdout.write(`  1. Pulling from ${cyan(remoteUrl)}... `);
+  let pullResult = null;
+  try {
+    const { SyncManager } = await import("../../core/sync.mjs");
+    const mgr = new SyncManager({ remoteUrl, token, strategy: "newer-wins" });
+    pullResult = await mgr.pull(remoteUrl, token, {});
+    console.log(green(`✓ pulled ${pullResult.pulled} files`));
+    if (pullResult.conflicts) {
+      console.log(yellow(`   ⚠ ${pullResult.conflicts} conflicts (saved as .conflict-* files)`));
+    }
+  } catch (err) {
+    console.log(yellow(`⚠ sync failed: ${err.message.slice(0, 60)}`));
+  }
+
+  // Step 3: Show what was done remotely
+  if (pullResult?.pulled > 0) {
+    console.log(`\n  ${bold("Remote activity summary:")}`);
+    console.log(`  ${green(pullResult.pulled)} files updated from remote`);
+    if (pullResult.skipped > 0) console.log(dim(`  ${pullResult.skipped} files already up to date`));
+  }
+
+  // Step 4: Switch back to local mode if remote.json exists
+  const remoteExists = !!remote?.url;
+  if (remoteExists) {
+    const { unlink } = await import("node:fs/promises");
+    try {
+      await unlink(REMOTE_FILE);
+      console.log(green("\n  ✓ Switched back to local mode"));
+    } catch {}
+  }
+
+  console.log(dim(`\n  Local workstreams updated. Run 'wispy' to continue.\n`));
+}
+
+export async function handleContinuityCommand(args) {
+  const cmd = args[0];
+  const sub = args[1];
+
+  if (cmd === "where") return cmdWhere();
+
+  if (cmd === "handoff") {
+    if (sub === "cloud") return cmdHandoffCloud();
+    if (sub === "local") return cmdHandoffLocal();
+
+    console.log(`
+${bold("🔄 Handoff Commands")}
+
+  wispy where              ${dim("show current mode: local/remote, provider, workstream")}
+  wispy handoff cloud      ${dim("sync push + context summary + connect URL")}
+  wispy handoff local      ${dim("sync pull + show remote activity + local mode")}
+`);
+  }
+}

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/commands/trust.mjs

@@ -0,0 +1,340 @@
+/**
+ * lib/commands/trust.mjs — Trust / security level commands
+ *
+ * wispy trust                                  show security level + recent approvals
+ * wispy trust level <careful|balanced|yolo>    change security level
+ * wispy trust log                              show audit log
+ * wispy trust replay <id>                      replay session step by step
+ * wispy trust receipt <id>                     show execution receipt
+ */
+
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+
+const WISPY_DIR = path.join(os.homedir(), ".wispy");
+const CONFIG_PATH = path.join(WISPY_DIR, "config.json");
+const PERMISSIONS_FILE = path.join(WISPY_DIR, "permissions.json");
+const AUDIT_DIR = path.join(WISPY_DIR, "audit");
+
+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`;
+
+// Security presets
+const SECURITY_PRESETS = {
+  careful: {
+    label: "careful 🔒",
+    color: green,
+    description: "Maximum oversight: approvals for most operations",
+    overrides: {
+      run_command: "approve",
+      write_file: "approve",
+      file_edit: "approve",
+      delete_file: "approve",
+      git: "approve",
+      spawn_subagent: "approve",
+      spawn_agent: "approve",
+    },
+  },
+  balanced: {
+    label: "balanced ⚖️",
+    color: yellow,
+    description: "Smart defaults: approve dangerous ops, notify writes",
+    overrides: {
+      run_command: "approve",
+      write_file: "notify",
+      file_edit: "notify",
+      delete_file: "approve",
+      git: "approve",
+      spawn_subagent: "notify",
+      spawn_agent: "notify",
+    },
+  },
+  yolo: {
+    label: "yolo 🚀",
+    color: red,
+    description: "Auto-approve everything (use with caution!)",
+    overrides: {
+      run_command: "auto",
+      write_file: "auto",
+      file_edit: "auto",
+      delete_file: "notify",
+      git: "auto",
+      spawn_subagent: "auto",
+      spawn_agent: "auto",
+    },
+  },
+};
+
+async function readJsonOr(filePath, fallback = null) {
+  try {
+    return JSON.parse(await readFile(filePath, "utf8"));
+  } catch {
+    return fallback;
+  }
+}
+
+async function getCurrentSecurityLevel() {
+  const cfg = await readJsonOr(CONFIG_PATH, {});
+  return cfg.securityLevel ?? "balanced";
+}
+
+async function getRecentApprovals(limit = 5) {
+  const approvals = [];
+  try {
+    const today = new Date().toISOString().slice(0, 10);
+    const yesterday = new Date(Date.now() - 86400000).toISOString().slice(0, 10);
+
+    for (const dateStr of [today, yesterday]) {
+      const auditFile = path.join(AUDIT_DIR, `${dateStr}.jsonl`);
+      try {
+        const raw = await readFile(auditFile, "utf8");
+        const lines = raw.trim().split("\n").filter(Boolean);
+        for (const line of lines) {
+          try {
+            const evt = JSON.parse(line);
+            if (evt.type === "approval_granted" || evt.type === "approval_denied" || evt.type === "approval_requested") {
+              approvals.push(evt);
+            }
+          } catch {}
+        }
+      } catch {}
+    }
+  } catch {}
+
+  return approvals.sort((a, b) => new Date(b.timestamp) - new Date(a.timestamp)).slice(0, limit);
+}
+
+// ── Commands ─────────────────────────────────────────────────────────────────
+
+export async function cmdTrustShow() {
+  const level = await getCurrentSecurityLevel();
+  const preset = SECURITY_PRESETS[level] ?? SECURITY_PRESETS.balanced;
+
+  console.log(`\n${bold("🔐 Trust & Security")}\n`);
+  console.log(`  Security level: ${preset.color(bold(preset.label))}`);
+  console.log(`  ${dim(preset.description)}`);
+
+  // Load custom policy overrides
+  const permsData = await readJsonOr(PERMISSIONS_FILE, {});
+  const overrides = permsData.policies ?? {};
+  if (Object.keys(overrides).length > 0) {
+    console.log(`\n  ${bold("Custom overrides:")} ${dim(`(${Object.keys(overrides).length} tools customized)`)}`);
+    for (const [tool, pol] of Object.entries(overrides).slice(0, 5)) {
+      const icon = pol === "approve" ? "🔐" : pol === "notify" ? "📋" : "✅";
+      console.log(`    ${icon} ${tool}: ${pol}`);
+    }
+    if (Object.keys(overrides).length > 5) {
+      console.log(dim(`    ... and ${Object.keys(overrides).length - 5} more`));
+    }
+  }
+
+  // Recent approvals
+  const approvals = await getRecentApprovals(5);
+  if (approvals.length > 0) {
+    console.log(`\n  ${bold("Recent approvals:")}`);
+    for (const a of approvals) {
+      const ts = new Date(a.timestamp).toLocaleTimeString();
+      const icon = a.type === "approval_granted" ? green("✓") : a.type === "approval_denied" ? red("✗") : yellow("?");
+      const tool = a.tool ?? a.toolName ?? "unknown";
+      console.log(`    ${icon} ${dim(ts)} ${tool}`);
+    }
+  } else {
+    console.log(dim("\n  No recent approval activity."));
+  }
+
+  console.log(dim(`\n  Change: wispy trust level <careful|balanced|yolo>\n`));
+}
+
+export async function cmdTrustLevel(level) {
+  if (!level) {
+    console.log(yellow("Usage: wispy trust level <careful|balanced|yolo>"));
+    return;
+  }
+
+  if (!SECURITY_PRESETS[level]) {
+    console.log(red(`Unknown level: ${level}. Use: careful, balanced, or yolo`));
+    return;
+  }
+
+  // Update config
+  const cfg = await readJsonOr(CONFIG_PATH, {});
+  cfg.securityLevel = level;
+  await mkdir(WISPY_DIR, { recursive: true });
+  await writeFile(CONFIG_PATH, JSON.stringify(cfg, null, 2) + "\n", "utf8");
+
+  // Update permissions.json with preset overrides
+  const permsData = await readJsonOr(PERMISSIONS_FILE, { policies: {} });
+  const preset = SECURITY_PRESETS[level];
+  permsData.policies = { ...permsData.policies, ...preset.overrides };
+  await writeFile(PERMISSIONS_FILE, JSON.stringify(permsData, null, 2) + "\n", "utf8");
+
+  const p = SECURITY_PRESETS[level];
+  console.log(`\n${green("✅")} Security level set to: ${p.color(bold(p.label))}`);
+  console.log(dim(`   ${p.description}`));
+  console.log(dim(`   ${Object.keys(p.overrides).length} tool policies updated.\n`));
+}
+
+export async function cmdTrustLog(extraArgs = []) {
+  // Delegate to audit command by running inline
+  const { AuditLog } = await import("../../core/audit.mjs");
+  const audit = new AuditLog(WISPY_DIR);
+
+  const filter = {};
+  const limitIdx = extraArgs.indexOf("--limit");
+  filter.limit = limitIdx !== -1 ? parseInt(extraArgs[limitIdx + 1]) : 20;
+  if (extraArgs.includes("--today")) filter.date = new Date().toISOString().slice(0, 10);
+
+  const events = await audit.search(filter);
+
+  if (events.length === 0) {
+    console.log(dim("No audit events found."));
+  } else {
+    console.log(`\n${bold("📋 Audit Log")} ${dim(`(${events.length} events)`)}\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: "🌿",
+        message_received: "👤", error: "🚨", subagent_spawned: "🤖",
+        subagent_completed: "🎉", cron_executed: "🕐",
+      };
+      const icon = icons[evt.type] ?? "•";
+      let detail = "";
+      if (evt.tool) detail += ` ${cyan(evt.tool)}`;
+      if (evt.content) detail += ` ${dim(evt.content.slice(0, 60))}`;
+      const sid = evt.sessionId ? dim(` [${evt.sessionId.slice(-8)}]`) : "";
+      console.log(`  ${dim(ts)} ${icon} ${evt.type}${detail}${sid}`);
+    }
+    console.log("");
+  }
+}
+
+export async function cmdTrustReplay(sessionId) {
+  if (!sessionId) {
+    console.log(yellow("Usage: wispy trust replay <session-id>"));
+    return;
+  }
+
+  const { AuditLog } = await import("../../core/audit.mjs");
+  const audit = new AuditLog(WISPY_DIR);
+
+  const steps = await audit.getReplayTrace(sessionId);
+
+  if (steps.length === 0) {
+    console.log(red(`No events found for session: ${sessionId}`));
+    return;
+  }
+
+  console.log(`\n${bold("🎬 Session Replay")} ${dim(sessionId)}\n`);
+  console.log(dim("  Press Enter to advance each step...\n"));
+
+  const { createInterface } = await import("node:readline");
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+
+  const wait = () => new Promise(r => rl.question("", r));
+
+  const icons = {
+    user_message: "👤", assistant_message: "🌿", tool_call: "🔧",
+    tool_result: "✅", approval_requested: "⚠️ ", approval_granted: "✅",
+    approval_denied: "❌", subagent_spawned: "🤖", subagent_completed: "🎉",
+  };
+
+  for (const step of steps) {
+    const ts = new Date(step.timestamp).toLocaleTimeString();
+    const icon = icons[step.type] ?? "•";
+    let detail = "";
+    if (step.content) detail = dim(step.content.slice(0, 100));
+    if (step.tool) detail = `${cyan(step.tool)} ${dim(JSON.stringify(step.args ?? {}).slice(0, 60))}`;
+
+    console.log(`  ${bold(`Step ${step.step}`)} ${dim(ts)} ${icon}  ${detail}`);
+
+    if (step.step < steps.length) {
+      await wait();
+    }
+  }
+
+  rl.close();
+  console.log(dim("\n  Replay complete.\n"));
+}
+
+export async function cmdTrustReceipt(id) {
+  if (!id) {
+    console.log(yellow("Usage: wispy trust receipt <session-id>"));
+    return;
+  }
+
+  const { AuditLog } = await import("../../core/audit.mjs");
+  const audit = new AuditLog(WISPY_DIR);
+
+  const events = await audit.search({ sessionId: id, limit: 100 });
+
+  if (events.length === 0) {
+    console.log(red(`No events found for: ${id}`));
+    return;
+  }
+
+  // Build receipt
+  const toolCalls = events.filter(e => e.type === "tool_call");
+  const approvals = events.filter(e => e.type.startsWith("approval_"));
+  const firstEvent = events[events.length - 1];
+  const lastEvent = events[0];
+
+  const startTime = new Date(firstEvent?.timestamp);
+  const endTime = new Date(lastEvent?.timestamp);
+  const duration = Math.round((endTime - startTime) / 1000);
+
+  console.log(`\n${bold("🧾 Execution Receipt")}\n`);
+  console.log(`  Session: ${cyan(id)}`);
+  console.log(`  Started: ${startTime.toLocaleString()}`);
+  console.log(`  Ended:   ${endTime.toLocaleString()}`);
+  console.log(`  Duration: ${duration}s`);
+  console.log(`  Events:  ${events.length}`);
+  console.log(`  Tool calls: ${toolCalls.length}`);
+
+  if (approvals.length > 0) {
+    console.log(`  Approvals: ${approvals.length}`);
+    for (const a of approvals) {
+      const icon = a.type === "approval_granted" ? green("✓") : a.type === "approval_denied" ? red("✗") : yellow("?");
+      console.log(`    ${icon} ${a.tool ?? a.toolName ?? "?"} — ${a.type.replace("approval_", "")}`);
+    }
+  }
+
+  if (toolCalls.length > 0) {
+    console.log(`\n  ${bold("Tools used:")}`);
+    const toolCounts = {};
+    for (const tc of toolCalls) {
+      const name = tc.tool ?? "?";
+      toolCounts[name] = (toolCounts[name] ?? 0) + 1;
+    }
+    for (const [tool, count] of Object.entries(toolCounts)) {
+      console.log(`    ${cyan(tool)}: ${count}x`);
+    }
+  }
+
+  console.log("");
+}
+
+export async function handleTrustCommand(args) {
+  const sub = args[1];
+
+  if (!sub) return cmdTrustShow();
+  if (sub === "level") return cmdTrustLevel(args[2]);
+  if (sub === "log") return cmdTrustLog(args.slice(2));
+  if (sub === "replay") return cmdTrustReplay(args[2]);
+  if (sub === "receipt") return cmdTrustReceipt(args[2]);
+
+  console.log(`
+${bold("🔐 Trust Commands")}
+
+  wispy trust                              ${dim("show security level + recent approvals")}
+  wispy trust level <careful|balanced|yolo> ${dim("change security level")}
+  wispy trust log                          ${dim("show audit log")}
+  wispy trust replay <session-id>          ${dim("replay session step by step")}
+  wispy trust receipt <session-id>         ${dim("show execution receipt")}
+`);
+}

package/lib/commands/ws.mjs

@@ -0,0 +1,422 @@
+/**
+ * lib/commands/ws.mjs — Workstream CLI commands
+ *
+ * wispy ws                    list all workstreams with last activity
+ * wispy ws new <name>         create new workstream
+ * wispy ws switch <name>      switch active workstream
+ * wispy ws archive <name>     archive workstream
+ * wispy ws status             detailed status of all workstreams
+ * wispy ws search <query>     search across all workstreams
+ * wispy ws delete <name>      delete workstream
+ */
+
+import { readFile, writeFile, mkdir, readdir, stat, rename, rm } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+const WISPY_DIR = path.join(os.homedir(), ".wispy");
+const WORKSTREAMS_DIR = path.join(WISPY_DIR, "workstreams");
+const CONVERSATIONS_DIR = path.join(WISPY_DIR, "conversations");
+const MEMORY_DIR = path.join(WISPY_DIR, "memory");
+const ARCHIVE_DIR = path.join(WISPY_DIR, "archive");
+const CONFIG_PATH = path.join(WISPY_DIR, "config.json");
+
+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 getConfig() {
+  return readJsonOr(CONFIG_PATH, {});
+}
+
+async function saveConfig(cfg) {
+  await mkdir(WISPY_DIR, { recursive: true });
+  await writeFile(CONFIG_PATH, JSON.stringify(cfg, null, 2) + "\n", "utf8");
+}
+
+async function getActiveWorkstream() {
+  const envWs = process.env.WISPY_WORKSTREAM;
+  if (envWs) return envWs;
+  const cfg = await getConfig();
+  return cfg.workstream ?? "default";
+}
+
+/**
+ * Get all workstreams by scanning conversations/ dir (legacy) and workstreams/ dir
+ */
+async function listAllWorkstreams() {
+  const found = new Set(["default"]);
+  const results = [];
+
+  // Scan conversations/
+  try {
+    const files = await readdir(CONVERSATIONS_DIR);
+    for (const f of files) {
+      if (f.endsWith(".json")) found.add(f.replace(".json", ""));
+    }
+  } catch {}
+
+  // Scan workstreams/
+  try {
+    const dirs = await readdir(WORKSTREAMS_DIR);
+    for (const d of dirs) {
+      found.add(d);
+    }
+  } catch {}
+
+  const active = await getActiveWorkstream();
+
+  for (const name of found) {
+    const wsDir = path.join(WORKSTREAMS_DIR, name);
+    const convFile = path.join(CONVERSATIONS_DIR, `${name}.json`);
+    const workMd = path.join(wsDir, "work.md");
+
+    let lastActive = null;
+    let sessionCount = 0;
+
+    // Check conversation file
+    try {
+      const s = await stat(convFile);
+      lastActive = s.mtime;
+      const conv = await readJsonOr(convFile, []);
+      sessionCount = conv.filter(m => m.role === "user").length;
+    } catch {}
+
+    // Check workstream dir
+    try {
+      const s = await stat(wsDir);
+      if (!lastActive || s.mtime > lastActive) lastActive = s.mtime;
+    } catch {}
+
+    results.push({
+      name,
+      isActive: name === active,
+      lastActive,
+      sessionCount,
+      hasWorkMd: existsSync(workMd),
+      wsDir,
+      convFile,
+    });
+  }
+
+  // Sort: active first, then by last activity
+  results.sort((a, b) => {
+    if (a.isActive && !b.isActive) return -1;
+    if (!a.isActive && b.isActive) return 1;
+    const ta = a.lastActive ? a.lastActive.getTime() : 0;
+    const tb = b.lastActive ? b.lastActive.getTime() : 0;
+    return tb - ta;
+  });
+
+  return results;
+}
+
+function formatRelative(date) {
+  if (!date) return dim("never");
+  const diffMs = Date.now() - new Date(date).getTime();
+  const diffMin = Math.floor(diffMs / 60000);
+  const diffH = Math.floor(diffMin / 60);
+  const diffD = Math.floor(diffH / 24);
+  if (diffMin < 1) return green("just now");
+  if (diffMin < 60) return `${diffMin}min ago`;
+  if (diffH < 24) return `${diffH}h ago`;
+  if (diffD < 7) return `${diffD}d ago`;
+  return new Date(date).toLocaleDateString();
+}
+
+// ── Commands ─────────────────────────────────────────────────────────────────
+
+export async function cmdWsList() {
+  const workstreams = await listAllWorkstreams();
+  if (workstreams.length === 0) {
+    console.log(dim("No workstreams yet. Create one: wispy ws new <name>"));
+    return;
+  }
+
+  console.log(`\n${bold("🌿 Workstreams")}\n`);
+  for (const ws of workstreams) {
+    const marker = ws.isActive ? green("●") : "○";
+    const name = ws.isActive ? bold(green(ws.name)) : ws.name;
+    const msgs = ws.sessionCount > 0 ? dim(` · ${ws.sessionCount} msgs`) : "";
+    const last = `  ${dim(formatRelative(ws.lastActive))}`;
+    const plan = ws.hasWorkMd ? cyan(" 📋") : "";
+    console.log(`  ${marker} ${name.padEnd(25)}${last}${msgs}${plan}`);
+  }
+
+  const active = await getActiveWorkstream();
+  console.log(dim(`\n  Active: ${active}   Switch: wispy ws <name>   Create: wispy ws new <name>\n`));
+}
+
+export async function cmdWsNew(name) {
+  if (!name) {
+    console.log(yellow("Usage: wispy ws new <name>"));
+    return;
+  }
+
+  const wsDir = path.join(WORKSTREAMS_DIR, name);
+  await mkdir(wsDir, { recursive: true });
+
+  const workMd = path.join(wsDir, "work.md");
+  const workMdContent = `# ${name} Workstream
+
+## Current Work
+
+> Update this as you progress.
+
+## Goals
+
+
+## Context
+
+
+## Next Steps
+
+
+## Notes
+
+`;
+  await writeFile(workMd, workMdContent, "utf8");
+
+  // Also create conversations entry
+  await mkdir(CONVERSATIONS_DIR, { recursive: true });
+  const convFile = path.join(CONVERSATIONS_DIR, `${name}.json`);
+  if (!existsSync(convFile)) {
+    await writeFile(convFile, "[]", "utf8");
+  }
+
+  console.log(green(`✅ Created workstream: ${name}`));
+  console.log(dim(`   Dir: ${wsDir}`));
+  console.log(dim(`   Run: wispy ws switch ${name}  — to activate`));
+}
+
+export async function cmdWsSwitch(name) {
+  if (!name) {
+    console.log(yellow("Usage: wispy ws switch <name>"));
+    return;
+  }
+
+  const cfg = await getConfig();
+  cfg.workstream = name;
+  await saveConfig(cfg);
+
+  console.log(green(`✅ Active workstream: ${bold(name)}`));
+  console.log(dim(`   Start a session: wispy (or set WISPY_WORKSTREAM=${name})`));
+}
+
+export async function cmdWsArchive(name) {
+  if (!name) {
+    console.log(yellow("Usage: wispy ws archive <name>"));
+    return;
+  }
+
+  const archiveWsDir = path.join(ARCHIVE_DIR, name);
+  await mkdir(archiveWsDir, { recursive: true });
+
+  let moved = 0;
+
+  // Move workstream dir
+  const wsDir = path.join(WORKSTREAMS_DIR, name);
+  if (existsSync(wsDir)) {
+    await rename(wsDir, path.join(archiveWsDir, "workstream")).catch(() => {});
+    moved++;
+  }
+
+  // Move conversation
+  const convFile = path.join(CONVERSATIONS_DIR, `${name}.json`);
+  if (existsSync(convFile)) {
+    await rename(convFile, path.join(archiveWsDir, "conversation.json")).catch(() => {});
+    moved++;
+  }
+
+  if (moved === 0) {
+    console.log(yellow(`Workstream '${name}' not found or already archived.`));
+    return;
+  }
+
+  console.log(green(`📦 Archived workstream: ${name}`));
+  console.log(dim(`   Archive: ${archiveWsDir}`));
+}
+
+export async function cmdWsStatus() {
+  const workstreams = await listAllWorkstreams();
+
+  console.log(`\n${bold("🌿 Workstream Status")}\n`);
+
+  for (const ws of workstreams) {
+    const marker = ws.isActive ? green("●") : "○";
+    const name = ws.isActive ? bold(green(ws.name)) : bold(ws.name);
+    console.log(`${marker} ${name}`);
+
+    // Session count
+    console.log(`   Sessions: ${ws.sessionCount} messages`);
+
+    // Last active
+    console.log(`   Last active: ${formatRelative(ws.lastActive)}`);
+
+    // Memory files
+    const wsMemDir = path.join(ws.wsDir, "memory");
+    try {
+      const memFiles = await readdir(wsMemDir);
+      console.log(`   Memory: ${memFiles.length} files`);
+    } catch {
+      const globalMemFiles = await readdir(MEMORY_DIR).catch(() => []);
+      if (ws.isActive) console.log(`   Memory: ${globalMemFiles.length} files (global)`);
+    }
+
+    // Work.md preview
+    if (ws.hasWorkMd) {
+      try {
+        const workMdContent = await readFile(path.join(ws.wsDir, "work.md"), "utf8");
+        const lines = workMdContent.split("\n").filter(l => l.trim() && !l.startsWith("#")).slice(0, 2);
+        if (lines.length > 0) {
+          console.log(dim(`   Work: ${lines[0].replace(/^[>*\-] /, "").slice(0, 60)}`));
+        }
+      } catch {}
+    }
+
+    console.log("");
+  }
+}
+
+export async function cmdWsSearch(query) {
+  if (!query) {
+    console.log(yellow("Usage: wispy ws search <query>"));
+    return;
+  }
+
+  const workstreams = await listAllWorkstreams();
+  const lowerQuery = query.toLowerCase();
+
+  console.log(`\n${bold("🔍 Searching workstreams for:")} ${cyan(query)}\n`);
+  let totalMatches = 0;
+
+  for (const ws of workstreams) {
+    const matches = [];
+
+    // Search conversation
+    try {
+      const conv = await readJsonOr(ws.convFile, []);
+      const convMatches = conv.filter(m =>
+        (m.role === "user" || m.role === "assistant") &&
+        m.content?.toLowerCase().includes(lowerQuery)
+      );
+      for (const m of convMatches.slice(-3)) {
+        const preview = m.content.replace(/\n/g, " ").slice(0, 80);
+        matches.push(`  ${m.role === "user" ? "👤" : "🌿"} ${dim(preview + (m.content.length > 80 ? "..." : ""))}`);
+      }
+    } catch {}
+
+    // Search work.md
+    if (ws.hasWorkMd) {
+      try {
+        const content = await readFile(path.join(ws.wsDir, "work.md"), "utf8");
+        if (content.toLowerCase().includes(lowerQuery)) {
+          const lines = content.split("\n").filter(l => l.toLowerCase().includes(lowerQuery)).slice(0, 2);
+          for (const l of lines) {
+            matches.push(`  📋 ${dim(l.trim().slice(0, 80))}`);
+          }
+        }
+      } catch {}
+    }
+
+    if (matches.length > 0) {
+      const name = ws.isActive ? bold(green(ws.name)) : bold(ws.name);
+      console.log(`${name} (${matches.length} match${matches.length === 1 ? "" : "es"}):`);
+      matches.forEach(m => console.log(m));
+      console.log("");
+      totalMatches += matches.length;
+    }
+  }
+
+  if (totalMatches === 0) {
+    console.log(dim(`No matches found for "${query}"`));
+  }
+}
+
+export async function cmdWsDelete(name) {
+  if (!name) {
+    console.log(yellow("Usage: wispy ws delete <name>"));
+    return;
+  }
+
+  if (name === "default") {
+    console.log(red("Cannot delete the default workstream."));
+    return;
+  }
+
+  const wsDir = path.join(WORKSTREAMS_DIR, name);
+  const convFile = path.join(CONVERSATIONS_DIR, `${name}.json`);
+
+  let deleted = 0;
+
+  if (existsSync(wsDir)) {
+    await rm(wsDir, { recursive: true, force: true });
+    deleted++;
+  }
+
+  if (existsSync(convFile)) {
+    const { unlink } = await import("node:fs/promises");
+    await unlink(convFile).catch(() => {});
+    deleted++;
+  }
+
+  if (deleted === 0) {
+    console.log(red(`Workstream '${name}' not found.`));
+    return;
+  }
+
+  // If it was active, reset to default
+  const cfg = await getConfig();
+  if (cfg.workstream === name) {
+    cfg.workstream = "default";
+    await saveConfig(cfg);
+    console.log(dim("  Reset active workstream to: default"));
+  }
+
+  console.log(green(`🗑️  Deleted workstream: ${name}`));
+}
+
+export async function handleWsCommand(args) {
+  const sub = args[1];
+
+  if (!sub) {
+    return cmdWsList();
+  }
+
+  if (sub === "new") return cmdWsNew(args[2]);
+  if (sub === "switch") return cmdWsSwitch(args[2]);
+  if (sub === "archive") return cmdWsArchive(args[2]);
+  if (sub === "status") return cmdWsStatus();
+  if (sub === "search") return cmdWsSearch(args.slice(2).join(" "));
+  if (sub === "delete" || sub === "rm") return cmdWsDelete(args[2]);
+
+  // If sub is not a keyword, treat it as a shortcut for ws switch
+  if (!["new", "switch", "archive", "status", "search", "delete", "rm", "--help", "-h"].includes(sub)) {
+    return cmdWsSwitch(sub);
+  }
+
+  console.log(`
+${bold("🌿 Workstream Commands")}
+
+  wispy ws                    ${dim("list all workstreams")}
+  wispy ws new <name>         ${dim("create new workstream")}
+  wispy ws switch <name>      ${dim("switch active workstream")}
+  wispy ws <name>             ${dim("shortcut for switch")}
+  wispy ws archive <name>     ${dim("archive workstream")}
+  wispy ws status             ${dim("detailed status")}
+  wispy ws search <query>     ${dim("search across all workstreams")}
+  wispy ws delete <name>      ${dim("delete workstream")}
+`);
+}

package/package.json

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