@tuttiai/cli 0.16.0 → 0.17.0

package/dist/index.js

@@ -2,7 +2,7 @@
 
 // src/index.ts
 import { config } from "dotenv";
-import { createLogger as createLogger16 } from "@tuttiai/core";
+import { createLogger as createLogger18 } from "@tuttiai/core";
 import { Command } from "commander";
 
 // src/commands/init.ts
@@ -1729,34 +1729,568 @@ async function evalCommand(suitePath, opts) {
   }
 }
 
+// src/commands/eval-record.ts
+import { readFile } from "fs/promises";
+import { join as join2, resolve as resolve10 } from "path";
+import chalk11 from "chalk";
+import Enquirer3 from "enquirer";
+import {
+  JsonFileGoldenStore,
+  PostgresSessionStore,
+  SecretsManager as SecretsManager5,
+  createLogger as createLogger10
+} from "@tuttiai/core";
+
+// src/commands/eval-record-render.ts
+import chalk10 from "chalk";
+function extractSessionDraft(session) {
+  const firstUser = session.messages.find((m) => m.role === "user");
+  const lastAssistant = [...session.messages].reverse().find((m) => m.role === "assistant");
+  return {
+    input: firstUser ? messageText(firstUser) : "",
+    output: lastAssistant ? messageText(lastAssistant) : "",
+    tool_sequence: collectToolSequence(session.messages)
+  };
+}
+function messageText(msg) {
+  if (typeof msg.content === "string") return msg.content;
+  return msg.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+}
+function collectToolSequence(messages) {
+  const seq = [];
+  for (const msg of messages) {
+    if (msg.role !== "assistant" || typeof msg.content === "string") continue;
+    for (const block of msg.content) {
+      if (block.type === "tool_use") seq.push(block.name);
+    }
+  }
+  return seq;
+}
+function truncate200(text) {
+  const compact = text.replace(/\s+/g, " ").trim();
+  return compact.length > 200 ? compact.slice(0, 199) + "\u2026" : compact;
+}
+function renderSessionSummary(session, draft, tokens) {
+  const lines = [];
+  lines.push(chalk10.cyan.bold("  Session summary"));
+  lines.push(chalk10.dim("  Session: ") + session.id);
+  lines.push(chalk10.dim("  Agent:   ") + session.agent_name);
+  lines.push(chalk10.dim("  Created: ") + session.created_at.toISOString());
+  lines.push(chalk10.dim("  Tokens:  ") + (tokens !== void 0 ? String(tokens) : "\u2014"));
+  lines.push("");
+  lines.push(chalk10.dim("  Input:   ") + truncate200(draft.input || "(empty)"));
+  lines.push(chalk10.dim("  Output:  ") + truncate200(draft.output || "(empty)"));
+  lines.push(
+    chalk10.dim("  Tools:   ") + (draft.tool_sequence.length === 0 ? chalk10.dim("(none)") : draft.tool_sequence.map((t) => chalk10.cyan(t)).join(chalk10.dim(" \u2192 ")))
+  );
+  return lines.join("\n");
+}
+function deriveDefaultCaseName(input) {
+  const compact = input.replace(/\s+/g, " ").trim();
+  return compact.length > 40 ? compact.slice(0, 40) : compact;
+}
+function parseTagInput(raw) {
+  return raw.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+}
+function parseToolSequenceInput(raw) {
+  return raw.split(/[,\u2192]|->/).map((s) => s.trim()).filter((s) => s.length > 0);
+}
+function buildGoldenCase(session, draft, answers, now = /* @__PURE__ */ new Date()) {
+  const expected_output = resolveExpectedOutput(draft, answers);
+  return {
+    id: "",
+    name: answers.name,
+    agent_id: session.agent_name,
+    input: draft.input,
+    ...expected_output !== void 0 ? { expected_output } : {},
+    ...answers.tool_sequence.length > 0 ? { expected_tool_sequence: answers.tool_sequence } : {},
+    scorers: answers.scorers,
+    ...answers.tags.length > 0 ? { tags: answers.tags } : {},
+    promoted_from_session: session.id,
+    created_at: now
+  };
+}
+function resolveExpectedOutput(draft, answers) {
+  if (answers.expected_mode === "actual") return draft.output;
+  if (answers.expected_mode === "custom") return answers.expected_output_custom ?? "";
+  return void 0;
+}
+function renderRecordedConfirmation(stored) {
+  return chalk10.green("\u2713") + " Golden case saved: " + chalk10.bold(stored.name) + chalk10.dim(" (" + stored.id + "). Run `tutti-ai eval run` to test against it.");
+}
+
+// src/commands/eval-record.ts
+var logger10 = createLogger10("tutti-cli");
+var { prompt: prompt3 } = Enquirer3;
+var LOCAL_SESSION_DIR = ".tutti/sessions";
+async function evalRecordCommand(sessionId) {
+  const { session, close } = await resolveSession(sessionId);
+  try {
+    const draft = extractSessionDraft(session);
+    console.log(renderSessionSummary(session, draft, void 0));
+    console.log("");
+    const answers = await collectAnswers(draft);
+    const goldenCase = buildGoldenCase(session, draft, answers);
+    const store = new JsonFileGoldenStore();
+    const stored = await store.saveCase(goldenCase);
+    console.log(renderRecordedConfirmation(stored));
+  } finally {
+    await close();
+  }
+}
+async function resolveSession(sessionId) {
+  const pgUrl = SecretsManager5.optional("TUTTI_PG_URL");
+  if (pgUrl) {
+    return loadFromPostgres(sessionId, pgUrl);
+  }
+  return loadFromLocalLog(sessionId);
+}
+async function loadFromPostgres(sessionId, pgUrl) {
+  const store = new PostgresSessionStore(pgUrl);
+  let session;
+  try {
+    session = await store.getAsync(sessionId);
+  } catch (err) {
+    await store.close();
+    logger10.error(
+      { error: err instanceof Error ? err.message : String(err) },
+      "Session store error"
+    );
+    process.exit(1);
+  }
+  if (!session) {
+    await store.close();
+    exitSessionNotFound(sessionId, "postgres");
+  }
+  return { session, close: () => store.close() };
+}
+async function loadFromLocalLog(sessionId) {
+  const path = resolve10(join2(LOCAL_SESSION_DIR, sessionId + ".json"));
+  let raw;
+  try {
+    raw = await readFile(path, "utf8");
+  } catch {
+    exitSessionNotFound(sessionId, "local");
+  }
+  const parsed = JSON.parse(raw);
+  const session = reviveLocalSession(parsed);
+  return { session, close: () => Promise.resolve() };
+}
+function reviveLocalSession(raw) {
+  const obj = raw;
+  return {
+    ...obj,
+    created_at: new Date(obj.created_at),
+    updated_at: new Date(obj.updated_at)
+  };
+}
+function exitSessionNotFound(sessionId, source) {
+  console.error(chalk11.red("Session not found: " + sessionId));
+  if (source === "postgres") {
+    console.error(
+      chalk11.dim(
+        "  Checked the Postgres session store at TUTTI_PG_URL. Verify the id and that the env var points at the right database."
+      )
+    );
+  } else {
+    console.error(
+      chalk11.dim(
+        "  TUTTI_PG_URL is unset and no local log exists at " + LOCAL_SESSION_DIR + "/" + sessionId + ".json.\n  Set TUTTI_PG_URL to pull the session from Postgres."
+      )
+    );
+  }
+  process.exit(1);
+}
+async function collectAnswers(draft) {
+  const { name } = await prompt3({
+    type: "input",
+    name: "name",
+    message: "Case name?",
+    initial: deriveDefaultCaseName(draft.input) || "unnamed-case"
+  });
+  const expected_mode = await promptExpectedMode();
+  const expected_output_custom = expected_mode === "custom" ? await promptCustomExpected() : void 0;
+  const tool_sequence = await promptToolSequence(draft.tool_sequence);
+  const scorers = await promptScorers(expected_mode, tool_sequence.length > 0);
+  const { tagsRaw } = await prompt3({
+    type: "input",
+    name: "tagsRaw",
+    message: "Tags (comma-separated, optional)?",
+    initial: ""
+  });
+  return {
+    name: name.trim() === "" ? deriveDefaultCaseName(draft.input) : name.trim(),
+    expected_mode,
+    ...expected_output_custom !== void 0 ? { expected_output_custom } : {},
+    tool_sequence,
+    scorers,
+    tags: parseTagInput(tagsRaw)
+  };
+}
+async function promptExpectedMode() {
+  const { choice } = await prompt3({
+    type: "select",
+    name: "choice",
+    message: "Expected output?",
+    choices: [
+      { name: "actual", message: "Use the actual output from this run (exact match)" },
+      { name: "custom", message: "Enter a custom expected output" },
+      { name: "skip", message: "Skip \u2014 rely on tool-sequence / custom scorers" }
+    ]
+  });
+  if (choice === "actual" || choice === "custom" || choice === "skip") return choice;
+  return "skip";
+}
+async function promptCustomExpected() {
+  const { expected } = await prompt3({
+    type: "input",
+    name: "expected",
+    message: "Custom expected output:"
+  });
+  return expected;
+}
+async function promptToolSequence(actual) {
+  const initial = actual.join(", ");
+  const { edited } = await prompt3({
+    type: "input",
+    name: "edited",
+    message: "Expected tool sequence (comma-separated, empty to skip)?",
+    initial
+  });
+  return parseToolSequenceInput(edited);
+}
+async function promptScorers(expectedMode, hasToolSequence) {
+  const defaults = [];
+  if (expectedMode !== "skip") defaults.push("exact");
+  if (hasToolSequence) defaults.push("tool-sequence");
+  const multiselectOpts = {
+    type: "multiselect",
+    name: "picked",
+    message: "Scorers to attach?",
+    choices: [
+      { name: "exact", message: "Exact output match" },
+      { name: "similarity", message: "Cosine similarity" },
+      { name: "tool-sequence", message: "Tool sequence match" },
+      { name: "custom", message: "Custom scorer module" }
+    ],
+    initial: defaults
+  };
+  const { picked } = await prompt3(multiselectOpts);
+  const refs = [];
+  for (const kind of picked) {
+    if (kind === "custom") {
+      const { path } = await prompt3({
+        type: "input",
+        name: "path",
+        message: "Custom scorer module path (relative to CWD)?"
+      });
+      refs.push({ type: "custom", path: path.trim() });
+    } else if (kind === "exact" || kind === "similarity" || kind === "tool-sequence") {
+      refs.push({ type: kind });
+    }
+  }
+  return refs;
+}
+
+// src/commands/eval-list.ts
+import { JsonFileGoldenStore as JsonFileGoldenStore2 } from "@tuttiai/core";
+
+// src/commands/eval-list-render.ts
+import chalk12 from "chalk";
+function visibleLen(s) {
+  return s.replace(/\u001b\[[0-9;]*m/g, "").length;
+}
+function pad(s, len) {
+  const v = visibleLen(s);
+  return v >= len ? s : s + " ".repeat(len - v);
+}
+function truncate(text, max) {
+  const oneLine = text.replace(/\s+/g, " ").trim();
+  return oneLine.length > max ? oneLine.slice(0, max - 1) + "\u2026" : oneLine;
+}
+function formatIsoShort(d) {
+  const iso = d.toISOString();
+  return iso.slice(0, 10) + " " + iso.slice(11, 16);
+}
+function scorersCell(scorers) {
+  if (scorers.length === 0) return chalk12.dim("(none)");
+  return scorers.map((s) => s.type).join(",");
+}
+function renderStatus(status) {
+  if (status === "pass") return chalk12.green("pass");
+  if (status === "fail") return chalk12.red("FAIL");
+  return chalk12.dim("never");
+}
+function deriveLastRunStatus(latest) {
+  if (!latest) return "never";
+  return latest.passed ? "pass" : "fail";
+}
+function renderGoldenCasesTable(cases, latestByCaseId) {
+  if (cases.length === 0) {
+    return chalk12.dim(
+      "No golden cases recorded. Run `tutti-ai eval record <session-id>` to pin one."
+    );
+  }
+  const rows = cases.map((c) => ({
+    id: c.id.slice(0, 8),
+    name: truncate(c.name, 36),
+    agent: truncate(c.agent_id, 16),
+    scorers: truncate(scorersCell(c.scorers), 32),
+    status: deriveLastRunStatus(latestByCaseId.get(c.id)),
+    created: formatIsoShort(c.created_at)
+  }));
+  const widths = {
+    id: 8,
+    name: Math.max(4, ...rows.map((r) => visibleLen(r.name))),
+    agent: Math.max(5, ...rows.map((r) => visibleLen(r.agent))),
+    scorers: Math.max(7, ...rows.map((r) => visibleLen(r.scorers))),
+    status: 6,
+    created: 16
+  };
+  const header = chalk12.dim.bold(
+    pad("ID", widths.id) + "  " + pad("NAME", widths.name) + "  " + pad("AGENT", widths.agent) + "  " + pad("SCORERS", widths.scorers) + "  " + pad("STATUS", widths.status) + "  " + pad("CREATED", widths.created)
+  );
+  const body = rows.map(
+    (r) => pad(chalk12.dim(r.id), widths.id) + "  " + pad(r.name, widths.name) + "  " + pad(chalk12.cyan(r.agent), widths.agent) + "  " + pad(r.scorers, widths.scorers) + "  " + pad(renderStatus(r.status), widths.status) + "  " + pad(chalk12.dim(r.created), widths.created)
+  ).join("\n");
+  return header + "\n" + body;
+}
+
+// src/commands/eval-list.ts
+async function evalListCommand() {
+  const store = new JsonFileGoldenStore2();
+  const cases = await store.listCases();
+  const latest = await Promise.all(
+    cases.map(async (c) => [c.id, await store.latestRun(c.id)])
+  );
+  const latestByCaseId = new Map(latest);
+  console.log(renderGoldenCasesTable(cases, latestByCaseId));
+}
+
+// src/commands/eval-run.ts
+import { mkdir, writeFile } from "fs/promises";
+import { dirname as dirname2, resolve as resolve11 } from "path";
+import chalk14 from "chalk";
+import ora7 from "ora";
+import {
+  GoldenRunner,
+  JsonFileGoldenStore as JsonFileGoldenStore3,
+  ScoreLoader as ScoreLoader6,
+  createLogger as createLogger11
+} from "@tuttiai/core";
+
+// src/commands/eval-run-render.ts
+import chalk13 from "chalk";
+var DIFF_PREVIEW_LINES = 20;
+function filterCases(cases, filters) {
+  return cases.filter((c) => {
+    if (filters.case !== void 0 && !c.id.startsWith(filters.case)) return false;
+    if (filters.tag !== void 0) {
+      const tags = c.tags ?? [];
+      if (!tags.includes(filters.tag)) return false;
+    }
+    return true;
+  });
+}
+function scoreSummary(scores) {
+  const parts = Object.values(scores).map(
+    (s) => s.scorer + ":" + s.score.toFixed(2)
+  );
+  return parts.length > 0 ? parts.join(", ") : "(no scorers)";
+}
+function firstFailure(scores) {
+  return Object.values(scores).find((s) => !s.passed);
+}
+function truncateDiffPreview(diff, maxLines = DIFF_PREVIEW_LINES) {
+  const lines = diff.split("\n");
+  if (lines.length <= maxLines) return diff;
+  const kept = lines.slice(0, maxLines);
+  const dropped = lines.length - maxLines;
+  return kept.join("\n") + "\n\u2026 (" + dropped + " more lines)";
+}
+function renderCaseLine(goldenCase, run2) {
+  if (run2.passed) {
+    return chalk13.green("\u2713 ") + chalk13.bold(goldenCase.name) + chalk13.dim(" \u2014 " + scoreSummary(run2.scores));
+  }
+  const failure = firstFailure(run2.scores);
+  const why = failure ? failure.scorer + (failure.detail ? ": " + failure.detail : " failed") : "run failed";
+  const head = chalk13.red("\u2717 ") + chalk13.bold(goldenCase.name) + chalk13.dim(" \u2014 " + why);
+  if (run2.diff) {
+    return head + "\n" + chalk13.dim(truncateDiffPreview(run2.diff));
+  }
+  return head;
+}
+function renderCaseLineCI(goldenCase, run2) {
+  const status = run2.passed ? "PASS" : "FAIL";
+  const id8 = goldenCase.id.slice(0, 8);
+  const scoreStr = scoreSummary(run2.scores);
+  const tokens = "tokens=" + run2.tokens;
+  const cost = run2.cost_usd !== void 0 ? " cost=$" + run2.cost_usd.toFixed(4) : "";
+  const why = !run2.passed && firstFailure(run2.scores) ? " why=" + (firstFailure(run2.scores)?.scorer ?? "") : "";
+  return status + " " + id8 + " " + goldenCase.name + " [" + scoreStr + "] " + tokens + cost + why;
+}
+function computeStats(runs) {
+  const passed = runs.filter((r) => r.passed).length;
+  const totalTokens = runs.reduce((sum, r) => sum + r.tokens, 0);
+  const totalCostUsd = runs.reduce((sum, r) => sum + (r.cost_usd ?? 0), 0);
+  return {
+    passed,
+    failed: runs.length - passed,
+    total: runs.length,
+    totalTokens,
+    totalCostUsd
+  };
+}
+function renderSummary(stats, colors) {
+  const avgTokens = stats.total > 0 ? Math.round(stats.totalTokens / stats.total) : 0;
+  const passStr = stats.passed + " passed";
+  const failStr = stats.failed + " failed";
+  const passOut = colors ? chalk13.green(passStr) : passStr;
+  const failOut = colors && stats.failed > 0 ? chalk13.red(failStr) : failStr;
+  return passOut + ", " + failOut + " out of " + stats.total + " cases | avg tokens: " + avgTokens + " | total cost: $" + stats.totalCostUsd.toFixed(2);
+}
+
+// src/commands/eval-run-junit.ts
+function escapeXmlText(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeXmlAttr(s) {
+  return escapeXmlText(s).replace(/"/g, "&quot;").replace(/\n/g, "&#10;");
+}
+function firstFailure2(scores) {
+  return Object.values(scores).find((s) => !s.passed);
+}
+function toJunitXml(rows, suiteName = "tutti-eval") {
+  const totalTimeSec = rows.reduce((s, r) => s + r.durationMs / 1e3, 0);
+  const failures = rows.filter((r) => !r.run.passed).length;
+  const attrs = 'name="' + escapeXmlAttr(suiteName) + '" tests="' + rows.length + '" failures="' + failures + '" errors="0" time="' + totalTimeSec.toFixed(3) + '"';
+  const body = rows.map(renderTestCase).join("");
+  return '<?xml version="1.0" encoding="UTF-8"?>\n<testsuites ' + attrs + ">\n  <testsuite " + attrs + ">\n" + body + "  </testsuite>\n</testsuites>\n";
+}
+function renderTestCase({ goldenCase, run: run2, durationMs }) {
+  const timeSec = (durationMs / 1e3).toFixed(3);
+  const caseAttrs = ' classname="' + escapeXmlAttr(goldenCase.agent_id) + '" name="' + escapeXmlAttr(goldenCase.name) + '" time="' + timeSec + '"';
+  if (run2.passed) {
+    return "    <testcase" + caseAttrs + "/>\n";
+  }
+  const failure = firstFailure2(run2.scores);
+  const message = failure ? failure.scorer + (failure.detail ? ": " + failure.detail : " failed") : "case failed";
+  const parts = [];
+  if (failure?.detail) parts.push(failure.detail);
+  if (run2.diff) parts.push(run2.diff);
+  parts.push("---- output ----\n" + run2.output);
+  const bodyRaw = parts.join("\n\n").replace(/]]>/g, "]]]]><![CDATA[>");
+  return "    <testcase" + caseAttrs + '>\n      <failure message="' + escapeXmlAttr(message) + '" type="ScorerFailed"><![CDATA[' + bodyRaw + "]]></failure>\n    </testcase>\n";
+}
+
+// src/commands/eval-run.ts
+var logger11 = createLogger11("tutti-cli");
+var DEFAULT_JUNIT_PATH = ".tutti/eval-results.xml";
+async function runEvalRun(opts, deps = {}) {
+  const store = deps.store ?? new JsonFileGoldenStore3();
+  const all = await store.listCases();
+  const cases = filterCases(all, {
+    ...opts.case !== void 0 ? { case: opts.case } : {},
+    ...opts.tag !== void 0 ? { tag: opts.tag } : {}
+  });
+  if (cases.length === 0) {
+    console.log(
+      chalk14.dim(
+        "No golden cases match the filter. Run `tutti-ai eval record <session-id>` first."
+      )
+    );
+    return { passed: 0, failed: 0, total: 0, totalTokens: 0, totalCostUsd: 0 };
+  }
+  const score = deps.score ?? await loadScore(opts.score);
+  const runner = new GoldenRunner({ score, store });
+  const rows = [];
+  for (const c of cases) {
+    const start = Date.now();
+    const run2 = await runner.runGoldenCase(c);
+    const durationMs = Date.now() - start;
+    rows.push({ goldenCase: c, run: run2, durationMs });
+    printCaseResult(c, run2, opts.ci === true);
+  }
+  const runs = rows.map((r) => r.run);
+  const stats = computeStats(runs);
+  console.log(renderSummary(stats, !opts.ci));
+  let xmlPath;
+  if (opts.ci) {
+    xmlPath = resolve11(deps.junitPath ?? DEFAULT_JUNIT_PATH);
+    await writeJunitFile(xmlPath, rows);
+  }
+  return {
+    passed: stats.passed,
+    failed: stats.failed,
+    total: stats.total,
+    totalTokens: stats.totalTokens,
+    totalCostUsd: stats.totalCostUsd,
+    ...xmlPath !== void 0 ? { xmlPath } : {}
+  };
+}
+async function evalRunCommand(opts) {
+  const result = await runEvalRun(opts);
+  if (opts.ci && result.failed > 0) {
+    process.exit(1);
+  }
+}
+async function loadScore(scorePath) {
+  const path = resolve11(scorePath ?? "./tutti.score.ts");
+  const spinner = ora7({ color: "cyan" }).start("Loading score...");
+  try {
+    const score = await ScoreLoader6.load(path);
+    spinner.stop();
+    return score;
+  } catch (err) {
+    spinner.fail("Failed to load score");
+    logger11.error(
+      { error: err instanceof Error ? err.message : String(err) },
+      "Score load error"
+    );
+    process.exit(1);
+  }
+}
+function printCaseResult(goldenCase, run2, ci) {
+  if (ci) {
+    console.log(renderCaseLineCI(goldenCase, run2));
+  } else {
+    console.log(renderCaseLine(goldenCase, run2));
+  }
+}
+async function writeJunitFile(xmlPath, rows) {
+  const xml = toJunitXml(rows);
+  await mkdir(dirname2(xmlPath), { recursive: true });
+  await writeFile(xmlPath, xml, "utf8");
+}
+
 // src/commands/serve.ts
 import { existsSync as existsSync10 } from "fs";
-import { resolve as resolve10 } from "path";
-import chalk10 from "chalk";
+import { resolve as resolve12 } from "path";
+import chalk15 from "chalk";
 import {
   TuttiRuntime as TuttiRuntime4,
-  ScoreLoader as ScoreLoader6,
+  ScoreLoader as ScoreLoader7,
   AnthropicProvider as AnthropicProvider4,
   OpenAIProvider as OpenAIProvider4,
   GeminiProvider as GeminiProvider4,
-  SecretsManager as SecretsManager5,
+  SecretsManager as SecretsManager6,
   InMemorySessionStore as InMemorySessionStore2,
-  createLogger as createLogger10
+  createLogger as createLogger12
 } from "@tuttiai/core";
 import { createServer, DEFAULT_PORT, SERVER_VERSION } from "@tuttiai/server";
-var logger10 = createLogger10("tutti-serve");
+var logger12 = createLogger12("tutti-serve");
 async function serveCommand(scorePath, options = {}) {
-  const file = resolve10(scorePath ?? "./tutti.score.ts");
+  const file = resolve12(scorePath ?? "./tutti.score.ts");
   if (!existsSync10(file)) {
-    logger10.error({ file }, "Score file not found");
-    console.error(chalk10.dim('Run "tutti-ai init" to create a new project.'));
+    logger12.error({ file }, "Score file not found");
+    console.error(chalk15.dim('Run "tutti-ai init" to create a new project.'));
     process.exit(1);
   }
   let score;
   try {
-    score = await ScoreLoader6.load(file);
+    score = await ScoreLoader7.load(file);
   } catch (err) {
-    logger10.error(
+    logger12.error(
       { error: err instanceof Error ? err.message : String(err) },
       "Failed to load score"
     );
@@ -1769,9 +2303,9 @@ async function serveCommand(scorePath, options = {}) {
   ];
   for (const [ProviderClass, envVar] of providerKeyMap) {
     if (score.provider instanceof ProviderClass) {
-      const key = SecretsManager5.optional(envVar);
+      const key = SecretsManager6.optional(envVar);
       if (!key) {
-        logger10.error({ envVar }, "Missing API key");
+        logger12.error({ envVar }, "Missing API key");
         process.exit(1);
       }
     }
@@ -1779,7 +2313,7 @@ async function serveCommand(scorePath, options = {}) {
   const agentNames = Object.keys(score.agents);
   const agentName = options.agent ?? (typeof score.entry === "string" ? score.entry : void 0) ?? agentNames[0];
   if (!agentName || !Object.hasOwn(score.agents, agentName)) {
-    logger10.error(
+    logger12.error(
       { requested: agentName, available: agentNames },
       "Agent not found in score"
     );
@@ -1794,7 +2328,7 @@ async function serveCommand(scorePath, options = {}) {
   if (options.watch) {
     reactive = new ReactiveScore(score, file);
     reactive.on("file-change", () => {
-      console.log(chalk10.cyan("\n[tutti] Score changed, reloading..."));
+      console.log(chalk15.cyan("\n[tutti] Score changed, reloading..."));
     });
     reactive.on("reloaded", () => {
       void (async () => {
@@ -1807,9 +2341,9 @@ async function serveCommand(scorePath, options = {}) {
           runtime = nextRuntime;
           app = nextApp;
           await app.listen({ port, host });
-          console.log(chalk10.green("[tutti] Score reloaded. Server restarted."));
+          console.log(chalk15.green("[tutti] Score reloaded. Server restarted."));
         } catch (err) {
-          logger10.error(
+          logger12.error(
             { error: err instanceof Error ? err.message : String(err) },
             "[tutti] Reload failed \u2014 server continues with previous config"
           );
@@ -1817,7 +2351,7 @@ async function serveCommand(scorePath, options = {}) {
       })();
     });
     reactive.on("reload-failed", (err) => {
-      logger10.error(
+      logger12.error(
         { error: err instanceof Error ? err.message : String(err) },
         "[tutti] Reload failed \u2014 server continues with previous config"
       );
@@ -1826,7 +2360,7 @@ async function serveCommand(scorePath, options = {}) {
   await app.listen({ port, host });
   printBanner(port, host, agentName, score, file, options.watch);
   const shutdown = async (signal) => {
-    console.log(chalk10.dim("\n" + signal + " received \u2014 shutting down..."));
+    console.log(chalk15.dim("\n" + signal + " received \u2014 shutting down..."));
     if (reactive) await reactive.close();
     await app.close();
     process.exit(0);
@@ -1838,7 +2372,7 @@ function parsePort(raw) {
   if (raw === void 0) return DEFAULT_PORT;
   const n = Number.parseInt(raw, 10);
   if (!Number.isInteger(n) || n < 1 || n > 65535) {
-    logger10.error({ port: raw }, "Invalid port number");
+    logger12.error({ port: raw }, "Invalid port number");
     process.exit(1);
   }
   return n;
@@ -1862,56 +2396,56 @@ function printBanner(port, host, agentName, score, file, watch) {
   const display = host === "0.0.0.0" || host === "::" ? "localhost" : host;
   const url = "http://" + display + ":" + port;
   console.log();
-  console.log(chalk10.bold("  Tutti Server v" + SERVER_VERSION));
-  console.log(chalk10.dim("  " + url));
+  console.log(chalk15.bold("  Tutti Server v" + SERVER_VERSION));
+  console.log(chalk15.dim("  " + url));
   console.log();
-  console.log(chalk10.dim("  Score:  ") + (score.name ?? file));
-  console.log(chalk10.dim("  Agent:  ") + agentName);
-  console.log(chalk10.dim("  Agents: ") + Object.keys(score.agents).join(", "));
+  console.log(chalk15.dim("  Score:  ") + (score.name ?? file));
+  console.log(chalk15.dim("  Agent:  ") + agentName);
+  console.log(chalk15.dim("  Agents: ") + Object.keys(score.agents).join(", "));
   if (watch) {
-    console.log(chalk10.dim("  Watch:  ") + chalk10.cyan("enabled"));
+    console.log(chalk15.dim("  Watch:  ") + chalk15.cyan("enabled"));
   }
   console.log();
-  console.log(chalk10.dim("  Endpoints:"));
-  console.log(chalk10.dim("    POST  ") + url + "/run");
-  console.log(chalk10.dim("    POST  ") + url + "/run/stream");
-  console.log(chalk10.dim("    GET   ") + url + "/sessions/:id");
-  console.log(chalk10.dim("    GET   ") + url + "/health");
+  console.log(chalk15.dim("  Endpoints:"));
+  console.log(chalk15.dim("    POST  ") + url + "/run");
+  console.log(chalk15.dim("    POST  ") + url + "/run/stream");
+  console.log(chalk15.dim("    GET   ") + url + "/sessions/:id");
+  console.log(chalk15.dim("    GET   ") + url + "/health");
   console.log();
 }
 
 // src/commands/schedule.ts
 import { existsSync as existsSync11 } from "fs";
-import { resolve as resolve11 } from "path";
-import chalk11 from "chalk";
+import { resolve as resolve13 } from "path";
+import chalk16 from "chalk";
 import {
-  ScoreLoader as ScoreLoader7,
+  ScoreLoader as ScoreLoader8,
   SchedulerEngine,
   PostgresScheduleStore,
   MemoryScheduleStore,
   AgentRunner,
   EventBus,
   InMemorySessionStore as InMemorySessionStore3,
-  SecretsManager as SecretsManager6,
-  createLogger as createLogger11
+  SecretsManager as SecretsManager7,
+  createLogger as createLogger13
 } from "@tuttiai/core";
-var logger11 = createLogger11("tutti-cli");
+var logger13 = createLogger13("tutti-cli");
 function resolveStore() {
-  const pgUrl = SecretsManager6.optional("TUTTI_PG_URL");
+  const pgUrl = SecretsManager7.optional("TUTTI_PG_URL");
   if (pgUrl) {
     return new PostgresScheduleStore({ connection_string: pgUrl });
   }
-  logger11.warn("TUTTI_PG_URL not set \u2014 using in-memory store (not durable across restarts)");
+  logger13.warn("TUTTI_PG_URL not set \u2014 using in-memory store (not durable across restarts)");
   return new MemoryScheduleStore();
 }
 async function scheduleCommand(scorePath) {
-  const file = resolve11(scorePath ?? "./tutti.score.ts");
+  const file = resolve13(scorePath ?? "./tutti.score.ts");
   if (!existsSync11(file)) {
-    console.error(chalk11.red("Score file not found: " + file));
-    console.error(chalk11.dim('Run "tutti-ai init" to create a new project.'));
+    console.error(chalk16.red("Score file not found: " + file));
+    console.error(chalk16.dim('Run "tutti-ai init" to create a new project.'));
     process.exit(1);
   }
-  const score = await ScoreLoader7.load(file);
+  const score = await ScoreLoader8.load(file);
   const events = new EventBus();
   const sessions = new InMemorySessionStore3();
   const runner = new AgentRunner(
@@ -1929,41 +2463,41 @@ async function scheduleCommand(scorePath) {
     registered++;
   }
   if (registered === 0) {
-    console.log(chalk11.yellow("No agents have a schedule config. Nothing to run."));
-    console.log(chalk11.dim("Add schedule: { cron: '...', input: '...' } to an agent in your score."));
+    console.log(chalk16.yellow("No agents have a schedule config. Nothing to run."));
+    console.log(chalk16.dim("Add schedule: { cron: '...', input: '...' } to an agent in your score."));
     process.exit(0);
   }
   events.onAny((e) => {
     if (e.type === "schedule:triggered") {
       const ev = e;
       console.log(
-        chalk11.dim((/* @__PURE__ */ new Date()).toISOString()) + " " + chalk11.cyan("triggered") + " " + chalk11.bold(ev.schedule_id) + " \u2192 " + ev.agent_name
+        chalk16.dim((/* @__PURE__ */ new Date()).toISOString()) + " " + chalk16.cyan("triggered") + " " + chalk16.bold(ev.schedule_id) + " \u2192 " + ev.agent_name
       );
     }
     if (e.type === "schedule:completed") {
       const ev = e;
       console.log(
-        chalk11.dim((/* @__PURE__ */ new Date()).toISOString()) + " " + chalk11.green("completed") + " " + chalk11.bold(ev.schedule_id) + " " + chalk11.dim("(" + ev.duration_ms + "ms)")
+        chalk16.dim((/* @__PURE__ */ new Date()).toISOString()) + " " + chalk16.green("completed") + " " + chalk16.bold(ev.schedule_id) + " " + chalk16.dim("(" + ev.duration_ms + "ms)")
       );
     }
     if (e.type === "schedule:error") {
       const ev = e;
       console.log(
-        chalk11.dim((/* @__PURE__ */ new Date()).toISOString()) + " " + chalk11.red("error") + " " + chalk11.bold(ev.schedule_id) + " \u2014 " + ev.error.message
+        chalk16.dim((/* @__PURE__ */ new Date()).toISOString()) + " " + chalk16.red("error") + " " + chalk16.bold(ev.schedule_id) + " \u2014 " + ev.error.message
       );
     }
   });
   engine.start();
   console.log("");
-  console.log(chalk11.cyan.bold("  Tutti Scheduler"));
-  console.log(chalk11.dim("  Score: " + (score.name ?? file)));
-  console.log(chalk11.dim("  Schedules: " + registered));
-  console.log(chalk11.dim("  Store: " + (SecretsManager6.optional("TUTTI_PG_URL") ? "postgres" : "memory")));
+  console.log(chalk16.cyan.bold("  Tutti Scheduler"));
+  console.log(chalk16.dim("  Score: " + (score.name ?? file)));
+  console.log(chalk16.dim("  Schedules: " + registered));
+  console.log(chalk16.dim("  Store: " + (SecretsManager7.optional("TUTTI_PG_URL") ? "postgres" : "memory")));
   console.log("");
-  console.log(chalk11.dim("  Press Ctrl+C to stop."));
+  console.log(chalk16.dim("  Press Ctrl+C to stop."));
   console.log("");
   const shutdown = () => {
-    console.log(chalk11.dim("\n  Shutting down scheduler..."));
+    console.log(chalk16.dim("\n  Shutting down scheduler..."));
     engine.stop();
     if ("close" in store && typeof store.close === "function") {
       void store.close();
@@ -1978,9 +2512,9 @@ async function scheduleCommand(scorePath) {
 // src/commands/update.ts
 import { execSync as execSync3 } from "child_process";
 import { existsSync as existsSync12, readFileSync as readFileSync5 } from "fs";
-import { resolve as resolve12 } from "path";
-import chalk12 from "chalk";
-import ora7 from "ora";
+import { resolve as resolve14 } from "path";
+import chalk17 from "chalk";
+import ora8 from "ora";
 var TUTTI_PACKAGES = [
   "@tuttiai/core",
   "@tuttiai/cli",
@@ -2023,8 +2557,8 @@ function getLatestVersion(pkg) {
 }
 function detectPackageManager() {
   const cwd = process.cwd();
-  if (existsSync12(resolve12(cwd, "yarn.lock"))) return "yarn";
-  if (existsSync12(resolve12(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync12(resolve14(cwd, "yarn.lock"))) return "yarn";
+  if (existsSync12(resolve14(cwd, "pnpm-lock.yaml"))) return "pnpm";
   return "npm";
 }
 function isGlobalInstall() {
@@ -2040,35 +2574,35 @@ function isGlobalInstall() {
 }
 function updateCommand() {
   console.log();
-  console.log(chalk12.cyan.bold("  Tutti Update"));
+  console.log(chalk17.cyan.bold("  Tutti Update"));
   console.log();
-  const spinner = ora7("Checking for updates...").start();
+  const spinner = ora8("Checking for updates...").start();
   const cliCurrent = getInstalledVersion("@tuttiai/cli") ?? "unknown";
   const cliLatest = getLatestVersion("@tuttiai/cli");
   spinner.stop();
   if (cliLatest && cliCurrent !== cliLatest) {
     console.log(
-      chalk12.yellow("  CLI update available: ") + chalk12.dim(cliCurrent) + " \u2192 " + chalk12.green(cliLatest)
+      chalk17.yellow("  CLI update available: ") + chalk17.dim(cliCurrent) + " \u2192 " + chalk17.green(cliLatest)
     );
     if (isGlobalInstall()) {
-      const updateSpinner2 = ora7("Updating global CLI...").start();
+      const updateSpinner2 = ora8("Updating global CLI...").start();
       try {
         execSync3("npm install -g tutti-ai@latest", { stdio: "pipe" });
         updateSpinner2.succeed("CLI updated to " + cliLatest);
       } catch {
         updateSpinner2.fail("Failed to update global CLI");
-        console.log(chalk12.dim("  Run manually: npm install -g tutti-ai@latest"));
+        console.log(chalk17.dim("  Run manually: npm install -g tutti-ai@latest"));
       }
     } else {
-      console.log(chalk12.dim("  Global: npm install -g tutti-ai@latest"));
+      console.log(chalk17.dim("  Global: npm install -g tutti-ai@latest"));
     }
   } else {
-    console.log(chalk12.green("  CLI is up to date") + chalk12.dim(" (" + cliCurrent + ")"));
+    console.log(chalk17.green("  CLI is up to date") + chalk17.dim(" (" + cliCurrent + ")"));
   }
-  const pkgPath = resolve12(process.cwd(), "package.json");
+  const pkgPath = resolve14(process.cwd(), "package.json");
   if (!existsSync12(pkgPath)) {
     console.log();
-    console.log(chalk12.dim("  No package.json found \u2014 skipping project dependency check."));
+    console.log(chalk17.dim("  No package.json found \u2014 skipping project dependency check."));
     console.log();
     return;
   }
@@ -2076,7 +2610,7 @@ function updateCommand() {
   try {
     pkg = JSON.parse(readFileSync5(pkgPath, "utf-8"));
   } catch {
-    console.log(chalk12.dim("  Could not read package.json"));
+    console.log(chalk17.dim("  Could not read package.json"));
     return;
   }
   const allDeps = /* @__PURE__ */ new Map();
@@ -2093,46 +2627,46 @@ function updateCommand() {
   const installed = TUTTI_PACKAGES.filter((p) => allDeps.has(p));
   if (installed.length === 0) {
     console.log();
-    console.log(chalk12.dim("  No @tuttiai packages found in this project."));
+    console.log(chalk17.dim("  No @tuttiai packages found in this project."));
     console.log();
     return;
   }
   console.log();
-  console.log("  " + chalk12.bold("Project packages:"));
+  console.log("  " + chalk17.bold("Project packages:"));
   const toUpdate = [];
   for (const name of installed) {
     const current = allDeps.get(name) ?? "?";
     const latest = getLatestVersion(name);
     if (!latest) {
-      console.log("  " + chalk12.dim(name) + " " + current + chalk12.dim(" (could not check)"));
+      console.log("  " + chalk17.dim(name) + " " + current + chalk17.dim(" (could not check)"));
       continue;
     }
     const cleanCurrent = current.replace(/^[\^~]/, "");
     if (cleanCurrent === latest) {
-      console.log("  " + chalk12.green("\u2714") + " " + name + " " + chalk12.dim(latest));
+      console.log("  " + chalk17.green("\u2714") + " " + name + " " + chalk17.dim(latest));
     } else {
       console.log(
-        "  " + chalk12.yellow("\u2191") + " " + name + " " + chalk12.dim(cleanCurrent) + " \u2192 " + chalk12.green(latest)
+        "  " + chalk17.yellow("\u2191") + " " + name + " " + chalk17.dim(cleanCurrent) + " \u2192 " + chalk17.green(latest)
       );
       toUpdate.push(name + "@latest");
     }
   }
   if (toUpdate.length === 0) {
     console.log();
-    console.log(chalk12.green("  All packages are up to date."));
+    console.log(chalk17.green("  All packages are up to date."));
     console.log();
     return;
   }
   console.log();
   const pm = detectPackageManager();
   const installCmd = pm === "yarn" ? "yarn add " + toUpdate.join(" ") : pm === "pnpm" ? "pnpm add " + toUpdate.join(" ") : "npm install " + toUpdate.join(" ");
-  const updateSpinner = ora7("Updating " + toUpdate.length + " package(s)...").start();
+  const updateSpinner = ora8("Updating " + toUpdate.length + " package(s)...").start();
   try {
     execSync3(installCmd, { cwd: process.cwd(), stdio: "pipe" });
     updateSpinner.succeed("Updated " + toUpdate.length + " package(s)");
   } catch {
     updateSpinner.fail("Update failed");
-    console.log(chalk12.dim("  Run manually: " + installCmd));
+    console.log(chalk17.dim("  Run manually: " + installCmd));
   }
   console.log();
 }
@@ -2140,9 +2674,9 @@ function updateCommand() {
 // src/commands/outdated.ts
 import { execSync as execSync4 } from "child_process";
 import { existsSync as existsSync13, readFileSync as readFileSync6 } from "fs";
-import { resolve as resolve13 } from "path";
-import chalk13 from "chalk";
-import ora8 from "ora";
+import { resolve as resolve15 } from "path";
+import chalk18 from "chalk";
+import ora9 from "ora";
 function getLatestVersion2(pkg) {
   try {
     return execSync4(`npm view ${pkg} version 2>/dev/null`, {
@@ -2153,21 +2687,21 @@ function getLatestVersion2(pkg) {
     return null;
   }
 }
-function pad(s, len) {
+function pad2(s, len) {
   return s.length >= len ? s : s + " ".repeat(len - s.length);
 }
 function outdatedCommand() {
-  const pkgPath = resolve13(process.cwd(), "package.json");
+  const pkgPath = resolve15(process.cwd(), "package.json");
   if (!existsSync13(pkgPath)) {
-    console.error(chalk13.red("No package.json found in the current directory."));
-    console.error(chalk13.dim('Run "tutti-ai init" to create a new project.'));
+    console.error(chalk18.red("No package.json found in the current directory."));
+    console.error(chalk18.dim('Run "tutti-ai init" to create a new project.'));
     process.exit(1);
   }
   let pkg;
   try {
     pkg = JSON.parse(readFileSync6(pkgPath, "utf-8"));
   } catch {
-    console.error(chalk13.red("Could not parse package.json"));
+    console.error(chalk18.red("Could not parse package.json"));
     process.exit(1);
   }
   const allDeps = /* @__PURE__ */ new Map();
@@ -2183,10 +2717,10 @@ function outdatedCommand() {
   }
   const tuttiDeps = [...allDeps.entries()].filter(([name]) => name.startsWith("@tuttiai/"));
   if (tuttiDeps.length === 0) {
-    console.log(chalk13.dim("No @tuttiai packages found in this project."));
+    console.log(chalk18.dim("No @tuttiai packages found in this project."));
     return;
   }
-  const spinner = ora8("Checking npm registry...").start();
+  const spinner = ora9("Checking npm registry...").start();
   const results = [];
   for (const [name, version] of tuttiDeps) {
     const latest = getLatestVersion2(name);
@@ -2201,41 +2735,41 @@ function outdatedCommand() {
   spinner.stop();
   console.log();
   console.log(
-    chalk13.dim(
-      "  " + pad("PACKAGE", 28) + pad("CURRENT", 12) + pad("LATEST", 12) + "STATUS"
+    chalk18.dim(
+      "  " + pad2("PACKAGE", 28) + pad2("CURRENT", 12) + pad2("LATEST", 12) + "STATUS"
     )
   );
-  console.log(chalk13.dim("  " + "\u2500".repeat(64)));
+  console.log(chalk18.dim("  " + "\u2500".repeat(64)));
   let outdatedCount = 0;
   for (const r of results) {
-    const status = r.outdated ? chalk13.yellow("update available") : chalk13.green("up to date");
+    const status = r.outdated ? chalk18.yellow("update available") : chalk18.green("up to date");
     if (r.outdated) outdatedCount++;
     console.log(
-      "  " + pad(r.name, 28) + pad(r.current, 12) + pad(r.latest, 12) + status
+      "  " + pad2(r.name, 28) + pad2(r.current, 12) + pad2(r.latest, 12) + status
     );
   }
   console.log();
   if (outdatedCount > 0) {
     console.log(
-      chalk13.yellow("  " + outdatedCount + " package(s) can be updated.") + chalk13.dim(" Run: tutti-ai update")
+      chalk18.yellow("  " + outdatedCount + " package(s) can be updated.") + chalk18.dim(" Run: tutti-ai update")
     );
   } else {
-    console.log(chalk13.green("  All packages are up to date."));
+    console.log(chalk18.green("  All packages are up to date."));
   }
   console.log();
 }
 
 // src/commands/info.ts
 import { existsSync as existsSync14, readFileSync as readFileSync7 } from "fs";
-import { resolve as resolve14 } from "path";
-import chalk14 from "chalk";
-import { ScoreLoader as ScoreLoader8, createLogger as createLogger12 } from "@tuttiai/core";
-var logger12 = createLogger12("tutti-cli");
-function pad2(s, len) {
+import { resolve as resolve16 } from "path";
+import chalk19 from "chalk";
+import { ScoreLoader as ScoreLoader9, createLogger as createLogger14 } from "@tuttiai/core";
+var logger14 = createLogger14("tutti-cli");
+function pad3(s, len) {
   return s.length >= len ? s : s + " ".repeat(len - s.length);
 }
 async function infoCommand(scorePath) {
-  const pkgPath = resolve14(process.cwd(), "package.json");
+  const pkgPath = resolve16(process.cwd(), "package.json");
   let projectName = "(unknown)";
   let projectVersion = "(unknown)";
   const installedDeps = /* @__PURE__ */ new Map();
@@ -2258,41 +2792,41 @@ async function infoCommand(scorePath) {
     }
   }
   console.log();
-  console.log(chalk14.cyan.bold("  Tutti Project Info"));
+  console.log(chalk19.cyan.bold("  Tutti Project Info"));
   console.log();
-  console.log("  " + chalk14.dim("Project:") + "  " + chalk14.bold(projectName) + " " + chalk14.dim(projectVersion));
+  console.log("  " + chalk19.dim("Project:") + "  " + chalk19.bold(projectName) + " " + chalk19.dim(projectVersion));
   const tuttiPkgs = [...installedDeps.entries()].filter(([name]) => name.startsWith("@tuttiai/"));
   if (tuttiPkgs.length > 0) {
     console.log();
-    console.log("  " + chalk14.bold("Packages:"));
+    console.log("  " + chalk19.bold("Packages:"));
     for (const [name, version] of tuttiPkgs) {
-      console.log("    " + pad2(name, 28) + chalk14.dim(version));
+      console.log("    " + pad3(name, 28) + chalk19.dim(version));
     }
   }
-  const scoreFile = resolve14(scorePath ?? "./tutti.score.ts");
+  const scoreFile = resolve16(scorePath ?? "./tutti.score.ts");
   if (!existsSync14(scoreFile)) {
     console.log();
-    console.log(chalk14.dim("  No score file found at " + scoreFile));
-    console.log(chalk14.dim('  Run "tutti-ai init" to create a new project.'));
+    console.log(chalk19.dim("  No score file found at " + scoreFile));
+    console.log(chalk19.dim('  Run "tutti-ai init" to create a new project.'));
     console.log();
     return;
   }
   let score;
   try {
-    score = await ScoreLoader8.load(scoreFile);
+    score = await ScoreLoader9.load(scoreFile);
   } catch (err) {
-    logger12.error(
+    logger14.error(
       { error: err instanceof Error ? err.message : String(err) },
       "Failed to load score"
     );
-    console.log(chalk14.dim("  Score file found but failed to load."));
+    console.log(chalk19.dim("  Score file found but failed to load."));
     console.log();
     return;
   }
-  console.log("  " + chalk14.dim("Score:") + "    " + (score.name ?? scoreFile));
+  console.log("  " + chalk19.dim("Score:") + "    " + (score.name ?? scoreFile));
   const agentEntries = Object.entries(score.agents);
   console.log();
-  console.log("  " + chalk14.bold("Agents:") + chalk14.dim(" (" + agentEntries.length + ")"));
+  console.log("  " + chalk19.bold("Agents:") + chalk19.dim(" (" + agentEntries.length + ")"));
   for (const [id, agent] of agentEntries) {
     const voiceNames = agent.voices.map((v) => v.name).join(", ") || "none";
     const model = agent.model ?? score.default_model ?? "(default)";
@@ -2304,22 +2838,22 @@ async function infoCommand(scorePath) {
     if (agent.outputSchema) flags.push("structured");
     if (agent.beforeRun ?? agent.afterRun) flags.push("guardrails");
     console.log();
-    console.log("    " + chalk14.bold(id) + chalk14.dim(" (" + agent.name + ")"));
-    console.log("      " + chalk14.dim("Model:  ") + model);
-    console.log("      " + chalk14.dim("Voices: ") + voiceNames);
+    console.log("    " + chalk19.bold(id) + chalk19.dim(" (" + agent.name + ")"));
+    console.log("      " + chalk19.dim("Model:  ") + model);
+    console.log("      " + chalk19.dim("Voices: ") + voiceNames);
     if (flags.length > 0) {
-      console.log("      " + chalk14.dim("Flags:  ") + flags.join(", "));
+      console.log("      " + chalk19.dim("Flags:  ") + flags.join(", "));
     }
     if (agent.schedule) {
       const sched = agent.schedule;
       const trigger = sched.cron ?? sched.every ?? sched.at ?? "?";
-      console.log("      " + chalk14.dim("Schedule: ") + trigger);
+      console.log("      " + chalk19.dim("Schedule: ") + trigger);
     }
   }
   if (score.entry) {
     const entry = typeof score.entry === "string" ? score.entry : "parallel";
     console.log();
-    console.log("  " + chalk14.dim("Entry:") + "    " + entry);
+    console.log("  " + chalk19.dim("Entry:") + "    " + entry);
   }
   console.log();
 }
@@ -2327,13 +2861,13 @@ async function infoCommand(scorePath) {
 // src/commands/upgrade.ts
 import { execSync as execSync5 } from "child_process";
 import { existsSync as existsSync15, readFileSync as readFileSync8 } from "fs";
-import { resolve as resolve15 } from "path";
-import chalk15 from "chalk";
-import ora9 from "ora";
+import { resolve as resolve17 } from "path";
+import chalk20 from "chalk";
+import ora10 from "ora";
 function detectPackageManager2() {
   const cwd = process.cwd();
-  if (existsSync15(resolve15(cwd, "yarn.lock"))) return "yarn";
-  if (existsSync15(resolve15(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync15(resolve17(cwd, "yarn.lock"))) return "yarn";
+  if (existsSync15(resolve17(cwd, "pnpm-lock.yaml"))) return "pnpm";
   return "npm";
 }
 function resolvePackageName2(input) {
@@ -2352,7 +2886,7 @@ function resolvePackageName2(input) {
   return KNOWN.get(input) ?? (input.startsWith("@") ? input : `@tuttiai/${input}`);
 }
 function getInstalledTuttiPackages() {
-  const pkgPath = resolve15(process.cwd(), "package.json");
+  const pkgPath = resolve17(process.cwd(), "package.json");
   if (!existsSync15(pkgPath)) return /* @__PURE__ */ new Map();
   try {
     const pkg = JSON.parse(readFileSync8(pkgPath, "utf-8"));
@@ -2373,40 +2907,40 @@ function getInstalledTuttiPackages() {
   }
 }
 function upgradeCommand(target) {
-  const pkgPath = resolve15(process.cwd(), "package.json");
+  const pkgPath = resolve17(process.cwd(), "package.json");
   if (!existsSync15(pkgPath)) {
-    console.error(chalk15.red("No package.json found in the current directory."));
-    console.error(chalk15.dim('Run "tutti-ai init" to create a new project.'));
+    console.error(chalk20.red("No package.json found in the current directory."));
+    console.error(chalk20.dim('Run "tutti-ai init" to create a new project.'));
     process.exit(1);
   }
   const pm = detectPackageManager2();
   const installed = getInstalledTuttiPackages();
   if (installed.size === 0) {
-    console.log(chalk15.dim("No @tuttiai packages found in this project."));
+    console.log(chalk20.dim("No @tuttiai packages found in this project."));
     return;
   }
   let packages;
   if (target) {
     const resolved = resolvePackageName2(target);
     if (!installed.has(resolved)) {
-      console.error(chalk15.red(resolved + " is not installed in this project."));
-      console.error(chalk15.dim("Installed: " + [...installed.keys()].join(", ")));
+      console.error(chalk20.red(resolved + " is not installed in this project."));
+      console.error(chalk20.dim("Installed: " + [...installed.keys()].join(", ")));
       process.exit(1);
     }
     packages = [resolved + "@latest"];
-    console.log(chalk15.cyan("  Upgrading " + resolved + "..."));
+    console.log(chalk20.cyan("  Upgrading " + resolved + "..."));
   } else {
     packages = [...installed.keys()].map((p) => p + "@latest");
-    console.log(chalk15.cyan("  Upgrading all " + packages.length + " @tuttiai packages..."));
+    console.log(chalk20.cyan("  Upgrading all " + packages.length + " @tuttiai packages..."));
   }
   const installCmd = pm === "yarn" ? "yarn add " + packages.join(" ") : pm === "pnpm" ? "pnpm add " + packages.join(" ") : "npm install " + packages.join(" ");
-  const spinner = ora9("Installing...").start();
+  const spinner = ora10("Installing...").start();
   try {
     execSync5(installCmd, { cwd: process.cwd(), stdio: "pipe" });
     spinner.succeed("Upgraded " + packages.length + " package(s)");
   } catch {
     spinner.fail("Upgrade failed");
-    console.log(chalk15.dim("  Run manually: " + installCmd));
+    console.log(chalk20.dim("  Run manually: " + installCmd));
     process.exit(1);
   }
   console.log();
@@ -2416,9 +2950,9 @@ function upgradeCommand(target) {
     const oldClean = oldVersion.replace(/^[\^~]/, "");
     const newClean = newVersion.replace(/^[\^~]/, "");
     if (oldClean !== newClean) {
-      console.log("  " + chalk15.green("\u2191") + " " + name + " " + chalk15.dim(oldClean) + " \u2192 " + chalk15.green(newClean));
+      console.log("  " + chalk20.green("\u2191") + " " + name + " " + chalk20.dim(oldClean) + " \u2192 " + chalk20.green(newClean));
     } else {
-      console.log("  " + chalk15.dim("=") + " " + name + " " + chalk15.dim(newClean) + chalk15.dim(" (already latest)"));
+      console.log("  " + chalk20.dim("=") + " " + name + " " + chalk20.dim(newClean) + chalk20.dim(" (already latest)"));
     }
   }
   console.log();
@@ -2426,21 +2960,21 @@ function upgradeCommand(target) {
 
 // src/commands/replay.ts
 import { existsSync as existsSync16 } from "fs";
-import { writeFile } from "fs/promises";
-import { resolve as resolve16 } from "path";
+import { writeFile as writeFile2 } from "fs/promises";
+import { resolve as resolve18 } from "path";
 import { createInterface as createInterface3 } from "readline/promises";
-import chalk17 from "chalk";
-import ora10 from "ora";
+import chalk22 from "chalk";
+import ora11 from "ora";
 import {
-  PostgresSessionStore,
-  ScoreLoader as ScoreLoader9,
+  PostgresSessionStore as PostgresSessionStore2,
+  ScoreLoader as ScoreLoader10,
   TuttiRuntime as TuttiRuntime5,
-  SecretsManager as SecretsManager7,
-  createLogger as createLogger13
+  SecretsManager as SecretsManager8,
+  createLogger as createLogger15
 } from "@tuttiai/core";
 
 // src/commands/replay-render.ts
-import chalk16 from "chalk";
+import chalk21 from "chalk";
 function messageToText2(msg) {
   if (typeof msg.content === "string") return msg.content;
   const parts = [];
@@ -2465,22 +2999,22 @@ function renderList(messages) {
   for (let i = 0; i < messages.length; i++) {
     const msg = messages.at(i);
     if (!msg) continue;
-    const role = msg.role === "user" ? chalk16.blue("user     ") : chalk16.green("assistant");
+    const role = msg.role === "user" ? chalk21.blue("user     ") : chalk21.green("assistant");
     const text = excerpt2(messageToText2(msg), 80);
     lines.push(
-      chalk16.dim(String(i).padStart(3)) + "  " + role + "  " + text
+      chalk21.dim(String(i).padStart(3)) + "  " + role + "  " + text
     );
   }
   return lines.join("\n");
 }
 function renderShow(messages, index) {
   if (index < 0 || index >= messages.length) {
-    return chalk16.red("Index out of range. Valid: 0\u2013" + (messages.length - 1));
+    return chalk21.red("Index out of range. Valid: 0\u2013" + (messages.length - 1));
   }
   const msg = messages.at(index);
-  if (!msg) return chalk16.red("Index out of range.");
+  if (!msg) return chalk21.red("Index out of range.");
   const lines = [];
-  lines.push(chalk16.cyan.bold("Turn " + index) + "  " + chalk16.dim("[" + msg.role + "]"));
+  lines.push(chalk21.cyan.bold("Turn " + index) + "  " + chalk21.dim("[" + msg.role + "]"));
   lines.push("");
   if (typeof msg.content === "string") {
     lines.push(msg.content);
@@ -2489,13 +3023,13 @@ function renderShow(messages, index) {
       if (block.type === "text") {
         lines.push(block.text);
       } else if (block.type === "tool_use") {
-        lines.push(chalk16.yellow("  tool_use: " + block.name));
-        lines.push(chalk16.dim("  id: " + block.id));
-        lines.push(chalk16.dim("  input: " + JSON.stringify(block.input, null, 2)));
+        lines.push(chalk21.yellow("  tool_use: " + block.name));
+        lines.push(chalk21.dim("  id: " + block.id));
+        lines.push(chalk21.dim("  input: " + JSON.stringify(block.input, null, 2)));
       } else if (block.type === "tool_result") {
-        const label = block.is_error ? chalk16.red("  tool_result (error):") : chalk16.green("  tool_result:");
+        const label = block.is_error ? chalk21.red("  tool_result (error):") : chalk21.green("  tool_result:");
         lines.push(label);
-        lines.push(chalk16.dim("  tool_use_id: " + block.tool_use_id));
+        lines.push(chalk21.dim("  tool_use_id: " + block.tool_use_id));
         lines.push("  " + block.content);
       }
     }
@@ -2504,7 +3038,7 @@ function renderShow(messages, index) {
 }
 function renderInspect(messages, index) {
   if (index < 0 || index >= messages.length) {
-    return chalk16.red("Index out of range.");
+    return chalk21.red("Index out of range.");
   }
   return JSON.stringify(messages.at(index), null, 2);
 }
@@ -2557,26 +3091,26 @@ function exportMarkdown(session) {
 }
 
 // src/commands/replay.ts
-var logger13 = createLogger13("tutti-cli");
+var logger15 = createLogger15("tutti-cli");
 async function replayCommand(sessionId, opts = {}) {
-  const pgUrl = SecretsManager7.optional("TUTTI_PG_URL");
+  const pgUrl = SecretsManager8.optional("TUTTI_PG_URL");
   if (!pgUrl) {
-    console.error(chalk17.red("TUTTI_PG_URL is not set."));
+    console.error(chalk22.red("TUTTI_PG_URL is not set."));
     console.error(
-      chalk17.dim(
+      chalk22.dim(
         "The replay command requires PostgreSQL for session persistence.\nSet TUTTI_PG_URL=postgres://user:pass@host/db in your environment."
       )
     );
     process.exit(1);
   }
-  const store = new PostgresSessionStore(pgUrl);
-  const spinner = ora10({ color: "cyan" }).start("Loading session...");
+  const store = new PostgresSessionStore2(pgUrl);
+  const spinner = ora11({ color: "cyan" }).start("Loading session...");
   let session;
   try {
     session = await store.getAsync(sessionId);
   } catch (err) {
     spinner.fail("Failed to load session");
-    logger13.error(
+    logger15.error(
       { error: err instanceof Error ? err.message : String(err) },
       "Session store error"
     );
@@ -2584,27 +3118,27 @@ async function replayCommand(sessionId, opts = {}) {
   }
   spinner.stop();
   if (!session) {
-    console.error(chalk17.red("Session not found: " + sessionId));
-    console.error(chalk17.dim("Check the session ID and ensure TUTTI_PG_URL points to the correct database."));
+    console.error(chalk22.red("Session not found: " + sessionId));
+    console.error(chalk22.dim("Check the session ID and ensure TUTTI_PG_URL points to the correct database."));
     await store.close();
     process.exit(1);
   }
   const messages = session.messages;
   console.log("");
-  console.log(chalk17.cyan.bold("  Tutti Replay"));
-  console.log(chalk17.dim("  Session: " + session.id));
-  console.log(chalk17.dim("  Agent:   " + session.agent_name));
-  console.log(chalk17.dim("  Created: " + session.created_at.toISOString()));
-  console.log(chalk17.dim("  Messages: " + messages.length));
+  console.log(chalk22.cyan.bold("  Tutti Replay"));
+  console.log(chalk22.dim("  Session: " + session.id));
+  console.log(chalk22.dim("  Agent:   " + session.agent_name));
+  console.log(chalk22.dim("  Created: " + session.created_at.toISOString()));
+  console.log(chalk22.dim("  Messages: " + messages.length));
   console.log("");
-  console.log(chalk17.dim("  Commands: list, show <n>, next, prev, inspect, replay-from <n>, export <json|md>, quit"));
+  console.log(chalk22.dim("  Commands: list, show <n>, next, prev, inspect, replay-from <n>, export <json|md>, quit"));
   console.log("");
   let cursor = 0;
   const rl = createInterface3({ input: process.stdin, output: process.stdout });
   try {
     while (true) {
-      const prompt5 = chalk17.cyan("replay [" + cursor + "/" + (messages.length - 1) + "]> ");
-      const raw = await rl.question(prompt5);
+      const prompt6 = chalk22.cyan("replay [" + cursor + "/" + (messages.length - 1) + "]> ");
+      const raw = await rl.question(prompt6);
       const input = raw.trim();
       if (!input) continue;
       const [cmd, ...args] = input.split(/\s+/);
@@ -2612,7 +3146,7 @@ async function replayCommand(sessionId, opts = {}) {
         case "quit":
         case "exit":
         case "q":
-          console.log(chalk17.dim("Bye."));
+          console.log(chalk22.dim("Bye."));
           return;
         case "list":
           console.log(renderList(messages));
@@ -2628,7 +3162,7 @@ async function replayCommand(sessionId, opts = {}) {
             cursor++;
             console.log(renderShow(messages, cursor));
           } else {
-            console.log(chalk17.dim("Already at last message."));
+            console.log(chalk22.dim("Already at last message."));
           }
           break;
         case "prev":
@@ -2636,7 +3170,7 @@ async function replayCommand(sessionId, opts = {}) {
             cursor--;
             console.log(renderShow(messages, cursor));
           } else {
-            console.log(chalk17.dim("Already at first message."));
+            console.log(chalk22.dim("Already at first message."));
           }
           break;
         case "inspect":
@@ -2645,7 +3179,7 @@ async function replayCommand(sessionId, opts = {}) {
         case "replay-from": {
           const turn = parseInt(args[0] ?? "", 10);
           if (isNaN(turn) || turn < 0 || turn >= messages.length) {
-            console.log(chalk17.red("Usage: replay-from <turn-number>"));
+            console.log(chalk22.red("Usage: replay-from <turn-number>"));
             break;
           }
           await handleReplayFrom(turn, session, rl, opts);
@@ -2655,20 +3189,20 @@ async function replayCommand(sessionId, opts = {}) {
           const format = args[0];
           if (format === "json") {
             const filename = "session-" + session.id.slice(0, 8) + ".json";
-            await writeFile(filename, exportJSON(session));
-            console.log(chalk17.green("Exported to " + filename));
+            await writeFile2(filename, exportJSON(session));
+            console.log(chalk22.green("Exported to " + filename));
           } else if (format === "md" || format === "markdown") {
             const filename = "session-" + session.id.slice(0, 8) + ".md";
-            await writeFile(filename, exportMarkdown(session));
-            console.log(chalk17.green("Exported to " + filename));
+            await writeFile2(filename, exportMarkdown(session));
+            console.log(chalk22.green("Exported to " + filename));
           } else {
-            console.log(chalk17.dim("Usage: export <json|md>"));
+            console.log(chalk22.dim("Usage: export <json|md>"));
           }
           break;
         }
         default:
           console.log(
-            chalk17.dim("Unknown command. Available: list, show <n>, next, prev, inspect, replay-from <n>, export <json|md>, quit")
+            chalk22.dim("Unknown command. Available: list, show <n>, next, prev, inspect, replay-from <n>, export <json|md>, quit")
           );
       }
     }
@@ -2678,29 +3212,29 @@ async function replayCommand(sessionId, opts = {}) {
   }
 }
 async function handleReplayFrom(turn, session, rl, opts) {
-  const scoreFile = resolve16(opts.score ?? "./tutti.score.ts");
+  const scoreFile = resolve18(opts.score ?? "./tutti.score.ts");
   if (!existsSync16(scoreFile)) {
-    console.log(chalk17.red("Score file not found: " + scoreFile));
-    console.log(chalk17.dim("Use --score to specify the score file."));
+    console.log(chalk22.red("Score file not found: " + scoreFile));
+    console.log(chalk22.dim("Use --score to specify the score file."));
     return;
   }
   const originalMsg = session.messages.at(turn);
   const originalInput = originalMsg ? messageToText2(originalMsg) : "";
   const answer = await rl.question(
-    chalk17.cyan("Replay from turn " + turn + " with original input? ") + chalk17.dim("(y / enter new input) ")
+    chalk22.cyan("Replay from turn " + turn + " with original input? ") + chalk22.dim("(y / enter new input) ")
   );
   const input = answer.trim().toLowerCase() === "y" || answer.trim() === "" ? originalInput : answer.trim();
   if (!input) {
-    console.log(chalk17.dim("No input provided. Cancelled."));
+    console.log(chalk22.dim("No input provided. Cancelled."));
     return;
   }
-  const spinnerLoad = ora10({ color: "cyan" }).start("Loading score...");
+  const spinnerLoad = ora11({ color: "cyan" }).start("Loading score...");
   let score;
   try {
-    score = await ScoreLoader9.load(scoreFile);
+    score = await ScoreLoader10.load(scoreFile);
   } catch (err) {
     spinnerLoad.fail("Failed to load score");
-    logger13.error({ error: err instanceof Error ? err.message : String(err) }, "Score load error");
+    logger15.error({ error: err instanceof Error ? err.message : String(err) }, "Score load error");
     return;
   }
   spinnerLoad.stop();
@@ -2720,10 +3254,10 @@ async function handleReplayFrom(turn, session, rl, opts) {
   const agentMap = new Map(Object.entries(score.agents));
   const agent = agentMap.get(agentName);
   if (!agent) {
-    console.log(chalk17.red('Agent "' + agentName + '" not found in score.'));
+    console.log(chalk22.red('Agent "' + agentName + '" not found in score.'));
     return;
   }
-  const spinnerRun = ora10({ color: "cyan" }).start("Running from turn " + turn + "...");
+  const spinnerRun = ora11({ color: "cyan" }).start("Running from turn " + turn + "...");
   runtime.events.on("token:stream", (e) => {
     spinnerRun.stop();
     process.stdout.write(e.text);
@@ -2732,39 +3266,39 @@ async function handleReplayFrom(turn, session, rl, opts) {
     const result = await runtime.run(agentName, input, session.id);
     spinnerRun.stop();
     console.log("");
-    console.log(chalk17.green("Replay complete."));
-    console.log(chalk17.dim("  Turns: " + result.turns));
-    console.log(chalk17.dim("  Tokens: " + result.usage.input_tokens + " in / " + result.usage.output_tokens + " out"));
+    console.log(chalk22.green("Replay complete."));
+    console.log(chalk22.dim("  Turns: " + result.turns));
+    console.log(chalk22.dim("  Tokens: " + result.usage.input_tokens + " in / " + result.usage.output_tokens + " out"));
     console.log("");
     console.log(result.output);
   } catch (err) {
     spinnerRun.fail("Replay failed");
-    logger13.error({ error: err instanceof Error ? err.message : String(err) }, "Replay error");
+    logger15.error({ error: err instanceof Error ? err.message : String(err) }, "Replay error");
   }
 }
 
 // src/commands/schedules.ts
 import { existsSync as existsSync17 } from "fs";
-import { resolve as resolve17 } from "path";
-import chalk18 from "chalk";
+import { resolve as resolve19 } from "path";
+import chalk23 from "chalk";
 import {
-  ScoreLoader as ScoreLoader10,
+  ScoreLoader as ScoreLoader11,
   SchedulerEngine as SchedulerEngine2,
   PostgresScheduleStore as PostgresScheduleStore2,
   MemoryScheduleStore as MemoryScheduleStore2,
   AgentRunner as AgentRunner2,
   EventBus as EventBus2,
   InMemorySessionStore as InMemorySessionStore4,
-  SecretsManager as SecretsManager8,
-  createLogger as createLogger14
+  SecretsManager as SecretsManager9,
+  createLogger as createLogger16
 } from "@tuttiai/core";
-var logger14 = createLogger14("tutti-cli");
+var logger16 = createLogger16("tutti-cli");
 function resolveStore2() {
-  const pgUrl = SecretsManager8.optional("TUTTI_PG_URL");
+  const pgUrl = SecretsManager9.optional("TUTTI_PG_URL");
   if (pgUrl) {
     return new PostgresScheduleStore2({ connection_string: pgUrl });
   }
-  logger14.warn("TUTTI_PG_URL not set \u2014 using in-memory store (schedules are ephemeral)");
+  logger16.warn("TUTTI_PG_URL not set \u2014 using in-memory store (schedules are ephemeral)");
   return new MemoryScheduleStore2();
 }
 async function closeStore(store) {
@@ -2778,7 +3312,7 @@ function formatTrigger(r) {
   if (r.config.at) return "at " + r.config.at;
   return "?";
 }
-function pad3(s, len) {
+function pad4(s, len) {
   return s.length >= len ? s : s + " ".repeat(len - s.length);
 }
 async function schedulesListCommand() {
@@ -2786,22 +3320,22 @@ async function schedulesListCommand() {
   try {
     const records = await store.list();
     if (records.length === 0) {
-      console.log(chalk18.dim("No schedules found."));
-      console.log(chalk18.dim('Run "tutti-ai schedule" to start the scheduler daemon.'));
+      console.log(chalk23.dim("No schedules found."));
+      console.log(chalk23.dim('Run "tutti-ai schedule" to start the scheduler daemon.'));
       return;
     }
     console.log("");
     console.log(
-      chalk18.dim(
-        "  " + pad3("ID", 20) + pad3("AGENT", 16) + pad3("TRIGGER", 22) + pad3("ENABLED", 10) + pad3("RUNS", 8) + "CREATED"
+      chalk23.dim(
+        "  " + pad4("ID", 20) + pad4("AGENT", 16) + pad4("TRIGGER", 22) + pad4("ENABLED", 10) + pad4("RUNS", 8) + "CREATED"
       )
     );
-    console.log(chalk18.dim("  " + "\u2500".repeat(90)));
+    console.log(chalk23.dim("  " + "\u2500".repeat(90)));
     for (const r of records) {
-      const enabled = r.enabled ? chalk18.green("yes") : chalk18.red("no") + " ";
+      const enabled = r.enabled ? chalk23.green("yes") : chalk23.red("no") + " ";
       const maxLabel = r.config.max_runs ? r.run_count + "/" + r.config.max_runs : String(r.run_count);
       console.log(
-        "  " + chalk18.bold(pad3(r.id, 20)) + pad3(r.agent_id, 16) + pad3(formatTrigger(r), 22) + pad3(enabled, 10) + pad3(maxLabel, 8) + chalk18.dim(r.created_at.toISOString().slice(0, 10))
+        "  " + chalk23.bold(pad4(r.id, 20)) + pad4(r.agent_id, 16) + pad4(formatTrigger(r), 22) + pad4(enabled, 10) + pad4(maxLabel, 8) + chalk23.dim(r.created_at.toISOString().slice(0, 10))
       );
     }
     console.log("");
@@ -2814,11 +3348,11 @@ async function schedulesEnableCommand(id) {
   try {
     const record = await store.get(id);
     if (!record) {
-      console.error(chalk18.red('Schedule "' + id + '" not found.'));
+      console.error(chalk23.red('Schedule "' + id + '" not found.'));
       process.exit(1);
     }
     await store.setEnabled(id, true);
-    console.log(chalk18.green('Schedule "' + id + '" enabled.'));
+    console.log(chalk23.green('Schedule "' + id + '" enabled.'));
   } finally {
     await closeStore(store);
   }
@@ -2828,22 +3362,22 @@ async function schedulesDisableCommand(id) {
   try {
     const record = await store.get(id);
     if (!record) {
-      console.error(chalk18.red('Schedule "' + id + '" not found.'));
+      console.error(chalk23.red('Schedule "' + id + '" not found.'));
       process.exit(1);
     }
     await store.setEnabled(id, false);
-    console.log(chalk18.yellow('Schedule "' + id + '" disabled.'));
+    console.log(chalk23.yellow('Schedule "' + id + '" disabled.'));
   } finally {
     await closeStore(store);
   }
 }
 async function schedulesTriggerCommand(id, scorePath) {
-  const file = resolve17(scorePath ?? "./tutti.score.ts");
+  const file = resolve19(scorePath ?? "./tutti.score.ts");
   if (!existsSync17(file)) {
-    console.error(chalk18.red("Score file not found: " + file));
+    console.error(chalk23.red("Score file not found: " + file));
     process.exit(1);
   }
-  const score = await ScoreLoader10.load(file);
+  const score = await ScoreLoader11.load(file);
   const events = new EventBus2();
   const sessions = new InMemorySessionStore4();
   const runner = new AgentRunner2(score.provider, events, sessions);
@@ -2851,30 +3385,30 @@ async function schedulesTriggerCommand(id, scorePath) {
   try {
     const record = await store.get(id);
     if (!record) {
-      console.error(chalk18.red('Schedule "' + id + '" not found.'));
+      console.error(chalk23.red('Schedule "' + id + '" not found.'));
       process.exit(1);
     }
     const agent = score.agents[record.agent_id];
     if (!agent) {
-      console.error(chalk18.red('Agent "' + record.agent_id + '" not found in score.'));
+      console.error(chalk23.red('Agent "' + record.agent_id + '" not found in score.'));
       process.exit(1);
     }
     const resolvedAgent = agent.model ? agent : { ...agent, model: score.default_model ?? "claude-sonnet-4-20250514" };
     const engine = new SchedulerEngine2(store, runner, events);
     await engine.schedule(id, resolvedAgent, record.config);
     engine.start();
-    console.log(chalk18.cyan('Triggering "' + id + '" (' + record.agent_id + ")..."));
+    console.log(chalk23.cyan('Triggering "' + id + '" (' + record.agent_id + ")..."));
     const run2 = await engine.trigger(id);
     engine.stop();
     if (run2.error) {
-      console.log(chalk18.red("  Error: " + run2.error));
+      console.log(chalk23.red("  Error: " + run2.error));
       process.exit(1);
     }
     const duration = run2.completed_at && run2.triggered_at ? run2.completed_at.getTime() - run2.triggered_at.getTime() : 0;
-    console.log(chalk18.green("  Completed in " + duration + "ms"));
+    console.log(chalk23.green("  Completed in " + duration + "ms"));
     if (run2.result) {
       const preview = run2.result.length > 200 ? run2.result.slice(0, 200) + "..." : run2.result;
-      console.log(chalk18.dim("  Output: " + preview));
+      console.log(chalk23.dim("  Output: " + preview));
     }
   } finally {
     await closeStore(store);
@@ -2885,31 +3419,31 @@ async function schedulesRunsCommand(id) {
   try {
     const record = await store.get(id);
     if (!record) {
-      console.error(chalk18.red('Schedule "' + id + '" not found.'));
+      console.error(chalk23.red('Schedule "' + id + '" not found.'));
       process.exit(1);
     }
     if ("getRuns" in store && typeof store.getRuns === "function") {
       const runs = store.getRuns(id);
       if (runs.length === 0) {
-        console.log(chalk18.dim("No runs recorded for this schedule."));
+        console.log(chalk23.dim("No runs recorded for this schedule."));
         return;
       }
       const recent = runs.slice(-20);
       console.log("");
-      console.log(chalk18.dim("  Showing last " + recent.length + " of " + runs.length + " runs:"));
+      console.log(chalk23.dim("  Showing last " + recent.length + " of " + runs.length + " runs:"));
       console.log("");
       for (const run2 of recent) {
         const duration = run2.completed_at && run2.triggered_at ? run2.completed_at.getTime() - run2.triggered_at.getTime() + "ms" : "?";
-        const status = run2.error ? chalk18.red("error") : chalk18.green("ok");
+        const status = run2.error ? chalk23.red("error") : chalk23.green("ok");
         const preview = run2.error ? run2.error.slice(0, 80) : (run2.result ?? "").slice(0, 80);
         console.log(
-          "  " + chalk18.dim(run2.triggered_at.toISOString()) + "  " + status + "  " + chalk18.dim(duration) + "  " + preview
+          "  " + chalk23.dim(run2.triggered_at.toISOString()) + "  " + status + "  " + chalk23.dim(duration) + "  " + preview
         );
       }
       console.log("");
     } else {
-      console.log(chalk18.dim('Schedule "' + id + '" has completed ' + record.run_count + " runs."));
-      console.log(chalk18.dim("Full run history requires the MemoryScheduleStore or a future tutti_schedule_runs table."));
+      console.log(chalk23.dim('Schedule "' + id + '" has completed ' + record.run_count + " runs."));
+      console.log(chalk23.dim("Full run history requires the MemoryScheduleStore or a future tutti_schedule_runs table."));
     }
   } finally {
     await closeStore(store);
@@ -2917,52 +3451,52 @@ async function schedulesRunsCommand(id) {
 }
 
 // src/commands/traces.ts
-import chalk20 from "chalk";
-import { SecretsManager as SecretsManager9 } from "@tuttiai/core";
+import chalk25 from "chalk";
+import { SecretsManager as SecretsManager10 } from "@tuttiai/core";
 
 // src/commands/traces-render.ts
-import chalk19 from "chalk";
-function visibleLen(s) {
+import chalk24 from "chalk";
+function visibleLen2(s) {
   return s.replace(/\u001b\[[0-9;]*m/g, "").length;
 }
-function pad4(s, len) {
-  const v = visibleLen(s);
+function pad5(s, len) {
+  const v = visibleLen2(s);
   return v >= len ? s : s + " ".repeat(len - v);
 }
 function colorStatus(status) {
-  if (status === "ok") return chalk19.green("ok");
-  if (status === "error") return chalk19.red("error");
-  return chalk19.yellow("running");
+  if (status === "ok") return chalk24.green("ok");
+  if (status === "error") return chalk24.red("error");
+  return chalk24.yellow("running");
 }
 function formatCost(cost) {
-  if (cost === null) return chalk19.dim("\u2014");
+  if (cost === null) return chalk24.dim("\u2014");
   if (cost === 0) return "$0";
   return "$" + cost.toFixed(6);
 }
 function formatTokens(n) {
-  return n > 0 ? String(n) : chalk19.dim("\u2014");
+  return n > 0 ? String(n) : chalk24.dim("\u2014");
 }
 function formatDuration(ms) {
-  if (ms === null) return chalk19.dim("\u2014");
+  if (ms === null) return chalk24.dim("\u2014");
   return ms + "ms";
 }
 function renderTracesList(traces) {
   if (traces.length === 0) {
-    return chalk19.dim("No traces found.");
+    return chalk24.dim("No traces found.");
   }
   const lines = [];
   lines.push("");
   lines.push(
-    chalk19.dim(
-      "  " + pad4("TRACE", 10) + pad4("AGENT", 18) + pad4("STARTED", 12) + pad4("DURATION", 12) + pad4("STATUS", 12) + pad4("TOKENS", 10) + "COST"
+    chalk24.dim(
+      "  " + pad5("TRACE", 10) + pad5("AGENT", 18) + pad5("STARTED", 12) + pad5("DURATION", 12) + pad5("STATUS", 12) + pad5("TOKENS", 10) + "COST"
     )
   );
-  lines.push(chalk19.dim("  " + "\u2500".repeat(80)));
+  lines.push(chalk24.dim("  " + "\u2500".repeat(80)));
   for (const t of traces) {
     const traceShort = t.trace_id.slice(0, 8);
     const startedShort = t.started_at.slice(11, 19);
     lines.push(
-      "  " + chalk19.bold(pad4(traceShort, 10)) + pad4(t.agent_id ?? chalk19.dim("\u2014"), 18) + pad4(startedShort, 12) + pad4(formatDuration(t.duration_ms), 12) + pad4(colorStatus(t.status), 12) + pad4(formatTokens(t.total_tokens), 10) + formatCost(t.cost_usd)
+      "  " + chalk24.bold(pad5(traceShort, 10)) + pad5(t.agent_id ?? chalk24.dim("\u2014"), 18) + pad5(startedShort, 12) + pad5(formatDuration(t.duration_ms), 12) + pad5(colorStatus(t.status), 12) + pad5(formatTokens(t.total_tokens), 10) + formatCost(t.cost_usd)
     );
   }
   lines.push("");
@@ -2978,11 +3512,11 @@ var SPAN_ICONS = {
 function renderSpanLine(span, indent) {
   const icon = SPAN_ICONS[span.kind];
   const indentStr = "  ".repeat(indent);
-  const dur = span.duration_ms !== void 0 ? chalk19.dim(" " + span.duration_ms + "ms ") : chalk19.dim(" (running) ");
+  const dur = span.duration_ms !== void 0 ? chalk24.dim(" " + span.duration_ms + "ms ") : chalk24.dim(" (running) ");
   const status = colorStatus(span.status);
   const attrs = formatAttrs(span);
-  const attrSuffix = attrs ? chalk19.dim(" \xB7 " + attrs) : "";
-  return indentStr + icon + " " + chalk19.bold(span.name) + dur + status + attrSuffix;
+  const attrSuffix = attrs ? chalk24.dim(" \xB7 " + attrs) : "";
+  return indentStr + icon + " " + chalk24.bold(span.name) + dur + status + attrSuffix;
 }
 function formatAttrs(span) {
   const a = span.attributes;
@@ -3003,13 +3537,13 @@ function formatAttrs(span) {
     if (a.session_id !== void 0) parts.push("session=" + a.session_id.slice(0, 8));
   }
   if (span.error?.message) {
-    parts.push(chalk19.red("error: " + span.error.message));
+    parts.push(chalk24.red("error: " + span.error.message));
   }
   return parts.join(" \xB7 ");
 }
 function renderTraceShow(spans) {
   if (spans.length === 0) {
-    return chalk19.dim("No spans found for this trace.");
+    return chalk24.dim("No spans found for this trace.");
   }
   const childrenByParent = /* @__PURE__ */ new Map();
   const presentSpanIds = new Set(spans.map((s) => s.span_id));
@@ -3048,9 +3582,9 @@ function renderTraceShow(spans) {
   }
   const wall_ms = roots.map((r) => r.duration_ms).find((d) => d !== void 0);
   lines.push("");
-  lines.push(chalk19.dim("\u2500".repeat(60)));
+  lines.push(chalk24.dim("\u2500".repeat(60)));
   lines.push(
-    chalk19.dim("Total: ") + chalk19.bold(formatTokens(total_tokens)) + chalk19.dim(" tokens \xB7 ") + chalk19.bold(any_cost ? formatCost(total_cost) : chalk19.dim("\u2014")) + chalk19.dim(" cost \xB7 ") + chalk19.bold(wall_ms !== void 0 ? wall_ms + "ms" : chalk19.dim("\u2014")) + chalk19.dim(" wall")
+    chalk24.dim("Total: ") + chalk24.bold(formatTokens(total_tokens)) + chalk24.dim(" tokens \xB7 ") + chalk24.bold(any_cost ? formatCost(total_cost) : chalk24.dim("\u2014")) + chalk24.dim(" cost \xB7 ") + chalk24.bold(wall_ms !== void 0 ? wall_ms + "ms" : chalk24.dim("\u2014")) + chalk24.dim(" wall")
   );
   lines.push("");
   return lines.join("\n");
@@ -3059,17 +3593,17 @@ function renderTraceShow(spans) {
 // src/commands/traces.ts
 var DEFAULT_SERVER_URL = "http://127.0.0.1:3847";
 function resolveUrl(opts) {
-  return opts.url ?? SecretsManager9.optional("TUTTI_SERVER_URL") ?? DEFAULT_SERVER_URL;
+  return opts.url ?? SecretsManager10.optional("TUTTI_SERVER_URL") ?? DEFAULT_SERVER_URL;
 }
 function resolveAuthHeader(opts) {
-  const key = opts.apiKey ?? SecretsManager9.optional("TUTTI_API_KEY");
+  const key = opts.apiKey ?? SecretsManager10.optional("TUTTI_API_KEY");
   return key ? { Authorization: "Bearer " + key } : {};
 }
 function explainConnectionError(err, baseUrl) {
   const msg = err instanceof Error ? err.message : String(err);
-  console.error(chalk20.red("Failed to reach Tutti server at " + baseUrl));
-  console.error(chalk20.dim("  " + msg));
-  console.error(chalk20.dim("  Is `tutti-ai serve` running? Set --url or TUTTI_SERVER_URL to override."));
+  console.error(chalk25.red("Failed to reach Tutti server at " + baseUrl));
+  console.error(chalk25.dim("  " + msg));
+  console.error(chalk25.dim("  Is `tutti-ai serve` running? Set --url or TUTTI_SERVER_URL to override."));
   process.exit(1);
 }
 async function tracesListCommand(opts) {
@@ -3082,11 +3616,11 @@ async function tracesListCommand(opts) {
     explainConnectionError(err, baseUrl);
   }
   if (res.status === 401) {
-    console.error(chalk20.red("Unauthorized \u2014 set --api-key or TUTTI_API_KEY."));
+    console.error(chalk25.red("Unauthorized \u2014 set --api-key or TUTTI_API_KEY."));
     process.exit(1);
   }
   if (!res.ok) {
-    console.error(chalk20.red("Server returned " + res.status + " " + res.statusText));
+    console.error(chalk25.red("Server returned " + res.status + " " + res.statusText));
     process.exit(1);
   }
   const body = await res.json();
@@ -3102,15 +3636,15 @@ async function tracesShowCommand(traceId, opts) {
     explainConnectionError(err, baseUrl);
   }
   if (res.status === 404) {
-    console.error(chalk20.red('Trace "' + traceId + '" not found.'));
+    console.error(chalk25.red('Trace "' + traceId + '" not found.'));
     process.exit(1);
   }
   if (res.status === 401) {
-    console.error(chalk20.red("Unauthorized \u2014 set --api-key or TUTTI_API_KEY."));
+    console.error(chalk25.red("Unauthorized \u2014 set --api-key or TUTTI_API_KEY."));
     process.exit(1);
   }
   if (!res.ok) {
-    console.error(chalk20.red("Server returned " + res.status + " " + res.statusText));
+    console.error(chalk25.red("Server returned " + res.status + " " + res.statusText));
     process.exit(1);
   }
   const body = await res.json();
@@ -3120,13 +3654,13 @@ async function tracesShowCommand(traceId, opts) {
 async function tracesTailCommand(opts) {
   const baseUrl = resolveUrl(opts);
   const url = baseUrl.replace(/\/$/, "") + "/traces/stream";
-  console.error(chalk20.dim("Tailing traces from " + baseUrl + " \u2014 Ctrl+C to exit"));
+  console.error(chalk25.dim("Tailing traces from " + baseUrl + " \u2014 Ctrl+C to exit"));
   console.error("");
   const controller = new AbortController();
   process.once("SIGINT", () => {
     controller.abort();
     console.error("");
-    console.error(chalk20.dim("Disconnected."));
+    console.error(chalk25.dim("Disconnected."));
     process.exit(0);
   });
   let res;
@@ -3140,11 +3674,11 @@ async function tracesTailCommand(opts) {
     explainConnectionError(err, baseUrl);
   }
   if (res.status === 401) {
-    console.error(chalk20.red("Unauthorized \u2014 set --api-key or TUTTI_API_KEY."));
+    console.error(chalk25.red("Unauthorized \u2014 set --api-key or TUTTI_API_KEY."));
     process.exit(1);
   }
   if (!res.ok || !res.body) {
-    console.error(chalk20.red("Server returned " + res.status + " " + res.statusText));
+    console.error(chalk25.red("Server returned " + res.status + " " + res.statusText));
     process.exit(1);
   }
   const reader = res.body.getReader();
@@ -3169,7 +3703,7 @@ async function tracesTailCommand(opts) {
         const span = reviveSpanDates(JSON.parse(dataLine.slice(6)));
         console.log(renderSpanLine(span, 0));
       } catch (err) {
-        console.error(chalk20.red("Bad SSE frame: " + (err instanceof Error ? err.message : String(err))));
+        console.error(chalk25.red("Bad SSE frame: " + (err instanceof Error ? err.message : String(err))));
       }
     }
   }
@@ -3184,25 +3718,25 @@ function reviveSpanDates(span) {
 
 // src/commands/memory.ts
 import { writeFileSync as writeFileSync2 } from "fs";
-import chalk22 from "chalk";
-import Enquirer3 from "enquirer";
+import chalk27 from "chalk";
+import Enquirer4 from "enquirer";
 import {
   MemoryUserMemoryStore,
   PostgresUserMemoryStore,
-  SecretsManager as SecretsManager10,
-  createLogger as createLogger15
+  SecretsManager as SecretsManager11,
+  createLogger as createLogger17
 } from "@tuttiai/core";
 
 // src/commands/memory-render.ts
-import chalk21 from "chalk";
-function visibleLen2(s) {
+import chalk26 from "chalk";
+function visibleLen3(s) {
   return s.replace(/\u001b\[[0-9;]*m/g, "").length;
 }
-function pad5(s, len) {
-  const v = visibleLen2(s);
+function pad6(s, len) {
+  const v = visibleLen3(s);
   return v >= len ? s : s + " ".repeat(len - v);
 }
-function truncate(text, max) {
+function truncate2(text, max) {
   const oneLine = text.replace(/\s+/g, " ").trim();
   return oneLine.length > max ? oneLine.slice(0, max - 1) + "\u2026" : oneLine;
 }
@@ -3222,23 +3756,23 @@ function sortMemoriesForList(memories) {
   });
 }
 function renderTable(memories, emptyMessage) {
-  if (memories.length === 0) return chalk21.dim(emptyMessage);
+  if (memories.length === 0) return chalk26.dim(emptyMessage);
   const lines = [];
   lines.push("");
   lines.push(
-    chalk21.dim(
-      "  " + pad5("ID", 10) + pad5("CONTENT", 62) + pad5("SOURCE", 12) + pad5("IMPORTANCE", 14) + "CREATED"
+    chalk26.dim(
+      "  " + pad6("ID", 10) + pad6("CONTENT", 62) + pad6("SOURCE", 12) + pad6("IMPORTANCE", 14) + "CREATED"
     )
   );
-  lines.push(chalk21.dim("  " + "\u2500".repeat(110)));
+  lines.push(chalk26.dim("  " + "\u2500".repeat(110)));
   for (const m of memories) {
     const idShort = m.id.slice(0, 8);
-    const content = truncate(m.content, 60);
-    const sourceColored = m.source === "explicit" ? chalk21.green("explicit") : chalk21.yellow("inferred");
+    const content = truncate2(m.content, 60);
+    const sourceColored = m.source === "explicit" ? chalk26.green("explicit") : chalk26.yellow("inferred");
     const importance = importanceStars(m.importance);
     const created = formatDate(m.created_at);
     lines.push(
-      "  " + chalk21.bold(pad5(idShort, 10)) + pad5(content, 62) + pad5(sourceColored, 12) + pad5(importance, 14) + chalk21.dim(created)
+      "  " + chalk26.bold(pad6(idShort, 10)) + pad6(content, 62) + pad6(sourceColored, 12) + pad6(importance, 14) + chalk26.dim(created)
     );
   }
   lines.push("");
@@ -3251,8 +3785,8 @@ function renderMemoryList(memories, userId) {
   );
 }
 function renderMemorySearch(memories, userId, query) {
-  const header = chalk21.dim(
-    "Search for " + chalk21.bold('"' + query + '"') + ' in user "' + userId + '" \u2014 ' + memories.length + " result" + (memories.length === 1 ? "" : "s")
+  const header = chalk26.dim(
+    "Search for " + chalk26.bold('"' + query + '"') + ' in user "' + userId + '" \u2014 ' + memories.length + " result" + (memories.length === 1 ? "" : "s")
   );
   const body = renderTable(
     memories,
@@ -3261,13 +3795,13 @@ function renderMemorySearch(memories, userId, query) {
   return header + body;
 }
 function renderMemoryAdded(memory) {
-  return chalk21.green("\u2713") + " Stored memory " + chalk21.bold(memory.id.slice(0, 8)) + chalk21.dim(" (" + memory.source + ", " + importanceStars(memory.importance) + ")");
+  return chalk26.green("\u2713") + " Stored memory " + chalk26.bold(memory.id.slice(0, 8)) + chalk26.dim(" (" + memory.source + ", " + importanceStars(memory.importance) + ")");
 }
 function renderMemoryDeleted(memoryId) {
-  return chalk21.green("\u2713") + " Deleted memory " + chalk21.bold(memoryId.slice(0, 8));
+  return chalk26.green("\u2713") + " Deleted memory " + chalk26.bold(memoryId.slice(0, 8));
 }
 function renderMemoryCleared(userId, count) {
-  return chalk21.green("\u2713") + " Deleted " + chalk21.bold(String(count)) + " memor" + (count === 1 ? "y" : "ies") + ' for user "' + userId + '"';
+  return chalk26.green("\u2713") + " Deleted " + chalk26.bold(String(count)) + " memor" + (count === 1 ? "y" : "ies") + ' for user "' + userId + '"';
 }
 function exportMemoriesJson(memories) {
   return JSON.stringify(memories, null, 2) + "\n";
@@ -3310,14 +3844,14 @@ function csvEscape(field) {
 }
 
 // src/commands/memory.ts
-var logger15 = createLogger15("tutti-cli");
-var { prompt: prompt3 } = Enquirer3;
+var logger17 = createLogger17("tutti-cli");
+var { prompt: prompt4 } = Enquirer4;
 function resolveStore3() {
-  const pgUrl = SecretsManager10.optional("TUTTI_PG_URL");
+  const pgUrl = SecretsManager11.optional("TUTTI_PG_URL");
   if (pgUrl) {
     return new PostgresUserMemoryStore({ connection_string: pgUrl });
   }
-  logger15.warn(
+  logger17.warn(
     "TUTTI_PG_URL not set \u2014 using in-memory store (memories are ephemeral; this command will appear to do nothing useful)"
   );
   return new MemoryUserMemoryStore();
@@ -3329,7 +3863,7 @@ async function closeStore2(store) {
 }
 function requireUser(opts) {
   if (!opts.user || opts.user.trim() === "") {
-    console.error(chalk22.red("--user <user-id> is required"));
+    console.error(chalk27.red("--user <user-id> is required"));
     process.exit(1);
   }
   return opts.user.trim();
@@ -3339,7 +3873,7 @@ function parseImportance(raw) {
   if (raw === "1") return 1;
   if (raw === "2") return 2;
   if (raw === "3") return 3;
-  console.error(chalk22.red("--importance must be 1, 2, or 3"));
+  console.error(chalk27.red("--importance must be 1, 2, or 3"));
   process.exit(1);
 }
 async function memoryListCommand(opts) {
@@ -3355,7 +3889,7 @@ async function memoryListCommand(opts) {
 async function memorySearchCommand(query, opts) {
   const userId = requireUser(opts);
   if (query.trim() === "") {
-    console.error(chalk22.red("Search query is required"));
+    console.error(chalk27.red("Search query is required"));
     process.exit(1);
   }
   const store = resolveStore3();
@@ -3369,7 +3903,7 @@ async function memorySearchCommand(query, opts) {
 async function memoryAddCommand(content, opts) {
   const userId = requireUser(opts);
   if (content.trim() === "") {
-    console.error(chalk22.red("Memory content is required"));
+    console.error(chalk27.red("Memory content is required"));
     process.exit(1);
   }
   const importance = parseImportance(opts.importance);
@@ -3400,17 +3934,17 @@ async function memoryClearCommand(opts) {
   try {
     const memories = await store.list(userId);
     if (memories.length === 0) {
-      console.log(chalk22.dim('No memories stored for user "' + userId + '".'));
+      console.log(chalk27.dim('No memories stored for user "' + userId + '".'));
       return;
     }
-    const { confirm } = await prompt3({
+    const { confirm } = await prompt4({
       type: "confirm",
       name: "confirm",
       message: "Delete all " + memories.length + ' memories for user "' + userId + '"?',
       initial: false
     });
     if (!confirm) {
-      console.log(chalk22.dim("  Cancelled."));
+      console.log(chalk27.dim("  Cancelled."));
       return;
     }
     await store.deleteAll(userId);
@@ -3423,7 +3957,7 @@ async function memoryExportCommand(opts) {
   const userId = requireUser(opts);
   const format = (opts.format ?? "json").toLowerCase();
   if (format !== "json" && format !== "csv") {
-    console.error(chalk22.red("--format must be 'json' or 'csv'"));
+    console.error(chalk27.red("--format must be 'json' or 'csv'"));
     process.exit(1);
   }
   const store = resolveStore3();
@@ -3433,7 +3967,7 @@ async function memoryExportCommand(opts) {
     if (opts.out) {
       writeFileSync2(opts.out, body, "utf8");
       console.log(
-        chalk22.green("\u2713") + " Wrote " + chalk22.bold(String(memories.length)) + " memor" + (memories.length === 1 ? "y" : "ies") + " to " + chalk22.bold(opts.out)
+        chalk27.green("\u2713") + " Wrote " + chalk27.bold(String(memories.length)) + " memor" + (memories.length === 1 ? "y" : "ies") + " to " + chalk27.bold(opts.out)
       );
     } else {
       process.stdout.write(body);
@@ -3444,24 +3978,24 @@ async function memoryExportCommand(opts) {
 }
 
 // src/commands/interrupts.ts
-import chalk24 from "chalk";
-import Enquirer4 from "enquirer";
-import { SecretsManager as SecretsManager11 } from "@tuttiai/core";
+import chalk29 from "chalk";
+import Enquirer5 from "enquirer";
+import { SecretsManager as SecretsManager12 } from "@tuttiai/core";
 
 // src/commands/interrupts-render.ts
-import chalk23 from "chalk";
-function visibleLen3(s) {
+import chalk28 from "chalk";
+function visibleLen4(s) {
   return s.replace(/\u001b\[[0-9;]*m/g, "").length;
 }
-function pad6(s, len) {
-  const v = visibleLen3(s);
+function pad7(s, len) {
+  const v = visibleLen4(s);
   return v >= len ? s : s + " ".repeat(len - v);
 }
-function truncate2(text, max) {
+function truncate3(text, max) {
   const oneLine = text.replace(/\s+/g, " ").trim();
   return oneLine.length > max ? oneLine.slice(0, max - 1) + "\u2026" : oneLine;
 }
-function formatIsoShort(d) {
+function formatIsoShort2(d) {
   const iso = d.toISOString();
   return iso.slice(0, 10) + " " + iso.slice(11, 19);
 }
@@ -3485,28 +4019,28 @@ function truncateArgs(tool_args, max = 80) {
     json = String(tool_args);
   }
   if (json === void 0) return "";
-  return truncate2(json, max);
+  return truncate3(json, max);
 }
 function renderInterruptsList(interrupts, now = /* @__PURE__ */ new Date()) {
   if (interrupts.length === 0) {
-    return chalk23.dim("No pending interrupts.");
+    return chalk28.dim("No pending interrupts.");
   }
   const lines = [];
   lines.push("");
   lines.push(
-    chalk23.dim(
-      "  " + pad6("ID", 10) + pad6("SESSION", 14) + pad6("TOOL", 22) + pad6("ARGS", 52) + "AGE"
+    chalk28.dim(
+      "  " + pad7("ID", 10) + pad7("SESSION", 14) + pad7("TOOL", 22) + pad7("ARGS", 52) + "AGE"
     )
   );
-  lines.push(chalk23.dim("  " + "\u2500".repeat(110)));
+  lines.push(chalk28.dim("  " + "\u2500".repeat(110)));
   for (const r of interrupts) {
     const idShort = r.interrupt_id.slice(0, 8);
     const sessionShort = r.session_id.slice(0, 12);
-    const toolName = truncate2(r.tool_name, 20);
+    const toolName = truncate3(r.tool_name, 20);
     const argsPreview = truncateArgs(r.tool_args, 50);
     const age = formatRelativeTime(r.requested_at, now);
     lines.push(
-      "  " + chalk23.bold(pad6(idShort, 10)) + pad6(sessionShort, 14) + pad6(chalk23.cyan(toolName), 22) + pad6(chalk23.dim(argsPreview), 52) + chalk23.dim(age)
+      "  " + chalk28.bold(pad7(idShort, 10)) + pad7(sessionShort, 14) + pad7(chalk28.cyan(toolName), 22) + pad7(chalk28.dim(argsPreview), 52) + chalk28.dim(age)
     );
   }
   lines.push("");
@@ -3515,25 +4049,25 @@ function renderInterruptsList(interrupts, now = /* @__PURE__ */ new Date()) {
 function renderInterruptDetail(interrupt, now = /* @__PURE__ */ new Date()) {
   const lines = [];
   lines.push("");
-  lines.push(chalk23.bold("Interrupt ") + chalk23.dim(interrupt.interrupt_id));
-  lines.push(chalk23.dim("\u2500".repeat(60)));
-  lines.push(chalk23.dim("Session:     ") + interrupt.session_id);
-  lines.push(chalk23.dim("Tool:        ") + chalk23.cyan(interrupt.tool_name));
+  lines.push(chalk28.bold("Interrupt ") + chalk28.dim(interrupt.interrupt_id));
+  lines.push(chalk28.dim("\u2500".repeat(60)));
+  lines.push(chalk28.dim("Session:     ") + interrupt.session_id);
+  lines.push(chalk28.dim("Tool:        ") + chalk28.cyan(interrupt.tool_name));
   lines.push(
-    chalk23.dim("Requested:   ") + formatIsoShort(interrupt.requested_at) + chalk23.dim(" (" + formatRelativeTime(interrupt.requested_at, now) + ")")
+    chalk28.dim("Requested:   ") + formatIsoShort2(interrupt.requested_at) + chalk28.dim(" (" + formatRelativeTime(interrupt.requested_at, now) + ")")
   );
-  lines.push(chalk23.dim("Status:      ") + colorStatus2(interrupt.status));
+  lines.push(chalk28.dim("Status:      ") + colorStatus2(interrupt.status));
   if (interrupt.resolved_at) {
-    lines.push(chalk23.dim("Resolved:    ") + formatIsoShort(interrupt.resolved_at));
+    lines.push(chalk28.dim("Resolved:    ") + formatIsoShort2(interrupt.resolved_at));
   }
   if (interrupt.resolved_by) {
-    lines.push(chalk23.dim("Resolved by: ") + interrupt.resolved_by);
+    lines.push(chalk28.dim("Resolved by: ") + interrupt.resolved_by);
   }
   if (interrupt.denial_reason) {
-    lines.push(chalk23.dim("Reason:      ") + interrupt.denial_reason);
+    lines.push(chalk28.dim("Reason:      ") + interrupt.denial_reason);
   }
   lines.push("");
-  lines.push(chalk23.dim("Arguments:"));
+  lines.push(chalk28.dim("Arguments:"));
   lines.push(prettyJson(interrupt.tool_args));
   lines.push("");
   return lines.join("\n");
@@ -3546,34 +4080,34 @@ function prettyJson(value) {
   }
 }
 function colorStatus2(status) {
-  if (status === "approved") return chalk23.green("approved");
-  if (status === "denied") return chalk23.red("denied");
-  return chalk23.yellow("pending");
+  if (status === "approved") return chalk28.green("approved");
+  if (status === "denied") return chalk28.red("denied");
+  return chalk28.yellow("pending");
 }
 function renderApproved(interrupt) {
-  return chalk23.green("\u2713") + " Approved " + chalk23.bold(interrupt.interrupt_id.slice(0, 8)) + chalk23.dim(" (" + interrupt.tool_name + ")") + (interrupt.resolved_by ? chalk23.dim(" by " + interrupt.resolved_by) : "");
+  return chalk28.green("\u2713") + " Approved " + chalk28.bold(interrupt.interrupt_id.slice(0, 8)) + chalk28.dim(" (" + interrupt.tool_name + ")") + (interrupt.resolved_by ? chalk28.dim(" by " + interrupt.resolved_by) : "");
 }
 function renderDenied(interrupt) {
-  return chalk23.red("\u2717") + " Denied " + chalk23.bold(interrupt.interrupt_id.slice(0, 8)) + chalk23.dim(" (" + interrupt.tool_name + ")") + (interrupt.denial_reason ? chalk23.dim(' \u2014 "' + interrupt.denial_reason + '"') : "");
+  return chalk28.red("\u2717") + " Denied " + chalk28.bold(interrupt.interrupt_id.slice(0, 8)) + chalk28.dim(" (" + interrupt.tool_name + ")") + (interrupt.denial_reason ? chalk28.dim(' \u2014 "' + interrupt.denial_reason + '"') : "");
 }
 
 // src/commands/interrupts.ts
-var { prompt: prompt4 } = Enquirer4;
+var { prompt: prompt5 } = Enquirer5;
 var DEFAULT_SERVER_URL2 = "http://127.0.0.1:3847";
 var POLL_INTERVAL_MS = 2e3;
 function resolveUrl2(opts) {
-  return opts.url ?? SecretsManager11.optional("TUTTI_SERVER_URL") ?? DEFAULT_SERVER_URL2;
+  return opts.url ?? SecretsManager12.optional("TUTTI_SERVER_URL") ?? DEFAULT_SERVER_URL2;
 }
 function resolveAuthHeader2(opts) {
-  const key = opts.apiKey ?? SecretsManager11.optional("TUTTI_API_KEY");
+  const key = opts.apiKey ?? SecretsManager12.optional("TUTTI_API_KEY");
   return key ? { Authorization: "Bearer " + key } : {};
 }
 function explainConnectionError2(err, baseUrl) {
   const msg = err instanceof Error ? err.message : String(err);
-  console.error(chalk24.red("Failed to reach Tutti server at " + baseUrl));
-  console.error(chalk24.dim("  " + msg));
+  console.error(chalk29.red("Failed to reach Tutti server at " + baseUrl));
+  console.error(chalk29.dim("  " + msg));
   console.error(
-    chalk24.dim("  Is `tutti-ai serve` running? Set --url or TUTTI_SERVER_URL to override.")
+    chalk29.dim("  Is `tutti-ai serve` running? Set --url or TUTTI_SERVER_URL to override.")
   );
   process.exit(1);
 }
@@ -3624,19 +4158,19 @@ async function fetchPending(opts) {
     "/interrupts/pending"
   );
   if (status === 401) {
-    console.error(chalk24.red("Unauthorized \u2014 set --api-key or TUTTI_API_KEY."));
+    console.error(chalk29.red("Unauthorized \u2014 set --api-key or TUTTI_API_KEY."));
     process.exit(1);
   }
   if (status === 503) {
     console.error(
-      chalk24.red(
+      chalk29.red(
         "The server has no InterruptStore configured. Start `tutti-ai serve` with an interrupt store attached."
       )
     );
     process.exit(1);
   }
   if (status < 200 || status >= 300 || !("interrupts" in body)) {
-    console.error(chalk24.red("Unexpected server response: " + status));
+    console.error(chalk29.red("Unexpected server response: " + status));
     process.exit(1);
   }
   return body.interrupts.map(reviveInterrupt);
@@ -3649,23 +4183,23 @@ async function postResolve(opts, interruptId, action, payload) {
     payload
   );
   if (status === 401) {
-    console.error(chalk24.red("Unauthorized \u2014 set --api-key or TUTTI_API_KEY."));
+    console.error(chalk29.red("Unauthorized \u2014 set --api-key or TUTTI_API_KEY."));
     process.exit(1);
   }
   if (status === 404) {
-    console.error(chalk24.red('Interrupt "' + interruptId + '" not found.'));
+    console.error(chalk29.red('Interrupt "' + interruptId + '" not found.'));
     process.exit(1);
   }
   if (status === 409) {
     const current = body.current;
     const currentStatus = current && typeof current["status"] === "string" ? current["status"] : "resolved";
     console.error(
-      chalk24.red("Interrupt already " + currentStatus + " \u2014 refusing to override.")
+      chalk29.red("Interrupt already " + currentStatus + " \u2014 refusing to override.")
     );
     process.exit(1);
   }
   if (status < 200 || status >= 300) {
-    console.error(chalk24.red("Unexpected server response: " + status));
+    console.error(chalk29.red("Unexpected server response: " + status));
     process.exit(1);
   }
   return reviveInterrupt(body);
@@ -3693,7 +4227,7 @@ function clearScreen() {
 function readKey() {
   const input = process.stdin;
   if (!input.isTTY) return Promise.resolve(null);
-  return new Promise((resolve18) => {
+  return new Promise((resolve20) => {
     input.setRawMode(true);
     input.resume();
     input.setEncoding("utf8");
@@ -3701,15 +4235,15 @@ function readKey() {
       input.removeListener("data", onData);
       input.setRawMode(false);
       input.pause();
-      resolve18(data);
+      resolve20(data);
     };
     input.on("data", onData);
   });
 }
 async function readKeyOrTimeout(ms) {
   let timer;
-  const timeout = new Promise((resolve18) => {
-    timer = setTimeout(() => resolve18(null), ms);
+  const timeout = new Promise((resolve20) => {
+    timer = setTimeout(() => resolve20(null), ms);
   });
   try {
     const winner = await Promise.race([readKey(), timeout]);
@@ -3734,17 +4268,17 @@ async function interruptsTUICommand(opts) {
       const pending = await fetchPending(opts);
       clearScreen();
       console.log(
-        chalk24.bold("Tutti \u2014 pending interrupts") + chalk24.dim("   (auto-refresh every " + POLL_INTERVAL_MS / 1e3 + "s)")
+        chalk29.bold("Tutti \u2014 pending interrupts") + chalk29.dim("   (auto-refresh every " + POLL_INTERVAL_MS / 1e3 + "s)")
       );
       console.log(renderInterruptsList(pending));
       if (pending.length > 0) {
         console.log(
-          chalk24.dim(
+          chalk29.dim(
             "Press a number to inspect, 'r' to refresh, 'q' to quit."
           )
         );
       } else {
-        console.log(chalk24.dim("Press 'r' to refresh, 'q' to quit."));
+        console.log(chalk29.dim("Press 'r' to refresh, 'q' to quit."));
       }
       const indexed = pending.slice(0, 9);
       const key = await readKeyOrTimeout(POLL_INTERVAL_MS);
@@ -3767,7 +4301,7 @@ async function runDetailView(opts, interrupt) {
   clearScreen();
   console.log(renderInterruptDetail(interrupt));
   console.log(
-    chalk24.dim(
+    chalk29.dim(
       "Press 'a' to approve, 'd' to deny, 'q' to go back to the list."
     )
   );
@@ -3781,7 +4315,7 @@ async function runDetailView(opts, interrupt) {
     return true;
   }
   if (key === "d") {
-    const { reason } = await prompt4({
+    const { reason } = await prompt5({
       type: "input",
       name: "reason",
       message: "Reason (optional):"
@@ -3802,19 +4336,19 @@ async function runDetailView(opts, interrupt) {
   return true;
 }
 async function pause() {
-  console.log(chalk24.dim("\nPress any key to continue..."));
+  console.log(chalk29.dim("\nPress any key to continue..."));
   await readKey();
 }
 
 // src/index.ts
 config();
-var logger16 = createLogger16("tutti-cli");
+var logger18 = createLogger18("tutti-cli");
 process.on("unhandledRejection", (reason) => {
-  logger16.error({ error: reason instanceof Error ? reason.message : String(reason) }, "Unhandled rejection");
+  logger18.error({ error: reason instanceof Error ? reason.message : String(reason) }, "Unhandled rejection");
   process.exit(1);
 });
 process.on("uncaughtException", (err) => {
-  logger16.error({ error: err.message }, "Fatal error");
+  logger18.error({ error: err.message }, "Fatal error");
   process.exit(1);
 });
 var program = new Command();
@@ -3871,9 +4405,30 @@ program.command("voices").description("List all available official voices and in
 program.command("publish").description("Publish the current voice to npm and the voice registry").option("--dry-run", "Run all checks without publishing").action(async (opts) => {
   await publishCommand(opts);
 });
-program.command("eval <suite-file>").description("Run an evaluation suite against a score").option("--ci", "Exit with code 1 if any case fails").option("-s, --score <path>", "Path to score file (default: ./tutti.score.ts)").action(async (suitePath, opts) => {
+var evalCmd = program.command("eval [suite-file]").description("Run an evaluation suite against a score").option("--ci", "Exit with code 1 if any case fails").option("-s, --score <path>", "Path to score file (default: ./tutti.score.ts)").action(async (suitePath, opts) => {
+  if (!suitePath) {
+    console.error(
+      "Usage: tutti-ai eval <suite-file>\n       tutti-ai eval record <session-id>\n       tutti-ai eval list"
+    );
+    process.exit(1);
+  }
   await evalCommand(suitePath, opts);
 });
+evalCmd.command("record <session-id>").description("Promote a past session run to a golden eval case").action(async (sessionId) => {
+  await evalRecordCommand(sessionId);
+});
+evalCmd.command("list").description("Show every golden case + latest-run status").action(async () => {
+  await evalListCommand();
+});
+evalCmd.command("run").description("Run every golden case (optionally filtered) and report pass/fail").option("--case <id>", "Run only the case with this id (full or 8-char prefix)").option("--tag <tag>", "Run only cases carrying this tag").option("--ci", "Write JUnit XML + exit 1 on failure + drop colors").option("-s, --score <path>", "Path to score file (default: ./tutti.score.ts)").action(async (opts) => {
+  const resolved = {
+    ...opts.case !== void 0 ? { case: opts.case } : {},
+    ...opts.tag !== void 0 ? { tag: opts.tag } : {},
+    ...opts.ci !== void 0 ? { ci: opts.ci } : {},
+    ...opts.score !== void 0 ? { score: opts.score } : {}
+  };
+  await evalRunCommand(resolved);
+});
 program.command("update").description("Update @tuttiai packages to their latest versions").action(() => {
   updateCommand();
 });