wispy-cli 2.7.14 → 2.7.15

package/bin/wispy.mjs

@@ -60,6 +60,16 @@ const globalPersonality = extractFlag(["--personality"], true);
 const globalJsonMode = hasFlag("--json");
 if (globalJsonMode) { args.splice(args.indexOf("--json"), 1); }
 
+// New flags: system prompt, session name, effort, agent, budget, tool allow/deny
+const globalSystemPrompt = extractFlag(["--system-prompt"], true);
+const globalAppendSystemPrompt = extractFlag(["--append-system-prompt"], true);
+const globalSessionName = extractFlag(["--name"], true);
+const globalAgent = extractFlag(["--agent"], true);
+const globalEffort = extractFlag(["--effort"], true);
+const globalMaxBudget = extractFlag(["--max-budget-usd"], true);
+const globalAllowedTools = extractFlag(["--allowedTools", "--allowed-tools"], true);
+const globalDisallowedTools = extractFlag(["--disallowedTools", "--disallowed-tools"], true);
+
 // Parse image flags: -i <path> or --image <path> (multiple allowed)
 const imagePaths = [];
 {
@@ -78,6 +88,14 @@ const imagePaths = [];
 if (globalProfile) process.env.WISPY_PROFILE = globalProfile;
 if (globalPersonality) process.env.WISPY_PERSONALITY = globalPersonality;
 if (imagePaths.length > 0) process.env.WISPY_IMAGES = JSON.stringify(imagePaths);
+if (globalSystemPrompt) process.env.WISPY_SYSTEM_PROMPT = globalSystemPrompt;
+if (globalAppendSystemPrompt) process.env.WISPY_APPEND_SYSTEM_PROMPT = globalAppendSystemPrompt;
+if (globalSessionName) process.env.WISPY_SESSION_NAME = globalSessionName;
+if (globalAgent) process.env.WISPY_AGENT = globalAgent;
+if (globalEffort) process.env.WISPY_EFFORT = globalEffort;
+if (globalMaxBudget) process.env.WISPY_MAX_BUDGET_USD = globalMaxBudget;
+if (globalAllowedTools) process.env.WISPY_ALLOWED_TOOLS = globalAllowedTools;
+if (globalDisallowedTools) process.env.WISPY_DISALLOWED_TOOLS = globalDisallowedTools;
 
 // ── Flags ─────────────────────────────────────────────────────────────────────
 
@@ -134,22 +152,75 @@ Usage:
   wispy review --base <branch> Review changes against branch
   wispy review --commit <sha>  Review a specific commit
   wispy review --json          Output review as JSON
+  wispy agents [list]          List available agents (built-in + custom)
+  wispy cost                   Show API spending report
 
 Options:
   -w, --workstream <name>      Set active workstream
   -p, --profile <name>         Use a named config profile
   -i, --image <path>           Attach image (can use multiple times)
   --session <id>               Resume a session
+  --name <name>                Give this session a display name (e.g. --name "refactor-auth")
   --model <name>               Override AI model
   --provider <name>            Override AI provider
   --personality <name>         Set personality (pragmatic|concise|explanatory|friendly|strict)
+  --agent <name>               Use a named agent (reviewer|planner|explorer|custom)
+  --effort <level>             Effort level: low|medium|high|max (default: medium)
+  --system-prompt <prompt>     Replace the default system prompt entirely
+  --append-system-prompt <p>   Append text to the default system prompt
+  --max-budget-usd <amount>    Session budget cap in USD (e.g. 5.00)
+  --allowedTools <patterns>    Only allow specified tools (e.g. "read_file Bash(git:*)")
+  --disallowedTools <patterns> Block specified tools (e.g. "write_file delete_file")
   --json                       Output JSONL events (for exec command, CI/pipeline use)
   --help, -h                   Show this help
   --version, -v                Show version
+
+Project settings:
+  .wispy/settings.json         Per-project config (model, personality, tools, agents, etc.)
+                               Wispy walks up from cwd to find this file.
 `);
   process.exit(0);
 }
 
+// ── Agents ────────────────────────────────────────────────────────────────────
+
+if (command === "agents" || command === "agent") {
+  try {
+    const { loadConfig } = await import(join(rootDir, "core/config.mjs"));
+    const { AgentManager } = await import(join(rootDir, "core/agents.mjs"));
+
+    const sub = args[1];
+    const config = await loadConfig();
+    const mgr = new AgentManager(config);
+
+    if (!sub || sub === "list") {
+      console.log(mgr.formatList());
+    } else {
+      console.error(`Unknown subcommand: ${sub}`);
+      console.log("Available: list");
+      process.exit(1);
+    }
+  } catch (err) {
+    console.error("Agents error:", err.message);
+    process.exit(1);
+  }
+  process.exit(0);
+}
+
+// ── Cost / Budget ──────────────────────────────────────────────────────────────
+
+if (command === "cost" || command === "budget") {
+  try {
+    const { BudgetManager } = await import(join(rootDir, "core/budget.mjs"));
+    const budget = new BudgetManager();
+    console.log(await budget.formatReport());
+  } catch (err) {
+    console.error("Cost error:", err.message);
+    process.exit(1);
+  }
+  process.exit(0);
+}
+
 // ── Setup (first-run wizard) ──────────────────────────────────────────────────
 
 if (command === "setup") {
@@ -680,9 +751,18 @@ if (command === "exec") {
     if (profileConfig.model)    process.env.WISPY_MODEL = process.env.WISPY_MODEL || profileConfig.model;
 
     const personality = globalPersonality || profileConfig.personality || null;
+    const effort = globalEffort || profileConfig.effort || null;
+    const maxBudgetUsd = globalMaxBudget ? parseFloat(globalMaxBudget) : null;
+    const allowedTools = globalAllowedTools || null;
+    const disallowedTools = globalDisallowedTools || null;
+    const agent = globalAgent || null;
 
     const engine = new WispyEngine({
       personality,
+      effort,
+      maxBudgetUsd,
+      allowedTools,
+      disallowedTools,
       workstream: process.env.WISPY_WORKSTREAM ?? "default",
     });
 
@@ -698,11 +778,17 @@ if (command === "exec") {
       process.exit(1);
     }
 
+    // Apply tool allow/deny to harness
+    if (allowedTools) engine.harness.setAllowedTools(allowedTools);
+    if (disallowedTools) engine.harness.setDisallowedTools(disallowedTools);
+
     const emitter = createEmitter(globalJsonMode);
 
     const result = await engine.processMessage(null, message, {
       emitter,
       personality,
+      effort,
+      agent,
       skipSkillCapture: true,
       skipUserModel: true,
     });

package/core/budget.mjs

@@ -0,0 +1,277 @@
+/**
+ * core/budget.mjs — API Spending Tracker for Wispy
+ *
+ * Tracks API costs per session and across sessions.
+ * Persisted to ~/.wispy/budget.json
+ *
+ * Usage:
+ *   const budget = new BudgetManager({ maxBudgetUsd: 5.00 });
+ *   budget.record(1000, 500, "gpt-4o");
+ *   const check = budget.checkBudget();
+ *   // { ok: true, remaining: 4.98, spent: 0.02 }
+ */
+
+import os from "node:os";
+import path from "node:path";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+
+// ── Model pricing (approximate, USD per 1M tokens) ────────────────────────────
+
+export const MODEL_PRICING = {
+  // OpenAI
+  "gpt-4o":                       { input: 2.50,  output: 10.00 },
+  "gpt-4o-mini":                  { input: 0.15,  output: 0.60  },
+  "gpt-4-turbo":                  { input: 10.00, output: 30.00 },
+  "gpt-4":                        { input: 30.00, output: 60.00 },
+  "o1":                           { input: 15.00, output: 60.00 },
+  "o1-mini":                      { input: 3.00,  output: 12.00 },
+  "o3":                           { input: 10.00, output: 40.00 },
+  "o3-mini":                      { input: 1.10,  output: 4.40  },
+  "o4-mini":                      { input: 1.10,  output: 4.40  },
+
+  // Anthropic
+  "claude-opus-4-20250514":       { input: 15.00, output: 75.00 },
+  "claude-sonnet-4-20250514":     { input: 3.00,  output: 15.00 },
+  "claude-3-5-sonnet-20241022":   { input: 3.00,  output: 15.00 },
+  "claude-3-5-haiku-20241022":    { input: 0.80,  output: 4.00  },
+  "claude-3-opus-20240229":       { input: 15.00, output: 75.00 },
+
+  // Google
+  "gemini-2.5-pro":               { input: 1.25,  output: 10.00 },
+  "gemini-2.5-flash":             { input: 0.075, output: 0.30  },
+  "gemini-2.0-flash":             { input: 0.075, output: 0.30  },
+  "gemini-1.5-pro":               { input: 1.25,  output: 5.00  },
+  "gemini-1.5-flash":             { input: 0.075, output: 0.30  },
+
+  // DeepSeek
+  "deepseek-chat":                { input: 0.14,  output: 0.28  },
+  "deepseek-coder":               { input: 0.14,  output: 0.28  },
+  "deepseek-reasoner":            { input: 0.55,  output: 2.19  },
+
+  // Groq (free for now, but tracking usage)
+  "llama-3.3-70b-versatile":      { input: 0,     output: 0     },
+  "llama-3.1-8b-instant":         { input: 0,     output: 0     },
+  "mixtral-8x7b-32768":           { input: 0,     output: 0     },
+  "gemma2-9b-it":                 { input: 0,     output: 0     },
+
+  // Mistral
+  "mistral-large-latest":         { input: 2.00,  output: 6.00  },
+  "mistral-small-latest":         { input: 0.20,  output: 0.60  },
+  "codestral-latest":             { input: 1.00,  output: 3.00  },
+
+  // xAI
+  "grok-3":                       { input: 3.00,  output: 15.00 },
+  "grok-3-mini":                  { input: 0.30,  output: 0.50  },
+};
+
+// ── BudgetManager ─────────────────────────────────────────────────────────────
+
+export class BudgetManager {
+  /**
+   * @param {object} options
+   * @param {number|null} options.maxBudgetUsd - Max budget for this session (null = unlimited)
+   * @param {string} options.budgetPath - Path to persist budget.json
+   */
+  constructor(options = {}) {
+    this.maxBudgetUsd = options.maxBudgetUsd ?? null;
+    this.sessionSpend = 0;       // USD spent this session
+    this.sessionInputTokens = 0;
+    this.sessionOutputTokens = 0;
+    this.sessionCalls = 0;
+    this.totalSpend = 0;         // loaded from disk
+    this.totalInputTokens = 0;
+    this.totalOutputTokens = 0;
+    this.totalCalls = 0;
+    this._budgetPath = options.budgetPath ?? path.join(os.homedir(), ".wispy", "budget.json");
+    this._loaded = false;
+  }
+
+  /**
+   * Load persisted budget data from disk (lazy).
+   */
+  async _ensureLoaded() {
+    if (this._loaded) return;
+    this._loaded = true;
+    try {
+      const raw = await readFile(this._budgetPath, "utf8");
+      const data = JSON.parse(raw);
+      this.totalSpend = data.totalSpend ?? 0;
+      this.totalInputTokens = data.totalInputTokens ?? 0;
+      this.totalOutputTokens = data.totalOutputTokens ?? 0;
+      this.totalCalls = data.totalCalls ?? 0;
+    } catch {
+      // File doesn't exist yet — start fresh
+    }
+  }
+
+  /**
+   * Persist total spend to disk.
+   */
+  async _persist() {
+    try {
+      await mkdir(path.dirname(this._budgetPath), { recursive: true });
+      await writeFile(
+        this._budgetPath,
+        JSON.stringify({
+          totalSpend: this.totalSpend,
+          totalInputTokens: this.totalInputTokens,
+          totalOutputTokens: this.totalOutputTokens,
+          totalCalls: this.totalCalls,
+          updatedAt: new Date().toISOString(),
+        }, null, 2) + "\n",
+        "utf8",
+      );
+    } catch { /* ignore write errors */ }
+  }
+
+  /**
+   * Get pricing for a model. Returns { input, output } in USD/1M tokens.
+   * Returns { input: 0, output: 0 } for unknown models (assume free/included).
+   * @param {string} model
+   */
+  getPricing(model) {
+    if (!model) return { input: 0, output: 0 };
+    // Exact match
+    if (MODEL_PRICING[model]) return MODEL_PRICING[model];
+    // Prefix match (e.g., "claude-sonnet-4" matches "claude-sonnet-4-20250514")
+    for (const [key, price] of Object.entries(MODEL_PRICING)) {
+      if (model.startsWith(key) || key.startsWith(model)) return price;
+    }
+    return { input: 0, output: 0 };
+  }
+
+  /**
+   * Estimate cost of an API call without recording it.
+   * @param {number} inputTokens
+   * @param {number} outputTokens
+   * @param {string} model
+   * @returns {number} Estimated cost in USD
+   */
+  estimateCost(inputTokens, outputTokens, model) {
+    const pricing = this.getPricing(model);
+    const inputCost = (inputTokens / 1_000_000) * pricing.input;
+    const outputCost = (outputTokens / 1_000_000) * pricing.output;
+    return inputCost + outputCost;
+  }
+
+  /**
+   * Record actual API usage after a call.
+   * @param {number} inputTokens
+   * @param {number} outputTokens
+   * @param {string} model
+   * @returns {number} Cost of this call in USD
+   */
+  async record(inputTokens, outputTokens, model) {
+    await this._ensureLoaded();
+
+    const cost = this.estimateCost(inputTokens || 0, outputTokens || 0, model);
+
+    this.sessionSpend += cost;
+    this.sessionInputTokens += inputTokens || 0;
+    this.sessionOutputTokens += outputTokens || 0;
+    this.sessionCalls++;
+
+    this.totalSpend += cost;
+    this.totalInputTokens += inputTokens || 0;
+    this.totalOutputTokens += outputTokens || 0;
+    this.totalCalls++;
+
+    // Persist async (don't await — non-blocking)
+    this._persist().catch(() => {});
+
+    return cost;
+  }
+
+  /**
+   * Check whether the current session is within budget.
+   * @returns {{ ok: boolean, remaining: number|null, spent: number }}
+   */
+  checkBudget() {
+    if (this.maxBudgetUsd === null) {
+      return { ok: true, remaining: null, spent: this.sessionSpend };
+    }
+    const remaining = this.maxBudgetUsd - this.sessionSpend;
+    return {
+      ok: remaining >= 0,
+      remaining,
+      spent: this.sessionSpend,
+      limit: this.maxBudgetUsd,
+    };
+  }
+
+  /**
+   * Get a spending report.
+   * @returns {object}
+   */
+  async getReport() {
+    await this._ensureLoaded();
+    return {
+      session: {
+        spend: this.sessionSpend,
+        inputTokens: this.sessionInputTokens,
+        outputTokens: this.sessionOutputTokens,
+        calls: this.sessionCalls,
+        limit: this.maxBudgetUsd,
+        remaining: this.maxBudgetUsd !== null ? this.maxBudgetUsd - this.sessionSpend : null,
+      },
+      total: {
+        spend: this.totalSpend,
+        inputTokens: this.totalInputTokens,
+        outputTokens: this.totalOutputTokens,
+        calls: this.totalCalls,
+      },
+    };
+  }
+
+  /**
+   * Format a spending report for CLI display.
+   */
+  async formatReport() {
+    const report = await this.getReport();
+    const fmt = (n) => `$${n.toFixed(4)}`;
+    const fmtTokens = (n) => n >= 1000 ? `${(n / 1000).toFixed(1)}k` : String(n);
+
+    const lines = ["\n  💰 Wispy Spending Report\n"];
+
+    lines.push("  This session:");
+    lines.push(`    Spent:    ${fmt(report.session.spend)}`);
+    if (report.session.limit !== null) {
+      const pct = ((report.session.spend / report.session.limit) * 100).toFixed(1);
+      const bar = this._progressBar(report.session.spend, report.session.limit, 20);
+      lines.push(`    Budget:   ${fmt(report.session.spend)} / ${fmt(report.session.limit)}  [${bar}] ${pct}%`);
+      lines.push(`    Remaining: ${fmt(Math.max(0, report.session.remaining))}`);
+    }
+    lines.push(`    Tokens:   ${fmtTokens(report.session.inputTokens)} in + ${fmtTokens(report.session.outputTokens)} out`);
+    lines.push(`    API calls: ${report.session.calls}`);
+
+    lines.push("\n  All time:");
+    lines.push(`    Spent:    ${fmt(report.total.spend)}`);
+    lines.push(`    Tokens:   ${fmtTokens(report.total.inputTokens)} in + ${fmtTokens(report.total.outputTokens)} out`);
+    lines.push(`    API calls: ${report.total.calls}`);
+    lines.push("");
+
+    return lines.join("\n");
+  }
+
+  _progressBar(value, max, width = 20) {
+    if (max <= 0) return " ".repeat(width);
+    const filled = Math.min(width, Math.round((value / max) * width));
+    const color = filled > width * 0.8 ? "\x1b[31m" : filled > width * 0.5 ? "\x1b[33m" : "\x1b[32m";
+    return `${color}${"█".repeat(filled)}\x1b[0m${"░".repeat(width - filled)}`;
+  }
+
+  /**
+   * Format a budget exceeded warning.
+   */
+  formatExceededWarning() {
+    const check = this.checkBudget();
+    return [
+      "",
+      "  \x1b[31m⛔ Budget limit reached!\x1b[0m",
+      `  Spent: $${this.sessionSpend.toFixed(4)} / $${this.maxBudgetUsd.toFixed(4)} limit`,
+      `  Session ended to prevent overspending.`,
+      `  Use --max-budget-usd to set a higher limit, or run without it for unlimited.`,
+      "",
+    ].join("\n");
+  }
+}

package/core/engine.mjs

@@ -15,6 +15,7 @@ import path from "node:path";
 import { readFile, writeFile, mkdir, appendFile, stat as fsStat } from "node:fs/promises";
 
 import { WISPY_DIR, CONVERSATIONS_DIR, MEMORY_DIR, MCP_CONFIG_PATH, detectProvider, PROVIDERS } from "./config.mjs";
+import { findProjectSettings, mergeSettings } from "./project-settings.mjs";
 import { NullEmitter } from "../lib/jsonl-emitter.mjs";
 
 /**
@@ -44,6 +45,33 @@ import { routeTask, classifyTask, filterAvailableModels } from "./task-router.mj
 import { decomposeTask, executeDecomposedPlan } from "./task-decomposer.mjs";
 import { BrowserBridge } from "./browser.mjs";
 import { LoopDetector } from "./loop-detector.mjs";
+import { AgentManager } from "./agents.mjs";
+import { BudgetManager } from "./budget.mjs";
+
+// ── Effort levels ──────────────────────────────────────────────────────────────
+
+export const EFFORT_LEVELS = {
+  low: {
+    maxRounds: 5,
+    maxTokens: 2000,
+    systemSuffix: "Be extremely brief. One-shot answers preferred. Minimize tool use.",
+  },
+  medium: {
+    maxRounds: 15,
+    maxTokens: 4000,
+    systemSuffix: "", // default behavior
+  },
+  high: {
+    maxRounds: 30,
+    maxTokens: 8000,
+    systemSuffix: "Be thorough. Explore multiple approaches. Verify your work.",
+  },
+  max: {
+    maxRounds: 50,
+    maxTokens: 16000,
+    systemSuffix: "Be exhaustive. Leave no stone unturned. Multiple verification passes. Consider edge cases.",
+  },
+};
 
 const MAX_TOOL_ROUNDS = 10;
 const MAX_CONTEXT_CHARS = 40_000;
@@ -74,6 +102,15 @@ export class WispyEngine {
       ?? "default";
     // Personality: from config, or null (use default Wispy personality)
     this._personality = config.personality ?? null;
+    // Agent manager
+    this.agentManager = new AgentManager(config);
+    // Effort level: low | medium | high | max
+    this._effort = config.effort ?? process.env.WISPY_EFFORT ?? "medium";
+    // Budget manager
+    this.budget = new BudgetManager({
+      maxBudgetUsd: config.maxBudgetUsd ?? null,
+      budgetPath: config.budgetPath,
+    });
   }
 
   get activeWorkstream() { return this._activeWorkstream; }
@@ -168,13 +205,25 @@ export class WispyEngine {
       if (sessionId) {
         session = this.sessions.get(sessionId) ?? await this.sessions.load(sessionId);
         if (!session) {
-          session = this.sessions.create({ workstream: opts.workstream ?? this._activeWorkstream });
+          session = this.sessions.create({
+            workstream: opts.workstream ?? this._activeWorkstream,
+            name: opts.sessionName ?? null,
+          });
+        } else if (opts.sessionName && !session.name) {
+          // Set name on existing session if not already named
+          session.name = opts.sessionName;
         }
       } else {
-        session = this.sessions.create({ workstream: opts.workstream ?? this._activeWorkstream });
+        session = this.sessions.create({
+          workstream: opts.workstream ?? this._activeWorkstream,
+          name: opts.sessionName ?? null,
+        });
       }
     } catch (err) {
-      session = this.sessions.create({ workstream: opts.workstream ?? this._activeWorkstream });
+      session = this.sessions.create({
+        workstream: opts.workstream ?? this._activeWorkstream,
+        name: opts.sessionName ?? null,
+      });
     }
 
     // JSONL emitter (no-op by default)
@@ -192,10 +241,44 @@ export class WispyEngine {
     // Resolve personality for this call
     const personality = opts.personality ?? this._personality ?? null;
 
+    // Resolve effort level for this call
+    const effort = opts.effort ?? this._effort ?? "medium";
+    const effortConfig = EFFORT_LEVELS[effort] ?? EFFORT_LEVELS.medium;
+
+    // Resolve agent for this call
+    const agentName = opts.agent ?? null;
+    const agentDef = agentName ? this.agentManager.get(agentName) : null;
+    if (agentName && !agentDef) {
+      return {
+        role: "assistant",
+        content: `⚠️ Unknown agent: "${agentName}". Run \`wispy agents\` to list available agents.`,
+        sessionId: session.id,
+        error: "UNKNOWN_AGENT",
+      };
+    }
+
+    // Check budget before processing
+    const budgetCheck = this.budget.checkBudget();
+    if (!budgetCheck.ok) {
+      return {
+        role: "assistant",
+        content: this.budget.formatExceededWarning(),
+        sessionId: session.id,
+        error: "BUDGET_EXCEEDED",
+      };
+    }
+
     // Build messages array for the provider
