@tuttiai/cli 0.8.0 → 0.10.0

package/dist/index.js

@@ -2,7 +2,7 @@
 
 // src/index.ts
 import { config } from "dotenv";
-import { createLogger as createLogger9 } from "@tuttiai/core";
+import { createLogger as createLogger10 } from "@tuttiai/core";
 import { Command } from "commander";
 
 // src/commands/init.ts
@@ -356,7 +356,7 @@ function templatesCommand() {
 
 // src/commands/run.ts
 import { existsSync as existsSync2 } from "fs";
-import { resolve } from "path";
+import { resolve as resolve2 } from "path";
 import { createInterface } from "readline/promises";
 import chalk2 from "chalk";
 import ora from "ora";
@@ -367,11 +367,122 @@ import {
   OpenAIProvider,
   GeminiProvider,
   SecretsManager,
+  InMemorySessionStore,
   createLogger as createLogger2
 } from "@tuttiai/core";
+
+// src/watch/score-watcher.ts
+import { dirname, resolve } from "path";
+import { EventEmitter } from "events";
+import chokidar from "chokidar";
+import { validateScore } from "@tuttiai/core";
+var DEFAULT_DEBOUNCE_MS = 200;
+var DEFAULT_IGNORED = [
+  /(^|[/\\])\../,
+  // dotfiles (.git, .env, etc.)
+  /node_modules/,
+  /[/\\]dist[/\\]/,
+  /[/\\]coverage[/\\]/
+];
+async function defaultLoadScore(path) {
+  const absolute = resolve(path);
+  const { pathToFileURL } = await import("url");
+  const url = pathToFileURL(absolute).href + "?t=" + Date.now().toString(36);
+  const mod = await import(url);
+  if (!mod.default) {
+    throw new Error(
+      "Score file has no default export: " + path + " \u2014 your score must export `defineScore({ ... })` as its default."
+    );
+  }
+  validateScore(mod.default);
+  return mod.default;
+}
+var ReactiveScore = class extends EventEmitter {
+  _current;
+  scorePath;
+  load;
+  debounceMs;
+  watcher;
+  debounceTimer;
+  closed = false;
+  _pendingReload = false;
+  constructor(initialScore, scorePath, options = {}) {
+    super();
+    this._current = initialScore;
+    this.scorePath = resolve(scorePath);
+    this.load = options.load ?? defaultLoadScore;
+    this.debounceMs = options.debounceMs ?? DEFAULT_DEBOUNCE_MS;
+    const watchTargets = [
+      this.scorePath,
+      dirname(this.scorePath),
+      ...options.extraPaths ?? []
+    ];
+    this.watcher = chokidar.watch(watchTargets, {
+      ignored: DEFAULT_IGNORED,
+      ignoreInitial: true,
+      // awaitWriteFinish: guard against partial writes from editors that
+      // save atomically via rename/move.
+      awaitWriteFinish: {
+        stabilityThreshold: 50,
+        pollInterval: 20
+      }
+    });
+    this.watcher.on("change", (path) => this.handleChange(path));
+    this.watcher.on("add", (path) => this.handleChange(path));
+  }
+  /** The most recent successfully-loaded score. Never stale. */
+  get current() {
+    return this._current;
+  }
+  /**
+   * True when a file change has been observed and a reload is pending
+   * (or just completed and not yet consumed). Readers call
+   * {@link consumePendingReload} to clear the flag when they've taken
+   * action on the new config.
+   */
+  get pendingReload() {
+    return this._pendingReload;
+  }
+  consumePendingReload() {
+    this._pendingReload = false;
+  }
+  /** Release the underlying filesystem watchers. */
+  async close() {
+    this.closed = true;
+    if (this.debounceTimer) clearTimeout(this.debounceTimer);
+    await this.watcher.close();
+  }
+  /**
+   * Force an immediate reload without waiting for a filesystem event.
+   * Exposed for tests and for the `reload` REPL command.
+   */
+  async reloadNow() {
+    if (this.closed) return;
+    this.emit("reloading");
+    try {
+      const next = await this.load(this.scorePath);
+      this._current = next;
+      this._pendingReload = true;
+      this.emit("reloaded", next);
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      this.emit("reload-failed", error);
+    }
+  }
+  handleChange(path) {
+    if (this.closed) return;
+    this.emit("file-change", path);
+    if (this.debounceTimer) clearTimeout(this.debounceTimer);
+    this.debounceTimer = setTimeout(() => {
+      void this.reloadNow();
+    }, this.debounceMs);
+  }
+};
+
+// src/commands/run.ts
 var logger2 = createLogger2("tutti-cli");
-async function runCommand(scorePath) {
-  const file = resolve(scorePath ?? "./tutti.score.ts");
+async function runCommand(scorePath, options = {}) {
+  const file = resolve2(scorePath ?? "./tutti.score.ts");
   if (!existsSync2(file)) {
     logger2.error({ file }, "Score file not found");
     console.error(chalk2.dim('Run "tutti-ai init" to create a new project.'));
@@ -401,90 +512,128 @@ async function runCommand(scorePath) {
       }
     }
   }
-  for (const agent of Object.values(score.agents)) {
-    agent.streaming = true;
-  }
-  const runtime = new TuttiRuntime(score);
+  const applyRunDefaults = (cfg) => {
+    for (const agent of Object.values(cfg.agents)) {
+      agent.streaming = true;
+    }
+  };
+  applyRunDefaults(score);
+  const sharedSessions = options.watch ? new InMemorySessionStore() : void 0;
   const spinner = ora({ color: "cyan" });
   let streaming = false;
-  runtime.events.on("agent:start", (e) => {
-    logger2.info({ agent: e.agent_name }, "Running agent");
-  });
-  runtime.events.on("llm:request", () => {
-    spinner.start("Thinking...");
-  });
-  runtime.events.on("token:stream", (e) => {
-    if (!streaming) {
-      spinner.stop();
-      streaming = true;
-    }
-    process.stdout.write(e.text);
-  });
-  runtime.events.on("llm:response", () => {
-    if (streaming) {
-      process.stdout.write("\n");
-    } else {
-      spinner.stop();
-    }
-  });
-  runtime.events.on("tool:start", (e) => {
-    if (streaming) {
-      process.stdout.write(chalk2.dim("\n  [using: " + e.tool_name + "]"));
-    } else {
-      spinner.stop();
-      console.log(chalk2.dim("  [using: " + e.tool_name + "]"));
-    }
-  });
-  runtime.events.on("tool:end", (e) => {
-    if (streaming) {
-      process.stdout.write(chalk2.dim("  [done: " + e.tool_name + "]\n"));
-    }
-  });
-  runtime.events.on("tool:error", (e) => {
-    spinner.stop();
-    logger2.error({ tool: e.tool_name }, "Tool error");
-  });
-  runtime.events.on("security:injection_detected", (e) => {
-    logger2.warn({ tool: e.tool_name }, "Potential prompt injection detected");
-  });
-  runtime.events.on("budget:warning", () => {
-    logger2.warn("Approaching token budget (80%)");
-  });
-  runtime.events.on("budget:exceeded", () => {
-    logger2.error("Token budget exceeded \u2014 stopping");
-  });
+  let runtime = buildRuntime(score, sharedSessions);
+  attachListeners(runtime);
   const rl = createInterface({
     input: process.stdin,
     output: process.stdout
   });
-  runtime.events.on("hitl:requested", (e) => {
-    spinner.stop();
-    if (streaming) {
-      process.stdout.write("\n");
-      streaming = false;
-    }
-    console.log();
-    console.log(chalk2.yellow("  " + chalk2.bold("[Agent needs input]") + " " + e.question));
-    if (e.options) {
-      e.options.forEach((opt, i) => {
-        console.log(chalk2.yellow("    " + (i + 1) + ". " + opt));
+  function attachListeners(r) {
+    r.events.on("agent:start", (e) => {
+      logger2.info({ agent: e.agent_name }, "Running agent");
+    });
+    r.events.on("llm:request", () => {
+      spinner.start("Thinking...");
+    });
+    r.events.on("token:stream", (e) => {
+      if (!streaming) {
+        spinner.stop();
+        streaming = true;
+      }
+      process.stdout.write(e.text);
+    });
+    r.events.on("llm:response", () => {
+      if (streaming) {
+        process.stdout.write("\n");
+      } else {
+        spinner.stop();
+      }
+    });
+    r.events.on("tool:start", (e) => {
+      if (streaming) {
+        process.stdout.write(chalk2.dim("\n  [using: " + e.tool_name + "]"));
+      } else {
+        spinner.stop();
+        console.log(chalk2.dim("  [using: " + e.tool_name + "]"));
+      }
+    });
+    r.events.on("tool:end", (e) => {
+      if (streaming) {
+        process.stdout.write(chalk2.dim("  [done: " + e.tool_name + "]\n"));
+      }
+    });
+    r.events.on("tool:error", (e) => {
+      spinner.stop();
+      logger2.error({ tool: e.tool_name }, "Tool error");
+    });
+    r.events.on("security:injection_detected", (e) => {
+      logger2.warn({ tool: e.tool_name }, "Potential prompt injection detected");
+    });
+    r.events.on("budget:warning", () => {
+      logger2.warn("Approaching token budget (80%)");
+    });
+    r.events.on("budget:exceeded", () => {
+      logger2.error("Token budget exceeded \u2014 stopping");
+    });
+    r.events.on("hitl:requested", (e) => {
+      spinner.stop();
+      if (streaming) {
+        process.stdout.write("\n");
+        streaming = false;
+      }
+      console.log();
+      console.log(
+        chalk2.yellow(
+          "  " + chalk2.bold("[Agent needs input]") + " " + e.question
+        )
+      );
+      if (e.options) {
+        e.options.forEach((opt, i) => {
+          console.log(chalk2.yellow("    " + (i + 1) + ". " + opt));
+        });
+      }
+      void rl.question(chalk2.yellow("  > ")).then((answer) => {
+        runtime.answer(e.session_id, answer.trim());
       });
-    }
-    void rl.question(chalk2.yellow("  > ")).then((answer) => {
-      runtime.answer(e.session_id, answer.trim());
     });
-  });
+  }
+  let reactive;
+  if (options.watch) {
+    reactive = new ReactiveScore(score, file);
+    reactive.on("file-change", () => {
+      console.log(chalk2.cyan("\n[tutti] Score changed, reloading..."));
+    });
+    reactive.on("reloaded", () => {
+      console.log(chalk2.green("[tutti] Score reloaded. Changes applied."));
+    });
+    reactive.on("reload-failed", (err) => {
+      logger2.error(
+        { error: err instanceof Error ? err.message : String(err) },
+        "[tutti] Reload failed \u2014 using previous config"
+      );
+    });
+  }
   console.log(chalk2.dim('Tutti REPL \u2014 type "exit" to quit\n'));
+  if (options.watch) {
+    console.log(chalk2.dim("Watching " + file + " for changes\u2026\n"));
+  }
   let sessionId;
   process.on("SIGINT", () => {
     if (streaming) process.stdout.write("\n");
     spinner.stop();
     console.log(chalk2.dim("Goodbye!"));
     rl.close();
+    if (reactive) void reactive.close();
     process.exit(0);
   });
   try {
     while (true) {
+      if (reactive?.pendingReload) {
+        const nextScore = reactive.current;
+        applyRunDefaults(nextScore);
+        runtime = buildRuntime(nextScore, sharedSessions);
+        attachListeners(runtime);
+        reactive.consumePendingReload();
+      }
       const input = await rl.question(chalk2.cyan("> "));
       const trimmed = input.trim();
       if (!trimmed) continue;
@@ -511,55 +660,322 @@ async function runCommand(scorePath) {
   }
   console.log(chalk2.dim("Goodbye!"));
   rl.close();
+  if (reactive) await reactive.close();
   process.exit(0);
 }
+function buildRuntime(score, sessionStore) {
+  return new TuttiRuntime(
+    score,
+    sessionStore ? { sessionStore } : {}
+  );
+}
 
-// src/commands/add.ts
-import { existsSync as existsSync3, readFileSync } from "fs";
-import { resolve as resolve2 } from "path";
-import { execSync } from "child_process";
+// src/commands/resume.ts
+import { existsSync as existsSync3 } from "fs";
+import { resolve as resolve3 } from "path";
+import { createInterface as createInterface2 } from "readline/promises";
 import chalk3 from "chalk";
 import ora2 from "ora";
-import { createLogger as createLogger3 } from "@tuttiai/core";
+import {
+  AnthropicProvider as AnthropicProvider2,
+  GeminiProvider as GeminiProvider2,
+  OpenAIProvider as OpenAIProvider2,
+  ScoreLoader as ScoreLoader2,
+  SecretsManager as SecretsManager2,
+  TuttiRuntime as TuttiRuntime2,
+  createCheckpointStore,
+  createLogger as createLogger3
+} from "@tuttiai/core";
 var logger3 = createLogger3("tutti-cli");
+async function resumeCommand(sessionId, opts) {
+  const scoreFile = resolve3(opts.score ?? "./tutti.score.ts");
+  if (!existsSync3(scoreFile)) {
+    logger3.error({ file: scoreFile }, "Score file not found");
+    console.error(chalk3.dim('Run "tutti-ai init" to create a new project.'));
+    process.exit(1);
+  }
+  let score;
+  try {
+    score = await ScoreLoader2.load(scoreFile);
+  } catch (err) {
+    logger3.error(
+      { error: err instanceof Error ? err.message : String(err) },
+      "Failed to load score"
+    );
+    process.exit(1);
+  }
+  const providerKeyMap = [
+    [AnthropicProvider2, "ANTHROPIC_API_KEY"],
+    [OpenAIProvider2, "OPENAI_API_KEY"],
+    [GeminiProvider2, "GEMINI_API_KEY"]
+  ];
+  for (const [ProviderClass, envVar] of providerKeyMap) {
+    if (score.provider instanceof ProviderClass) {
+      if (!SecretsManager2.optional(envVar)) {
+        logger3.error({ envVar }, "Missing API key");
+        process.exit(1);
+      }
+    }
+  }
+  const agentName = resolveAgentName(score, opts.agent);
+  const agent = score.agents[agentName];
+  if (!agent) {
+    logger3.error(
+      { agent: agentName, available: Object.keys(score.agents) },
+      "Agent not found in score"
+    );
+    process.exit(1);
+  }
+  if (!agent.durable) {
+    console.error(
+      chalk3.yellow(
+        "Agent '" + agentName + "' does not have `durable: true` set \u2014 resume has nothing to restore."
+      )
+    );
+    console.error(
+      chalk3.dim(
+        "Enable durable checkpointing on the agent before the run that created this session."
+      )
+    );
+    process.exit(1);
+  }
+  const spinner = ora2({ color: "cyan" }).start("Loading checkpoint...");
+  let checkpointStore;
+  let checkpoint;
+  try {
+    checkpointStore = createCheckpointStore({ store: opts.store });
+    checkpoint = await checkpointStore.loadLatest(sessionId);
+  } catch (err) {
+    spinner.fail("Failed to load checkpoint");
+    logger3.error(
+      { error: err instanceof Error ? err.message : String(err), store: opts.store },
+      "Checkpoint store error"
+    );
+    process.exit(1);
+  }
+  spinner.stop();
+  if (!checkpoint) {
+    console.error(
+      chalk3.red("No checkpoint found for session " + sessionId + ".")
+    );
+    console.error(
+      chalk3.dim(
+        "Verify TUTTI_" + (opts.store === "redis" ? "REDIS" : "PG") + "_URL points to the same " + opts.store + " the original run used."
+      )
+    );
+    process.exit(1);
+  }
+  printSummary(checkpoint);
+  if (!opts.yes && !await confirmResume(checkpoint.turn)) {
+    console.log(chalk3.dim("Cancelled."));
+    process.exit(0);
+  }
+  const runtime = new TuttiRuntime2(score, { checkpointStore });
+  const sessions = runtime.sessions;
+  if ("save" in sessions && typeof sessions.save === "function") {
+    sessions.save({
+      id: sessionId,
+      agent_name: agentName,
+      messages: [...checkpoint.messages],
+      created_at: checkpoint.saved_at,
+      updated_at: /* @__PURE__ */ new Date()
+    });
+  } else {
+    console.error(
+      chalk3.red(
+        "Session store does not support resume seeding. Use the default InMemorySessionStore or PostgresSessionStore."
+      )
+    );
+    process.exit(1);
+  }
+  wireProgress(runtime);
+  try {
+    const result = await runtime.run(agentName, "[resume]", sessionId);
+    console.log();
+    console.log(chalk3.green("\u2713 Resumed run complete."));
+    console.log(chalk3.dim("  Final turn:    " + result.turns));
+    console.log(chalk3.dim("  Session ID:    " + result.session_id));
+    console.log(
+      chalk3.dim(
+        "  Token usage:   " + result.usage.input_tokens + " in / " + result.usage.output_tokens + " out"
+      )
+    );
+    console.log();
+    console.log(result.output);
+  } catch (err) {
+    logger3.error(
+      { error: err instanceof Error ? err.message : String(err) },
+      "Resume failed"
+    );
+    process.exit(1);
+  }
+}
+function resolveAgentName(score, override) {
+  if (override) return override;
+  if (typeof score.entry === "string") return score.entry;
+  const first = Object.keys(score.agents)[0];
+  if (!first) {
+    console.error(chalk3.red("Score has no agents defined."));
+    process.exit(1);
+  }
+  return first;
+}
+function printSummary(checkpoint) {
+  console.log();
+  console.log(chalk3.cyan.bold("Checkpoint summary"));
+  console.log(
+    chalk3.dim("  Session ID:    ") + checkpoint.session_id
+  );
+  console.log(
+    chalk3.dim("  Last turn:     ") + String(checkpoint.turn)
+  );
+  console.log(
+    chalk3.dim("  Saved at:      ") + checkpoint.saved_at.toISOString()
+  );
+  console.log(
+    chalk3.dim("  Messages:      ") + String(checkpoint.messages.length) + " total"
+  );
+  console.log();
+  console.log(chalk3.cyan("First messages"));
+  const preview = checkpoint.messages.slice(0, 3);
+  for (const msg of preview) {
+    const text = excerpt(messageToText(msg), 200);
+    console.log(chalk3.dim("  [" + msg.role + "] ") + text);
+  }
+  if (checkpoint.messages.length > preview.length) {
+    console.log(
+      chalk3.dim(
+        "  \u2026 " + String(checkpoint.messages.length - preview.length) + " more"
+      )
+    );
+  }
+  console.log();
+}
+function messageToText(msg) {
+  if (typeof msg.content === "string") return msg.content;
+  const parts = [];
+  for (const block of msg.content) {
+    if (block.type === "text") {
+      parts.push(block.text);
+    } else if (block.type === "tool_use") {
+      parts.push("[tool_use " + block.name + "]");
+    } else if (block.type === "tool_result") {
+      parts.push("[tool_result " + excerpt(block.content, 80) + "]");
+    }
+  }
+  return parts.join(" ");
+}
+function excerpt(text, max) {
+  const oneLine = text.replace(/\s+/g, " ").trim();
+  return oneLine.length > max ? oneLine.slice(0, max - 1) + "\u2026" : oneLine;
+}
+async function confirmResume(turn) {
+  const rl = createInterface2({
+    input: process.stdin,
+    output: process.stdout
+  });
+  try {
+    const answer = (await rl.question(
+      chalk3.cyan("Resume from turn " + turn + "? ") + chalk3.dim("(y/n) ")
+    )).trim().toLowerCase();
+    return answer === "y" || answer === "yes";
+  } finally {
+    rl.close();
+  }
+}
+function wireProgress(runtime) {
+  const spinner = ora2({ color: "cyan" });
+  let streaming = false;
+  runtime.events.on("checkpoint:restored", (e) => {
+    console.log(
+      chalk3.dim("\u21BB Restored from turn " + e.turn) + chalk3.dim(" (session " + e.session_id.slice(0, 8) + "\u2026)")
+    );
+  });
+  runtime.events.on("checkpoint:saved", (e) => {
+    console.log(chalk3.dim("\xB7 Checkpoint saved at turn " + e.turn));
+  });
+  runtime.events.on("llm:request", () => {
+    spinner.start("Thinking...");
+  });
+  runtime.events.on("token:stream", (e) => {
+    if (!streaming) {
+      spinner.stop();
+      streaming = true;
+    }
+    process.stdout.write(e.text);
+  });
+  runtime.events.on("llm:response", () => {
+    if (streaming) {
+      process.stdout.write("\n");
+    } else {
+      spinner.stop();
+    }
+  });
+  runtime.events.on("tool:start", (e) => {
+    if (streaming) {
+      process.stdout.write(chalk3.dim("\n  [using: " + e.tool_name + "]"));
+    } else {
+      spinner.stop();
+      console.log(chalk3.dim("  [using: " + e.tool_name + "]"));
+    }
+  });
+  runtime.events.on("tool:end", (e) => {
+    if (streaming) {
+      process.stdout.write(chalk3.dim("  [done: " + e.tool_name + "]\n"));
+    }
+  });
+  runtime.events.on("tool:error", (e) => {
+    spinner.stop();
+    logger3.error({ tool: e.tool_name }, "Tool error");
+  });
+}
+
+// src/commands/add.ts
+import { existsSync as existsSync4, readFileSync } from "fs";
+import { resolve as resolve4 } from "path";
+import { execSync } from "child_process";
+import chalk4 from "chalk";
+import ora3 from "ora";
+import { createLogger as createLogger4 } from "@tuttiai/core";
+var logger4 = createLogger4("tutti-cli");
 var OFFICIAL_VOICES = {
   filesystem: {
     package: "@tuttiai/filesystem",
     setup: `  Add to your score:
-    ${chalk3.cyan('import { FilesystemVoice } from "@tuttiai/filesystem"')}
-    ${chalk3.cyan("voices: [new FilesystemVoice()]")}`
+    ${chalk4.cyan('import { FilesystemVoice } from "@tuttiai/filesystem"')}
+    ${chalk4.cyan("voices: [new FilesystemVoice()]")}`
   },
   github: {
     package: "@tuttiai/github",
-    setup: `  Add ${chalk3.bold("GITHUB_TOKEN")} to your .env file:
-    ${chalk3.cyan("GITHUB_TOKEN=ghp_your_token_here")}
+    setup: `  Add ${chalk4.bold("GITHUB_TOKEN")} to your .env file:
+    ${chalk4.cyan("GITHUB_TOKEN=ghp_your_token_here")}
 
   Add to your score:
-    ${chalk3.cyan('import { GitHubVoice } from "@tuttiai/github"')}
-    ${chalk3.cyan("voices: [new GitHubVoice()]")}`
+    ${chalk4.cyan('import { GitHubVoice } from "@tuttiai/github"')}
+    ${chalk4.cyan("voices: [new GitHubVoice()]")}`
   },
   playwright: {
     package: "@tuttiai/playwright",
     setup: `  Install the browser:
-    ${chalk3.cyan("npx playwright install chromium")}
+    ${chalk4.cyan("npx playwright install chromium")}
 
   Add to your score:
-    ${chalk3.cyan('import { PlaywrightVoice } from "@tuttiai/playwright"')}
-    ${chalk3.cyan("voices: [new PlaywrightVoice()]")}`
+    ${chalk4.cyan('import { PlaywrightVoice } from "@tuttiai/playwright"')}
+    ${chalk4.cyan("voices: [new PlaywrightVoice()]")}`
   },
   postgres: {
     package: "pg",
-    setup: `  Add ${chalk3.bold("DATABASE_URL")} to your .env file:
-    ${chalk3.cyan("DATABASE_URL=postgres://user:pass@localhost:5432/tutti")}
+    setup: `  Add ${chalk4.bold("DATABASE_URL")} to your .env file:
+    ${chalk4.cyan("DATABASE_URL=postgres://user:pass@localhost:5432/tutti")}
 
   Add to your score:
-    ${chalk3.cyan("memory: { provider: 'postgres' }")}
+    ${chalk4.cyan("memory: { provider: 'postgres' }")}
 
   Or with an explicit URL:
-    ${chalk3.cyan("memory: { provider: 'postgres', url: process.env.DATABASE_URL }")}
+    ${chalk4.cyan("memory: { provider: 'postgres', url: process.env.DATABASE_URL }")}
 
   Use the async factory for initialization:
-    ${chalk3.cyan("const tutti = await TuttiRuntime.create(score)")}`
+    ${chalk4.cyan("const tutti = await TuttiRuntime.create(score)")}`
   }
 };
 function resolvePackageName(input) {
@@ -572,8 +988,8 @@ function resolvePackageName(input) {
   return `@tuttiai/${input}`;
 }
 function isAlreadyInstalled(packageName) {
-  const pkgPath = resolve2(process.cwd(), "package.json");
-  if (!existsSync3(pkgPath)) return false;
+  const pkgPath = resolve4(process.cwd(), "package.json");
+  if (!existsSync4(pkgPath)) return false;
   try {
     const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
     const deps = { ...pkg.dependencies, ...pkg.devDependencies };
@@ -584,17 +1000,17 @@ function isAlreadyInstalled(packageName) {
 }
 function addCommand(voiceName) {
   const packageName = resolvePackageName(voiceName);
-  const pkgPath = resolve2(process.cwd(), "package.json");
-  if (!existsSync3(pkgPath)) {
-    logger3.error("No package.json found in the current directory");
-    console.error(chalk3.dim('Run "tutti-ai init" to create a new project first.'));
+  const pkgPath = resolve4(process.cwd(), "package.json");
+  if (!existsSync4(pkgPath)) {
+    logger4.error("No package.json found in the current directory");
+    console.error(chalk4.dim('Run "tutti-ai init" to create a new project first.'));
     process.exit(1);
   }
   if (isAlreadyInstalled(packageName)) {
-    console.log(chalk3.green(`  \u2714 ${packageName} is already installed`));
+    console.log(chalk4.green(`  \u2714 ${packageName} is already installed`));
     return;
   }
-  const spinner = ora2(`Installing ${packageName}...`).start();
+  const spinner = ora3(`Installing ${packageName}...`).start();
   try {
     execSync(`npm install ${packageName}`, {
       cwd: process.cwd(),
@@ -604,7 +1020,7 @@ function addCommand(voiceName) {
   } catch (error) {
     spinner.fail(`Failed to install ${packageName}`);
     const message = error instanceof Error ? error.message : String(error);
-    logger3.error({ error: message, package: packageName }, "Installation failed");
+    logger4.error({ error: message, package: packageName }, "Installation failed");
     process.exit(1);
   }
   const official = OFFICIAL_VOICES[voiceName];
@@ -616,43 +1032,43 @@ function addCommand(voiceName) {
   } else {
     console.log();
     console.log(
-      chalk3.dim("  Check the package README for setup instructions.")
+      chalk4.dim("  Check the package README for setup instructions.")
     );
     console.log();
   }
 }
 
 // src/commands/check.ts
-import { existsSync as existsSync4 } from "fs";
-import { resolve as resolve3 } from "path";
-import chalk4 from "chalk";
+import { existsSync as existsSync5 } from "fs";
+import { resolve as resolve5 } from "path";
+import chalk5 from "chalk";
 import {
-  ScoreLoader as ScoreLoader2,
-  AnthropicProvider as AnthropicProvider2,
-  OpenAIProvider as OpenAIProvider2,
-  GeminiProvider as GeminiProvider2,
-  SecretsManager as SecretsManager2,
-  createLogger as createLogger4
+  ScoreLoader as ScoreLoader3,
+  AnthropicProvider as AnthropicProvider3,
+  OpenAIProvider as OpenAIProvider3,
+  GeminiProvider as GeminiProvider3,
+  SecretsManager as SecretsManager3,
+  createLogger as createLogger5
 } from "@tuttiai/core";
-var logger4 = createLogger4("tutti-cli");
-var ok = (msg) => console.log(chalk4.green("  \u2714 " + msg));
-var fail = (msg) => console.log(chalk4.red("  \u2718 " + msg));
+var logger5 = createLogger5("tutti-cli");
+var ok = (msg) => console.log(chalk5.green("  \u2714 " + msg));
+var fail = (msg) => console.log(chalk5.red("  \u2718 " + msg));
 async function checkCommand(scorePath) {
-  const file = resolve3(scorePath ?? "./tutti.score.ts");
-  console.log(chalk4.cyan(`
+  const file = resolve5(scorePath ?? "./tutti.score.ts");
+  console.log(chalk5.cyan(`
 Checking ${file}...
 `));
-  if (!existsSync4(file)) {
+  if (!existsSync5(file)) {
     fail("Score file not found: " + file);
     process.exit(1);
   }
   let score;
   try {
-    score = await ScoreLoader2.load(file);
+    score = await ScoreLoader3.load(file);
     ok("Score file is valid");
   } catch (err) {
     fail("Score validation failed");
-    logger4.error(
+    logger5.error(
       { error: err instanceof Error ? err.message : String(err) },
       "Score validation failed"
     );
@@ -660,15 +1076,15 @@ Checking ${file}...
   }
   let hasErrors = false;
   const providerChecks = [
-    [AnthropicProvider2, "AnthropicProvider", "ANTHROPIC_API_KEY"],
-    [OpenAIProvider2, "OpenAIProvider", "OPENAI_API_KEY"],
-    [GeminiProvider2, "GeminiProvider", "GEMINI_API_KEY"]
+    [AnthropicProvider3, "AnthropicProvider", "ANTHROPIC_API_KEY"],
+    [OpenAIProvider3, "OpenAIProvider", "OPENAI_API_KEY"],
+    [GeminiProvider3, "GeminiProvider", "GEMINI_API_KEY"]
   ];
   let providerDetected = false;
   for (const [ProviderClass, name, envVar] of providerChecks) {
     if (score.provider instanceof ProviderClass) {
       providerDetected = true;
-      const key = SecretsManager2.optional(envVar);
+      const key = SecretsManager3.optional(envVar);
       if (key) {
         ok("Provider: " + name + " (" + envVar + " is set)");
       } else {
@@ -690,7 +1106,7 @@ Checking ${file}...
       };
       const envVar = voiceEnvMap[voiceName];
       if (envVar) {
-        const key = SecretsManager2.optional(envVar);
+        const key = SecretsManager3.optional(envVar);
         if (key) {
           ok(
             "Voice: " + voiceName + " on " + agentKey + " (" + envVar + " is set)"
@@ -709,28 +1125,28 @@ Checking ${file}...
   console.log("");
   if (hasErrors) {
     console.log(
-      chalk4.yellow("Some checks failed. Fix the issues above and re-run.")
+      chalk5.yellow("Some checks failed. Fix the issues above and re-run.")
     );
     process.exit(1);
   } else {
     console.log(
-      chalk4.green("All checks passed.") + chalk4.dim(" Run tutti-ai run to start.")
+      chalk5.green("All checks passed.") + chalk5.dim(" Run tutti-ai run to start.")
     );
   }
 }
 
 // src/commands/studio.ts
-import { existsSync as existsSync5 } from "fs";
-import { resolve as resolve4 } from "path";
+import { existsSync as existsSync6 } from "fs";
+import { resolve as resolve6 } from "path";
 import { execFile } from "child_process";
 import express from "express";
-import chalk5 from "chalk";
+import chalk6 from "chalk";
 import {
-  TuttiRuntime as TuttiRuntime2,
-  ScoreLoader as ScoreLoader3,
-  createLogger as createLogger5
+  TuttiRuntime as TuttiRuntime3,
+  ScoreLoader as ScoreLoader4,
+  createLogger as createLogger6
 } from "@tuttiai/core";
-var logger5 = createLogger5("tutti-studio");
+var logger6 = createLogger6("tutti-studio");
 var envPort = Number.parseInt(process.env.PORT ?? "", 10);
 var PORT = Number.isInteger(envPort) && envPort > 0 && envPort <= 65535 ? envPort : 4747;
 function safeStringify(obj) {
@@ -749,20 +1165,20 @@ function openBrowser(url) {
   execFile(cmd, [url]);
 }
 async function studioCommand(scorePath) {
-  const file = resolve4(scorePath ?? "./tutti.score.ts");
-  if (!existsSync5(file)) {
-    logger5.error({ file }, "Score file not found");
-    console.error(chalk5.dim('Run "tutti-ai init" to create a new project.'));
+  const file = resolve6(scorePath ?? "./tutti.score.ts");
+  if (!existsSync6(file)) {
+    logger6.error({ file }, "Score file not found");
+    console.error(chalk6.dim('Run "tutti-ai init" to create a new project.'));
     process.exit(1);
   }
   let score;
   try {
-    score = await ScoreLoader3.load(file);
+    score = await ScoreLoader4.load(file);
   } catch (err) {
-    logger5.error({ error: err instanceof Error ? err.message : String(err) }, "Failed to load score");
+    logger6.error({ error: err instanceof Error ? err.message : String(err) }, "Failed to load score");
     process.exit(1);
   }
-  const runtime = new TuttiRuntime2(score);
+  const runtime = new TuttiRuntime3(score);
   const sessionRegistry = /* @__PURE__ */ new Map();
   runtime.events.on("agent:start", (e) => {
     if (!sessionRegistry.has(e.session_id)) {
@@ -865,16 +1281,16 @@ async function studioCommand(scorePath) {
   app.listen(PORT, () => {
     const url = "http://localhost:" + PORT;
     console.log();
-    console.log(chalk5.bold("  Tutti Studio"));
-    console.log(chalk5.dim("  " + url));
+    console.log(chalk6.bold("  Tutti Studio"));
+    console.log(chalk6.dim("  " + url));
     console.log();
-    console.log(chalk5.dim("  Score: ") + (runtime.score.name ?? file));
-    console.log(chalk5.dim("  Agents: ") + Object.keys(runtime.score.agents).join(", "));
+    console.log(chalk6.dim("  Score: ") + (runtime.score.name ?? file));
+    console.log(chalk6.dim("  Agents: ") + Object.keys(runtime.score.agents).join(", "));
     console.log();
     openBrowser(url);
   });
   process.on("SIGINT", () => {
-    console.log(chalk5.dim("\nShutting down Tutti Studio..."));
+    console.log(chalk6.dim("\nShutting down Tutti Studio..."));
     process.exit(0);
   });
 }
@@ -883,12 +1299,12 @@ function getStudioHtml() {
 }
 
 // src/commands/search.ts
-import { existsSync as existsSync6, readFileSync as readFileSync2 } from "fs";
-import { resolve as resolve5 } from "path";
-import chalk6 from "chalk";
-import ora3 from "ora";
-import { createLogger as createLogger6 } from "@tuttiai/core";
-var logger6 = createLogger6("tutti-cli");
+import { existsSync as existsSync7, readFileSync as readFileSync2 } from "fs";
+import { resolve as resolve7 } from "path";
+import chalk7 from "chalk";
+import ora4 from "ora";
+import { createLogger as createLogger7 } from "@tuttiai/core";
+var logger7 = createLogger7("tutti-cli");
 var REGISTRY_URL = "https://raw.githubusercontent.com/tuttiai/voices/main/voices.json";
 var BUILTIN_VOICES = [
   {
@@ -939,7 +1355,7 @@ async function fetchRegistry() {
     if (voices.length === 0) throw new Error("Empty registry");
     return voices;
   } catch {
-    logger6.debug("Registry unreachable, using built-in voice list");
+    logger7.debug("Registry unreachable, using built-in voice list");
     return BUILTIN_VOICES;
   }
 }
@@ -955,8 +1371,8 @@ function matchesQuery(voice, query) {
   return false;
 }
 function isInstalled(packageName) {
-  const pkgPath = resolve5(process.cwd(), "package.json");
-  if (!existsSync6(pkgPath)) return false;
+  const pkgPath = resolve7(process.cwd(), "package.json");
+  if (!existsSync7(pkgPath)) return false;
   try {
     const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
     const deps = { ...pkg.dependencies, ...pkg.devDependencies };
@@ -966,35 +1382,35 @@ function isInstalled(packageName) {
   }
 }
 function printVoice(voice, showInstallStatus) {
-  const badge = voice.official ? chalk6.green(" [official]") : chalk6.blue(" [community]");
+  const badge = voice.official ? chalk7.green(" [official]") : chalk7.blue(" [community]");
   const installed = showInstallStatus && isInstalled(voice.package);
-  const status = showInstallStatus ? installed ? chalk6.green(" \u2714 installed") : chalk6.dim(" not installed") : "";
+  const status = showInstallStatus ? installed ? chalk7.green(" \u2714 installed") : chalk7.dim(" not installed") : "";
   console.log();
-  console.log("  " + chalk6.bold(voice.package) + badge + status);
+  console.log("  " + chalk7.bold(voice.package) + badge + status);
   console.log("  " + voice.description);
   const installCmd = voice.official && voice.name !== "postgres" ? "tutti-ai add " + voice.name : "npm install " + voice.package;
-  console.log("  " + chalk6.dim("Install: ") + chalk6.cyan(installCmd));
+  console.log("  " + chalk7.dim("Install: ") + chalk7.cyan(installCmd));
   if (voice.tags.length > 0) {
-    console.log("  " + chalk6.dim("Tags: ") + voice.tags.join(", "));
+    console.log("  " + chalk7.dim("Tags: ") + voice.tags.join(", "));
   }
 }
 async function searchCommand(query) {
-  const spinner = ora3("Searching the Repertoire...").start();
+  const spinner = ora4("Searching the Repertoire...").start();
   const voices = await fetchRegistry();
   const results = voices.filter((v) => matchesQuery(v, query));
   spinner.stop();
   if (results.length === 0) {
     console.log();
-    console.log(chalk6.yellow('  No voices found for "' + query + '"'));
+    console.log(chalk7.yellow('  No voices found for "' + query + '"'));
     console.log();
-    console.log(chalk6.dim("  Browse all: https://tutti-ai.com/voices"));
-    console.log(chalk6.dim("  Build your own: tutti-ai create voice <name>"));
+    console.log(chalk7.dim("  Browse all: https://tutti-ai.com/voices"));
+    console.log(chalk7.dim("  Build your own: tutti-ai create voice <name>"));
     console.log();
     return;
   }
   console.log();
   console.log(
-    "  Found " + chalk6.bold(String(results.length)) + " voice" + (results.length !== 1 ? "s" : "") + " matching " + chalk6.cyan("'" + query + "'") + ":"
+    "  Found " + chalk7.bold(String(results.length)) + " voice" + (results.length !== 1 ? "s" : "") + " matching " + chalk7.cyan("'" + query + "'") + ":"
   );
   for (const voice of results) {
     printVoice(voice, false);
@@ -1002,12 +1418,12 @@ async function searchCommand(query) {
   console.log();
 }
 async function voicesCommand() {
-  const spinner = ora3("Loading voices...").start();
+  const spinner = ora4("Loading voices...").start();
   const voices = await fetchRegistry();
   const official = voices.filter((v) => v.official);
   spinner.stop();
   console.log();
-  console.log("  " + chalk6.bold("Official Tutti Voices"));
+  console.log("  " + chalk7.bold("Official Tutti Voices"));
   console.log();
   for (const voice of official) {
     printVoice(voice, true);
@@ -1015,49 +1431,49 @@ async function voicesCommand() {
   const community = voices.filter((v) => !v.official);
   if (community.length > 0) {
     console.log();
-    console.log("  " + chalk6.bold("Community Voices"));
+    console.log("  " + chalk7.bold("Community Voices"));
     for (const voice of community) {
       printVoice(voice, true);
     }
   }
   console.log();
-  console.log(chalk6.dim("  Search: tutti-ai search <query>"));
-  console.log(chalk6.dim("  Browse: https://tutti-ai.com/voices"));
+  console.log(chalk7.dim("  Search: tutti-ai search <query>"));
+  console.log(chalk7.dim("  Browse: https://tutti-ai.com/voices"));
   console.log();
 }
 
 // src/commands/publish.ts
-import { existsSync as existsSync7, readFileSync as readFileSync3 } from "fs";
-import { resolve as resolve6 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync3 } from "fs";
+import { resolve as resolve8 } from "path";
 import { execSync as execSync2 } from "child_process";
-import chalk7 from "chalk";
-import ora4 from "ora";
+import chalk8 from "chalk";
+import ora5 from "ora";
 import Enquirer2 from "enquirer";
-import { createLogger as createLogger7, SecretsManager as SecretsManager3 } from "@tuttiai/core";
+import { createLogger as createLogger8, SecretsManager as SecretsManager4 } from "@tuttiai/core";
 var { prompt: prompt2 } = Enquirer2;
-var logger7 = createLogger7("tutti-cli");
+var logger8 = createLogger8("tutti-cli");
 function readPkg(dir) {
-  const p = resolve6(dir, "package.json");
-  if (!existsSync7(p)) return void 0;
+  const p = resolve8(dir, "package.json");
+  if (!existsSync8(p)) return void 0;
   return JSON.parse(readFileSync3(p, "utf-8"));
 }
 function run(cmd, cwd) {
   return execSync2(cmd, { cwd, stdio: "pipe", encoding: "utf-8" });
 }
 function fail2(msg) {
-  console.error(chalk7.red("  " + msg));
+  console.error(chalk8.red("  " + msg));
   process.exit(1);
 }
-var ok2 = (msg) => console.log(chalk7.green("  \u2714 " + msg));
+var ok2 = (msg) => console.log(chalk8.green("  \u2714 " + msg));
 async function publishCommand(opts) {
   const cwd = process.cwd();
   const pkg = readPkg(cwd);
   console.log();
-  console.log(chalk7.bold("  Tutti Voice Publisher"));
+  console.log(chalk8.bold("  Tutti Voice Publisher"));
   console.log();
-  const spinner = ora4("Running pre-flight checks...").start();
+  const spinner = ora5("Running pre-flight checks...").start();
   if (!pkg) fail2("No package.json found in the current directory.");
-  if (!existsSync7(resolve6(cwd, "src/index.ts"))) fail2("No src/index.ts found \u2014 are you inside a voice directory?");
+  if (!existsSync8(resolve8(cwd, "src/index.ts"))) fail2("No src/index.ts found \u2014 are you inside a voice directory?");
   const missing = [];
   if (!pkg.name) missing.push("name");
   if (!pkg.version) missing.push("version");
@@ -1069,22 +1485,22 @@ async function publishCommand(opts) {
   const version = pkg.version;
   const validName = name.startsWith("@tuttiai/") || name.startsWith("tutti");
   if (!validName) fail2("Package name must start with @tuttiai/ or tutti \u2014 got: " + name);
-  const src = readFileSync3(resolve6(cwd, "src/index.ts"), "utf-8");
+  const src = readFileSync3(resolve8(cwd, "src/index.ts"), "utf-8");
   if (!src.includes("required_permissions")) {
     fail2("Voice class must declare required_permissions in src/index.ts");
   }
   spinner.succeed("Pre-flight checks passed");
-  const buildSpinner = ora4("Building...").start();
+  const buildSpinner = ora5("Building...").start();
   try {
     run("npm run build", cwd);
     buildSpinner.succeed("Build succeeded");
   } catch (err) {
     buildSpinner.fail("Build failed");
     const msg = err instanceof Error ? err.message : String(err);
-    console.error(chalk7.dim("  " + msg.split("\n").slice(0, 5).join("\n  ")));
+    console.error(chalk8.dim("  " + msg.split("\n").slice(0, 5).join("\n  ")));
     process.exit(1);
   }
-  const testSpinner = ora4("Running tests...").start();
+  const testSpinner = ora5("Running tests...").start();
   try {
     run("npx vitest run", cwd);
     testSpinner.succeed("Tests passed");
@@ -1092,15 +1508,15 @@ async function publishCommand(opts) {
     testSpinner.fail("Tests failed");
     process.exit(1);
   }
-  const auditSpinner = ora4("Checking vulnerabilities...").start();
+  const auditSpinner = ora5("Checking vulnerabilities...").start();
   try {
     run("npm audit --audit-level=high", cwd);
     auditSpinner.succeed("No high/critical vulnerabilities");
   } catch {
-    auditSpinner.stopAndPersist({ symbol: chalk7.yellow("\u26A0"), text: "Vulnerabilities found (npm audit)" });
+    auditSpinner.stopAndPersist({ symbol: chalk8.yellow("\u26A0"), text: "Vulnerabilities found (npm audit)" });
   }
   console.log();
-  const drySpinner = ora4("Packing (dry run)...").start();
+  const drySpinner = ora5("Packing (dry run)...").start();
   let packOutput;
   try {
     packOutput = run("npm pack --dry-run 2>&1", cwd);
@@ -1108,24 +1524,24 @@ async function publishCommand(opts) {
   } catch (err) {
     drySpinner.fail("Pack dry-run failed");
     const msg = err instanceof Error ? err.message : String(err);
-    console.error(chalk7.dim("  " + msg));
+    console.error(chalk8.dim("  " + msg));
     process.exit(1);
   }
   const fileLines = packOutput.split("\n").filter((l) => l.includes("npm notice") && /\d+(\.\d+)?\s*[kM]?B\s/.test(l)).map((l) => l.replace(/npm notice\s*/, ""));
   if (fileLines.length > 0) {
-    console.log(chalk7.dim("  Files:"));
+    console.log(chalk8.dim("  Files:"));
     for (const line of fileLines) {
-      console.log(chalk7.dim("    " + line.trim()));
+      console.log(chalk8.dim("    " + line.trim()));
     }
   }
   const sizeLine = packOutput.split("\n").find((l) => l.includes("package size"));
   const totalLine = packOutput.split("\n").find((l) => l.includes("total files"));
-  if (sizeLine) console.log(chalk7.dim("  " + sizeLine.replace(/npm notice\s*/, "").trim()));
-  if (totalLine) console.log(chalk7.dim("  " + totalLine.replace(/npm notice\s*/, "").trim()));
+  if (sizeLine) console.log(chalk8.dim("  " + sizeLine.replace(/npm notice\s*/, "").trim()));
+  if (totalLine) console.log(chalk8.dim("  " + totalLine.replace(/npm notice\s*/, "").trim()));
   if (opts.dryRun) {
     console.log();
     ok2("Dry run complete \u2014 no packages were published");
-    console.log(chalk7.dim("  Run without --dry-run to publish for real."));
+    console.log(chalk8.dim("  Run without --dry-run to publish for real."));
     console.log();
     return;
   }
@@ -1133,38 +1549,38 @@ async function publishCommand(opts) {
   const { confirm } = await prompt2({
     type: "confirm",
     name: "confirm",
-    message: "Publish " + chalk7.cyan(name + "@" + version) + "?"
+    message: "Publish " + chalk8.cyan(name + "@" + version) + "?"
   });
   if (!confirm) {
-    console.log(chalk7.dim("  Cancelled."));
+    console.log(chalk8.dim("  Cancelled."));
     return;
   }
-  const pubSpinner = ora4("Publishing to npm...").start();
+  const pubSpinner = ora5("Publishing to npm...").start();
   try {
     run("npm publish --access public", cwd);
-    pubSpinner.succeed("Published " + chalk7.cyan(name + "@" + version));
+    pubSpinner.succeed("Published " + chalk8.cyan(name + "@" + version));
   } catch (err) {
     pubSpinner.fail("Publish failed");
     const msg = err instanceof Error ? err.message : String(err);
-    logger7.error({ error: msg }, "npm publish failed");
+    logger8.error({ error: msg }, "npm publish failed");
     process.exit(1);
   }
-  const ghToken = SecretsManager3.optional("GITHUB_TOKEN");
+  const ghToken = SecretsManager4.optional("GITHUB_TOKEN");
   let prUrl;
   if (ghToken) {
-    const prSpinner = ora4("Opening PR to voice registry...").start();
+    const prSpinner = ora5("Opening PR to voice registry...").start();
     try {
       prUrl = await openRegistryPR(name, version, pkg.description ?? "", ghToken);
       prSpinner.succeed("PR opened: " + prUrl);
     } catch (err) {
       prSpinner.fail("Failed to open PR");
       const msg = err instanceof Error ? err.message : String(err);
-      logger7.error({ error: msg }, "Registry PR failed");
+      logger8.error({ error: msg }, "Registry PR failed");
     }
   } else {
     console.log();
-    console.log(chalk7.dim("  To list in the Repertoire, set GITHUB_TOKEN and re-run"));
-    console.log(chalk7.dim("  Or open a PR manually: github.com/tuttiai/voices"));
+    console.log(chalk8.dim("  To list in the Repertoire, set GITHUB_TOKEN and re-run"));
+    console.log(chalk8.dim("  Or open a PR manually: github.com/tuttiai/voices"));
   }
   console.log();
   ok2(name + "@" + version + " published to npm");
@@ -1249,78 +1665,97 @@ async function openRegistryPR(packageName, version, description, token) {
 }
 
 // src/commands/eval.ts
-import { existsSync as existsSync8, readFileSync as readFileSync4 } from "fs";
-import { resolve as resolve7 } from "path";
-import chalk8 from "chalk";
-import ora5 from "ora";
+import { existsSync as existsSync9, readFileSync as readFileSync4 } from "fs";
+import { resolve as resolve9 } from "path";
+import chalk9 from "chalk";
+import ora6 from "ora";
 import {
-  ScoreLoader as ScoreLoader4,
+  ScoreLoader as ScoreLoader5,
   EvalRunner,
   printEvalTable,
-  createLogger as createLogger8
+  createLogger as createLogger9
 } from "@tuttiai/core";
-var logger8 = createLogger8("tutti-cli");
+var logger9 = createLogger9("tutti-cli");
 async function evalCommand(suitePath, opts) {
-  const suiteFile = resolve7(suitePath);
-  if (!existsSync8(suiteFile)) {
-    logger8.error({ file: suiteFile }, "Suite file not found");
+  const suiteFile = resolve9(suitePath);
+  if (!existsSync9(suiteFile)) {
+    logger9.error({ file: suiteFile }, "Suite file not found");
     process.exit(1);
   }
   let suite;
   try {
     suite = JSON.parse(readFileSync4(suiteFile, "utf-8"));
   } catch (err) {
-    logger8.error({ error: err instanceof Error ? err.message : String(err) }, "Failed to parse suite file");
+    logger9.error({ error: err instanceof Error ? err.message : String(err) }, "Failed to parse suite file");
     process.exit(1);
   }
-  const scoreFile = resolve7(opts.score ?? "./tutti.score.ts");
-  if (!existsSync8(scoreFile)) {
-    logger8.error({ file: scoreFile }, "Score file not found");
+  const scoreFile = resolve9(opts.score ?? "./tutti.score.ts");
+  if (!existsSync9(scoreFile)) {
+    logger9.error({ file: scoreFile }, "Score file not found");
     process.exit(1);
   }
-  const spinner = ora5("Loading score...").start();
+  const spinner = ora6("Loading score...").start();
   let score;
   try {
-    score = await ScoreLoader4.load(scoreFile);
+    score = await ScoreLoader5.load(scoreFile);
   } catch (err) {
     spinner.fail("Failed to load score");
-    logger8.error({ error: err instanceof Error ? err.message : String(err) }, "Score load failed");
+    logger9.error({ error: err instanceof Error ? err.message : String(err) }, "Score load failed");
     process.exit(1);
   }
   spinner.succeed("Score loaded");
-  const evalSpinner = ora5("Running " + suite.cases.length + " eval cases...").start();
+  const evalSpinner = ora6("Running " + suite.cases.length + " eval cases...").start();
   const runner = new EvalRunner(score);
   const report = await runner.run(suite);
   evalSpinner.stop();
   printEvalTable(report);
   if (opts.ci && report.summary.failed > 0) {
-    console.error(chalk8.red("  CI mode: " + report.summary.failed + " case(s) failed"));
+    console.error(chalk9.red("  CI mode: " + report.summary.failed + " case(s) failed"));
     process.exit(1);
   }
 }
 
 // src/index.ts
 config();
-var logger9 = createLogger9("tutti-cli");
+var logger10 = createLogger10("tutti-cli");
 process.on("unhandledRejection", (reason) => {
-  logger9.error({ error: reason instanceof Error ? reason.message : String(reason) }, "Unhandled rejection");
+  logger10.error({ error: reason instanceof Error ? reason.message : String(reason) }, "Unhandled rejection");
   process.exit(1);
 });
 process.on("uncaughtException", (err) => {
-  logger9.error({ error: err.message }, "Fatal error");
+  logger10.error({ error: err.message }, "Fatal error");
   process.exit(1);
 });
 var program = new Command();
-program.name("tutti-ai").description("Tutti \u2014 multi-agent orchestration. All agents. All together.").version("0.8.0");
+program.name("tutti-ai").description("Tutti \u2014 multi-agent orchestration. All agents. All together.").version("0.10.0");
 program.command("init [project-name]").description("Create a new Tutti project").option("-t, --template <id>", "Project template to use").action(async (projectName, opts) => {
   await initCommand(projectName, opts.template);
 });
 program.command("templates").description("List all available project templates").action(() => {
   templatesCommand();
 });
-program.command("run [score]").description("Run a Tutti score interactively").action(async (score) => {
-  await runCommand(score);
+program.command("run [score]").description("Run a Tutti score interactively").option("-w, --watch", "Reload the score on file changes").action(async (score, opts) => {
+  await runCommand(score, { watch: opts.watch });
 });
+program.command("resume <session-id>").description("Resume a crashed or interrupted run from its last checkpoint").option(
+  "--store <backend>",
+  "Durable store the checkpoint was written to (redis | postgres)",
+  "redis"
+).option("-s, --score <path>", "Path to score file (default: ./tutti.score.ts)").option("-a, --agent <name>", "Agent key to resume (default: score.entry or the first agent)").option("-y, --yes", "Skip the confirmation prompt").action(
+  async (sessionId, opts) => {
+    if (opts.store !== "redis" && opts.store !== "postgres") {
+      console.error("--store must be 'redis' or 'postgres'");
+      process.exit(1);
+    }
+    const resolved = {
+      store: opts.store,
+      ...opts.score !== void 0 ? { score: opts.score } : {},
+      ...opts.agent !== void 0 ? { agent: opts.agent } : {},
+      ...opts.yes !== void 0 ? { yes: opts.yes } : {}
+    };
+    await resumeCommand(sessionId, resolved);
+  }
+);
 program.command("add <voice>").description("Add a voice to your project").action((voice) => {
   addCommand(voice);
 });