+    // opts.systemPrompt = full override, opts.appendSystemPrompt = append to default
     let systemPrompt;
     try {
-      systemPrompt = opts.systemPrompt ?? await this._buildSystemPrompt(userMessage, { personality });
+      systemPrompt = await this._buildSystemPrompt(userMessage, {
+        personality,
+        agentDef,
+        effortConfig,
+        systemPrompt: opts.systemPrompt ?? null,
+        appendSystemPrompt: opts.appendSystemPrompt ?? null,
+      });
     } catch {
       systemPrompt = "You are Wispy 🌿 — a helpful AI assistant in the terminal.";
     }
@@ -236,7 +319,7 @@ export class WispyEngine {
     const _startMs = Date.now();
     let responseText;
     try {
-      responseText = await this._agentLoop(messages, session, { ...opts, emitter });
+      responseText = await this._agentLoop(messages, session, { ...opts, emitter, effortConfig, agentDef });
     } catch (err) {
       responseText = this._friendlyError(err);
       emitter.error(err);
@@ -345,7 +428,11 @@ export class WispyEngine {
     const loopDetector = new LoopDetector();
     let loopWarned = false;
 
-    for (let round = 0; round < MAX_TOOL_ROUNDS; round++) {
+    // Effort level config
+    const effortConfig = opts.effortConfig ?? EFFORT_LEVELS.medium;
+    const maxRounds = effortConfig.maxRounds ?? MAX_TOOL_ROUNDS;
+
+    for (let round = 0; round < maxRounds; round++) {
       // ── Loop detection check before LLM call ─────────────────────────────
       if (loopDetector.size >= 2) {
         const loopCheck = loopDetector.check();
@@ -373,11 +460,25 @@ export class WispyEngine {
         }
       }
 
+      // Use agent model if specified
+      const agentDef = opts.agentDef ?? null;
+      const resolvedModel = agentDef?.model ?? opts.model;
+
       const result = await this.providers.chat(messages, this.tools.getDefinitions(), {
         onChunk: opts.onChunk,
-        model: opts.model,
+        model: resolvedModel,
+        maxTokens: effortConfig.maxTokens,
       });
 
+      // Record spend if usage info available
+      if (result?.usage) {
+        this.budget.record(
+          result.usage.inputTokens ?? result.usage.prompt_tokens ?? 0,
+          result.usage.outputTokens ?? result.usage.completion_tokens ?? 0,
+          resolvedModel ?? this.model,
+        ).catch(() => {});
+      }
+
       if (result.type === "text") {
         return result.text;
       }
@@ -426,7 +527,8 @@ export class WispyEngine {
       }
     }
 
-    return "(tool call limit reached)";
+    const effortName = Object.entries(EFFORT_LEVELS).find(([, v]) => v === effortConfig)?.[0] ?? "medium";
+    return `(tool call limit reached — effort: ${effortName}, max rounds: ${maxRounds})`;
   }
 
   /**
@@ -872,6 +974,52 @@ export class WispyEngine {
 
   async _buildSystemPrompt(lastUserMessage = "", opts = {}) {
     const personality = opts.personality ?? this._personality ?? null;
+    const agentDef = opts.agentDef ?? null;
+    const effortConfig = opts.effortConfig ?? null;
+
+    // Resolve system prompt override with precedence:
+    // opts.systemPrompt (call-level) > this._systemPrompt (engine config) > default
+    // Resolve append with precedence:
+    // opts.appendSystemPrompt (call-level) > this._appendSystemPrompt (engine config) > project settings
+    const systemPromptOverride = opts.systemPrompt ?? this._systemPrompt ?? null;
+    const appendSystemPrompt = opts.appendSystemPrompt ?? this._appendSystemPrompt ?? null;
+
+    // If a full system prompt override is provided (not from agent), use it as-is
+    // then apply appends
+    if (systemPromptOverride && !agentDef?.prompt) {
+      const parts = [systemPromptOverride];
+      if (appendSystemPrompt) {
+        parts.push("\n" + appendSystemPrompt);
+      }
+      if (personality && PERSONALITIES[personality]) {
+        parts.push(`\n## Personality Override (${personality})\n${PERSONALITIES[personality]}`);
+      }
+      if (effortConfig?.systemSuffix) {
+        parts.push("\n## Effort Level\n" + effortConfig.systemSuffix);
+      }
+      return parts.join("");
+    }
+
+    // If an agent with a custom prompt is active, use that as the system prompt base
+    if (agentDef?.prompt) {
+      const parts = [agentDef.prompt];
+      // Append effort suffix if effort is not medium/default
+      if (effortConfig?.systemSuffix) {
+        parts.push("\n" + effortConfig.systemSuffix);
+      }
+      // Append custom system prompt addition if provided
+      if (appendSystemPrompt) {
+        parts.push("\n" + appendSystemPrompt);
+      }
+      // Still inject memories for context
+      try {
+        const memories = await this.memory.getContextForPrompt(lastUserMessage);
+        if (memories) {
+          parts.push("\n## Persistent Memory\n" + memories);
+        }
+      } catch { /* ignore */ }
+      return parts.join("\n");
+    }
 
     const parts = [
       "You are Wispy 🌿 — a small ghost that lives in terminals.",
@@ -879,6 +1027,13 @@ export class WispyEngine {
       "",
     ];
 
+    // Inject effort level modifier if not default (medium)
+    if (effortConfig?.systemSuffix) {
+      parts.push("## Effort Level");
+      parts.push(effortConfig.systemSuffix);
+      parts.push("");
+    }
+
     // Inject personality override if set
     if (personality && PERSONALITIES[personality]) {
       parts.push(`## Personality Override (${personality})`);
@@ -943,6 +1098,11 @@ export class WispyEngine {
       }
     }
 
+    // Append custom system prompt addition (from opts, engine config, or project settings)
+    if (appendSystemPrompt) {
+      parts.push("## Additional Instructions", appendSystemPrompt, "");
+    }
+
     return parts.join("\n");
   }
 

package/core/harness.mjs

@@ -19,6 +19,99 @@ import os from "node:os";
 
 import { EVENT_TYPES } from "./audit.mjs";
 
+// ── Tool allow/deny patterns ───────────────────────────────────────────────────
+
+/**
+ * Claude Code compatible tool name aliases.
+ * Maps user-facing alias to internal tool name.
+ */
+export const TOOL_ALIASES = {
+  "Bash":      "run_command",
+  "Edit":      "file_edit",
+  "Write":     "write_file",
+  "Read":      "read_file",
+  "Grep":      "file_search",
+  "LS":        "list_directory",
+  "WebSearch": "web_search",
+};
+
+/**
+ * Parse a tool pattern string like:
+ *   "Bash(git:*)"  → { tool: "run_command", argPattern: "git *" }
+ *   "Edit"         → { tool: "file_edit", argPattern: "*" }
+ *   "Read(*.ts)"   → { tool: "read_file", argPattern: "*.ts" }
+ *   "run_command"  → { tool: "run_command", argPattern: "*" }
+ *
+ * @param {string} pattern
+ * @returns {{ tool: string, argPattern: string }}
+ */
+export function parseToolPattern(pattern) {
+  const m = pattern.match(/^([^(]+)(?:\(([^)]*)\))?$/);
+  if (!m) return null;
+
+  const rawName = m[1].trim();
+  const argSpec = m[2] ?? "*";
+
+  // Resolve alias
+  const toolName = TOOL_ALIASES[rawName] ?? rawName;
+
+  // Normalize "git:*" style to "git *" for command matching
+  const argPattern = argSpec.replace(/:/g, " ").trim() || "*";
+
+  return { tool: toolName, argPattern };
+}
+
+/**
+ * Parse a space-separated list of tool patterns.
+ * @param {string} patternsStr - e.g. "Bash(git:*) read_file Edit"
+ * @returns {Array<{ tool: string, argPattern: string }>}
+ */
+export function parseToolPatternList(patternsStr) {
+  if (!patternsStr) return [];
+  // Split on whitespace but respect parentheses
+  const patterns = [];
+  let current = "";
+  let depth = 0;
+  for (const ch of patternsStr) {
+    if (ch === "(") { depth++; current += ch; }
+    else if (ch === ")") { depth--; current += ch; }
+    else if ((ch === " " || ch === ",") && depth === 0) {
+      if (current.trim()) patterns.push(current.trim());
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  if (current.trim()) patterns.push(current.trim());
+  return patterns.map(parseToolPattern).filter(Boolean);
+}
+
+/**
+ * Check whether a tool call matches a pattern.
+ * @param {string} toolName
+ * @param {object} args
+ * @param {{ tool: string, argPattern: string }} pattern
+ */
+export function matchesPattern(toolName, args, pattern) {
+  // Tool name must match
+  if (pattern.tool !== toolName && pattern.tool !== "*") return false;
+  // If no arg pattern, it's a match
+  if (pattern.argPattern === "*") return true;
+  // Get the relevant arg string
+  const argStr = _getArgString(toolName, args);
+  return _globMatch(argStr, pattern.argPattern);
+}
+
+/**
+ * Simple glob matching (supports * wildcard).
+ */
+function _globMatch(str, pattern) {
+  if (pattern === "*") return true;
+  // Convert glob to regex
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+  return new RegExp(`^${escaped}`, "i").test(str);
+}
+
 // ── Approval gate constants ────────────────────────────────────────────────────
 
 // Tools that require approval depending on security mode
@@ -491,6 +584,55 @@ export class Harness extends EventEmitter {
       file_edit: "diff",
       git: "preview",
     };
+
+    // Tool allow/deny patterns (from config)
+    this._allowedPatterns = config.allowedTools ? parseToolPatternList(config.allowedTools) : null; // null = allow all
+    this._disallowedPatterns = config.disallowedTools ? parseToolPatternList(config.disallowedTools) : [];
+  }
+
+  /**
+   * Set allowed tools (replaces current filter).
+   * @param {string|Array} patterns - Space-separated string or array of pattern strings
+   */
+  setAllowedTools(patterns) {
+    if (!patterns) { this._allowedPatterns = null; return; }
+    const str = Array.isArray(patterns) ? patterns.join(" ") : patterns;
+    this._allowedPatterns = parseToolPatternList(str);
+  }
+
+  /**
+   * Set disallowed tools.
+   * @param {string|Array} patterns
+   */
+  setDisallowedTools(patterns) {
+    if (!patterns) { this._disallowedPatterns = []; return; }
+    const str = Array.isArray(patterns) ? patterns.join(" ") : patterns;
+    this._disallowedPatterns = parseToolPatternList(str);
+  }
+
+  /**
+   * Check if a tool call is allowed by the current allow/deny filters.
+   * @param {string} toolName
+   * @param {object} args
+   * @returns {{ allowed: boolean, reason?: string }}
+   */
+  checkToolFilter(toolName, args) {
+    // Check disallowed patterns first (deny takes precedence)
+    for (const pattern of this._disallowedPatterns) {
+      if (matchesPattern(toolName, args, pattern)) {
+        return { allowed: false, reason: `Tool '${toolName}' is in the disallowed list.` };
+      }
+    }
+
+    // Check allowed patterns (if set)
+    if (this._allowedPatterns !== null && this._allowedPatterns.length > 0) {
+      const allowed = this._allowedPatterns.some(p => matchesPattern(toolName, args, p));
+      if (!allowed) {
+        return { allowed: false, reason: `Tool '${toolName}' is not in the allowed list.` };
+      }
+    }
+
+    return { allowed: true };
   }
 
   /**
@@ -510,6 +652,26 @@ export class Harness extends EventEmitter {
 
     const callStart = Date.now();
 
+    // ── 0. Tool allow/deny filter ────────────────────────────────────────────
+    const filterResult = this.checkToolFilter(toolName, args);
+    if (!filterResult.allowed) {
+      receipt.approved = false;
+      receipt.success = false;
+      receipt.error = filterResult.reason ?? `Tool '${toolName}' is not available.`;
+      receipt.duration = 0;
+      this.emit("tool:denied", { toolName, args, receipt, context, reason: "tool-filter" });
+      // Return a clear error that the LLM can understand
+      return new HarnessResult({
+        result: {
+          success: false,
+          error: filterResult.reason ?? `Tool '${toolName}' is not available in this session.`,
+          tool_not_available: true,
+        },
+        receipt,
+        denied: true,
+      });
+    }
+
     // ── 1. Permission check ──────────────────────────────────────────────────
     const permResult = await this.permissions.check(toolName, args, context);
     receipt.permissionLevel = permResult.level ?? "auto";

package/core/project-settings.mjs

@@ -0,0 +1,122 @@
+/**
+ * core/project-settings.mjs — Per-project configuration for Wispy
+ *
+ * Supports .wispy/settings.json in the project root (or any parent dir).
+ * Settings precedence (highest to lowest):
+ *   1. CLI flags
+ *   2. Project settings (.wispy/settings.json)
+ *   3. User profile settings (wispy -p <name>)
+ *   4. User config (~/.wispy/config.json)
+ *   5. Defaults
+ *
+ * Example .wispy/settings.json:
+ * {
+ *   "model": "gpt-4o",
+ *   "personality": "pragmatic",
+ *   "effort": "high",
+ *   "appendSystemPrompt": "This is a TypeScript project using Next.js 15.",
+ *   "features": { "browser_integration": true },
+ *   "tools": {
+ *     "allow": ["run_command", "read_file", "write_file", "file_edit"],
+ *     "deny": ["delete_file"]
+ *   },
+ *   "agents": {
+ *     "styler": { "description": "CSS specialist", "prompt": "You are a CSS/Tailwind expert." }
+ *   }
+ * }
+ */
+
+import path from "node:path";
+import { readFile } from "node:fs/promises";
+
+const SETTINGS_FILENAME = "settings.json";
+const SETTINGS_DIR = ".wispy";
+
+/**
+ * Walk up from startDir looking for .wispy/settings.json.
+ * Returns parsed settings object (with _projectRoot added) or null.
+ *
+ * @param {string} startDir - Directory to start searching from (default: cwd)
+ * @returns {Promise<object|null>}
+ */
+export async function findProjectSettings(startDir = process.cwd()) {
+  let dir = path.resolve(startDir);
+  const root = path.parse(dir).root;
+
+  while (true) {
+    const settingsPath = path.join(dir, SETTINGS_DIR, SETTINGS_FILENAME);
+    try {
+      const raw = await readFile(settingsPath, "utf8");
+      const settings = JSON.parse(raw);
+      if (settings && typeof settings === "object") {
+        settings._projectRoot = dir;
+        settings._settingsPath = settingsPath;
+        return settings;
+      }
+    } catch { /* not found or parse error, keep walking */ }
+
+    const parent = path.dirname(dir);
+    if (parent === dir || dir === root) break;
+    dir = parent;
+  }
+  return null;
+}
+
+/**
+ * Deep-merge settings with correct precedence.
+ * CLI flags > project settings > profile settings > base config > defaults.
+ *
+ * For object values (like "features", "tools", "agents"), performs shallow merge.
+ * For scalar values, higher-precedence wins.
+ *
+ * @param {object} base    - Base user config (~/.wispy/config.json)
+ * @param {object|null} project  - Project settings (.wispy/settings.json)
+ * @param {object|null} profile  - Named profile from config.profiles
+ * @param {object} cli     - CLI flag overrides
+ * @returns {object} Merged settings
+ */
+export function mergeSettings(base = {}, project = null, profile = null, cli = {}) {
+  // Start with base config (strip profiles map to avoid leakage)
+  const { profiles: _profiles, ...baseClean } = base;
+  let merged = { ...baseClean };
+
+  // Apply profile on top (profile keys override base)
+  if (profile && typeof profile === "object") {
+    const { profiles: _pp, ...profileClean } = profile;
+    for (const [key, value] of Object.entries(profileClean)) {
+      if (value !== undefined) merged[key] = value;
+    }
+  }
+
+  // Apply project settings on top (project overrides profile + base)
+  if (project && typeof project === "object") {
+    for (const [key, value] of Object.entries(project)) {
+      if (key.startsWith("_")) continue; // skip internal metadata keys
+      if (value !== undefined && value !== null) {
+        // Deep merge objects (features, tools, agents)
+        if (
+          typeof value === "object" &&
+          !Array.isArray(value) &&
+          typeof merged[key] === "object" &&
+          !Array.isArray(merged[key]) &&
+          merged[key] !== null
+        ) {
+          merged[key] = { ...merged[key], ...value };
+        } else {
+          merged[key] = value;
+        }
+      }
+    }
+  }
+
+  // Apply CLI flags last (highest precedence)
+  if (cli && typeof cli === "object") {
+    for (const [key, value] of Object.entries(cli)) {
+      if (value !== undefined && value !== null) {
+        merged[key] = value;
+      }
+    }
+  }
+
+  return merged;
+}

package/core/session.mjs

@@ -23,7 +23,7 @@ import { readFile, writeFile, mkdir, readdir, stat } from "node:fs/promises";
 import { SESSIONS_DIR } from "./config.mjs";
 
 export class Session {
-  constructor({ id, workstream = "default", channel = null, chatId = null, messages = [], createdAt = null }) {
+  constructor({ id, workstream = "default", channel = null, chatId = null, messages = [], createdAt = null, name = null, model = null, cwd = null }) {
     this.id = id;
     this.workstream = workstream;
     this.channel = channel;
@@ -31,14 +31,20 @@ export class Session {
     this.messages = messages;
     this.createdAt = createdAt ?? new Date().toISOString();
     this.updatedAt = new Date().toISOString();
+    this.name = name ?? null;         // user-given display name
+    this.model = model ?? null;       // model used in this session
+    this.cwd = cwd ?? process.cwd(); // working directory when session was created
   }
 
   toJSON() {
     return {
       id: this.id,
+      name: this.name,
       workstream: this.workstream,
       channel: this.channel,
       chatId: this.chatId,
+      model: this.model,
+      cwd: this.cwd,
       messages: this.messages,
       createdAt: this.createdAt,
       updatedAt: this.updatedAt,
@@ -55,9 +61,9 @@ export class SessionManager {
   /**
    * Create a new session
    */
-  create({ workstream = "default", channel = null, chatId = null } = {}) {
+  create({ workstream = "default", channel = null, chatId = null, name = null, model = null, cwd = null } = {}) {
     const id = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`;
-    const session = new Session({ id, workstream, channel, chatId });
+    const session = new Session({ id, workstream, channel, chatId, name, model, cwd });
     this._sessions.set(id, session);
     if (channel && chatId) {
       this._keyMap.set(`${channel}:${chatId}`, id);
@@ -136,6 +142,7 @@ export class SessionManager {
 
         results.push({
           id: data.id,
+          name: data.name ?? null,
           workstream: data.workstream ?? "default",
           channel: data.channel ?? null,
           chatId: data.chatId ?? null,
@@ -184,6 +191,8 @@ export class SessionManager {
       workstream: opts.workstream ?? source.workstream,
       channel: opts.channel ?? null,
       chatId: opts.chatId ?? null,
+      name: opts.name ?? null,
+      model: opts.model ?? source.model ?? null,
     });
 
     // Copy message history (deep copy)
@@ -196,6 +205,21 @@ export class SessionManager {
     return forked;
   }
 
+  /**
+   * Set (or update) the display name of a session.
+   * Persists immediately to disk.
+   *
+   * @param {string} id - Session ID
+   * @param {string} name - Display name
+   */
+  async setName(id, name) {
+    const session = this._sessions.get(id);
+    if (!session) throw new Error(`Session not found: ${id}`);
+    session.name = name;
+    session.updatedAt = new Date().toISOString();
+    await this.save(id);
+  }
+
   /**
    * Add a message to a session.
    */

package/package.json

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