@tuttiai/cli 0.12.0 → 0.14.0

package/dist/index.js

@@ -2,7 +2,7 @@
 
 // src/index.ts
 import { config } from "dotenv";
-import { createLogger as createLogger13 } from "@tuttiai/core";
+import { createLogger as createLogger15 } from "@tuttiai/core";
 import { Command } from "commander";
 
 // src/commands/init.ts
@@ -718,7 +718,8 @@ async function resumeCommand(sessionId, opts) {
     }
   }
   const agentName = resolveAgentName(score, opts.agent);
-  const agent = score.agents[agentName];
+  const agentMap = new Map(Object.entries(score.agents));
+  const agent = agentMap.get(agentName);
   if (!agent) {
     logger3.error(
       { agent: agentName, available: Object.keys(score.agents) },
@@ -938,14 +939,14 @@ import chalk4 from "chalk";
 import ora3 from "ora";
 import { createLogger as createLogger4 } from "@tuttiai/core";
 var logger4 = createLogger4("tutti-cli");
-var OFFICIAL_VOICES = {
-  filesystem: {
+var OFFICIAL_VOICES = /* @__PURE__ */ new Map([
+  ["filesystem", {
     package: "@tuttiai/filesystem",
     setup: `  Add to your score:
     ${chalk4.cyan('import { FilesystemVoice } from "@tuttiai/filesystem"')}
     ${chalk4.cyan("voices: [new FilesystemVoice()]")}`
-  },
-  github: {
+  }],
+  ["github", {
     package: "@tuttiai/github",
     setup: `  Add ${chalk4.bold("GITHUB_TOKEN")} to your .env file:
     ${chalk4.cyan("GITHUB_TOKEN=ghp_your_token_here")}
@@ -953,8 +954,8 @@ var OFFICIAL_VOICES = {
   Add to your score:
     ${chalk4.cyan('import { GitHubVoice } from "@tuttiai/github"')}
     ${chalk4.cyan("voices: [new GitHubVoice()]")}`
-  },
-  playwright: {
+  }],
+  ["playwright", {
     package: "@tuttiai/playwright",
     setup: `  Install the browser:
     ${chalk4.cyan("npx playwright install chromium")}
@@ -962,8 +963,8 @@ var OFFICIAL_VOICES = {
   Add to your score:
     ${chalk4.cyan('import { PlaywrightVoice } from "@tuttiai/playwright"')}
     ${chalk4.cyan("voices: [new PlaywrightVoice()]")}`
-  },
-  postgres: {
+  }],
+  ["postgres", {
     package: "pg",
     setup: `  Add ${chalk4.bold("DATABASE_URL")} to your .env file:
     ${chalk4.cyan("DATABASE_URL=postgres://user:pass@localhost:5432/tutti")}
@@ -976,11 +977,12 @@ var OFFICIAL_VOICES = {
 
   Use the async factory for initialization:
     ${chalk4.cyan("const tutti = await TuttiRuntime.create(score)")}`
-  }
-};
+  }]
+]);
 function resolvePackageName(input) {
-  if (OFFICIAL_VOICES[input]) {
-    return OFFICIAL_VOICES[input].package;
+  const voice = OFFICIAL_VOICES.get(input);
+  if (voice) {
+    return voice.package;
   }
   if (input.startsWith("@")) {
     return input;
@@ -1023,7 +1025,7 @@ function addCommand(voiceName) {
     logger4.error({ error: message, package: packageName }, "Installation failed");
     process.exit(1);
   }
-  const official = OFFICIAL_VOICES[voiceName];
+  const official = OFFICIAL_VOICES.get(voiceName);
   if (official) {
     console.log();
     console.log("  Setup:");
@@ -1051,8 +1053,12 @@ import {
   createLogger as createLogger5
 } from "@tuttiai/core";
 var logger5 = createLogger5("tutti-cli");
-var ok = (msg) => console.log(chalk5.green("  \u2714 " + msg));
-var fail = (msg) => console.log(chalk5.red("  \u2718 " + msg));
+var ok = (msg) => {
+  console.log(chalk5.green("  \u2714 " + msg));
+};
+var fail = (msg) => {
+  console.log(chalk5.red("  \u2718 " + msg));
+};
 async function checkCommand(scorePath) {
   const file = resolve5(scorePath ?? "./tutti.score.ts");
   console.log(chalk5.cyan(`
@@ -1101,10 +1107,10 @@ Checking ${file}...
   for (const [agentKey, agent] of Object.entries(score.agents)) {
     for (const voice of agent.voices) {
       const voiceName = voice.name;
-      const voiceEnvMap = {
-        github: "GITHUB_TOKEN"
-      };
-      const envVar = voiceEnvMap[voiceName];
+      const voiceEnvMap = /* @__PURE__ */ new Map([
+        ["github", "GITHUB_TOKEN"]
+      ]);
+      const envVar = voiceEnvMap.get(voiceName);
       if (envVar) {
         const key = SecretsManager3.optional(envVar);
         if (key) {
@@ -1360,8 +1366,8 @@ async function fetchRegistry() {
   }
 }
 function toolCount(name) {
-  const counts = { filesystem: 7, github: 10, playwright: 12 };
-  return counts[name] ?? 0;
+  const counts = /* @__PURE__ */ new Map([["filesystem", 7], ["github", 10], ["playwright", 12]]);
+  return counts.get(name) ?? 0;
 }
 function matchesQuery(voice, query) {
   const q = query.toLowerCase();
@@ -1464,7 +1470,9 @@ function fail2(msg) {
   console.error(chalk8.red("  " + msg));
   process.exit(1);
 }
-var ok2 = (msg) => console.log(chalk8.green("  \u2714 " + msg));
+var ok2 = (msg) => {
+  console.log(chalk8.green("  \u2714 " + msg));
+};
 async function publishCommand(opts) {
   const cwd = process.cwd();
   const pkg = readPkg(cwd);
@@ -1481,8 +1489,8 @@ async function publishCommand(opts) {
   if (!pkg.license) missing.push("license");
   if (!pkg.exports) missing.push("exports");
   if (missing.length > 0) fail2("package.json is missing: " + missing.join(", "));
-  const name = pkg.name;
-  const version = pkg.version;
+  const name = pkg.name ?? "";
+  const version = pkg.version ?? "";
   const validName = name.startsWith("@tuttiai/") || name.startsWith("tutti");
   if (!validName) fail2("Package name must start with @tuttiai/ or tutti \u2014 got: " + name);
   const src = readFileSync3(resolve8(cwd, "src/index.ts"), "utf-8");
@@ -1527,7 +1535,7 @@ async function publishCommand(opts) {
     console.error(chalk8.dim("  " + msg));
     process.exit(1);
   }
-  const fileLines = packOutput.split("\n").filter((l) => l.includes("npm notice") && /\d+(\.\d+)?\s*[kM]?B\s/.test(l)).map((l) => l.replace(/npm notice\s*/, ""));
+  const fileLines = packOutput.split("\n").filter((l) => l.includes("npm notice") && /\d+(?:\.\d+)?\s*[kM]?B\s/.test(l)).map((l) => l.replace(/npm notice\s*/, ""));
   if (fileLines.length > 0) {
     console.log(chalk8.dim("  Files:"));
     for (const line of fileLines) {
@@ -1613,13 +1621,19 @@ async function openRegistryPR(packageName, version, description, token) {
     author: isOfficial ? "tuttiai" : packageName.split("/")[0]?.replace("@", "") ?? "community",
     tags: [shortName]
   };
-  if (!registry[section]) registry[section] = [];
-  const exists = registry[section].some((v) => v.package === packageName);
-  if (exists) {
-    const idx = registry[section].findIndex((v) => v.package === packageName);
-    registry[section][idx] = { ...registry[section][idx], ...entry };
+  const sectionList = section === "official" ? registry.official : registry.community;
+  const list = sectionList ?? [];
+  if (section === "official") {
+    registry.official = list;
   } else {
-    registry[section].push(entry);
+    registry.community = list;
+  }
+  const existingIdx = list.findIndex((v) => v.package === packageName);
+  if (existingIdx >= 0) {
+    const existing = list.at(existingIdx);
+    list.splice(existingIdx, 1, { ...existing, ...entry });
+  } else {
+    list.push(entry);
   }
   const updatedContent = Buffer.from(JSON.stringify(registry, null, 2) + "\n").toString("base64");
   const mainRes = await fetch(
@@ -1764,7 +1778,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 || !score.agents[agentName]) {
+  if (!agentName || !Object.hasOwn(score.agents, agentName)) {
     logger10.error(
       { requested: agentName, available: agentNames },
       "Agent not found in score"
@@ -1785,7 +1799,8 @@ async function serveCommand(scorePath, options = {}) {
     reactive.on("reloaded", () => {
       void (async () => {
         try {
-          const nextScore = reactive.current;
+          const nextScore = reactive?.current;
+          if (!nextScore) return;
           const nextRuntime = buildRuntime2(nextScore, sharedSessions);
           const nextApp = await buildApp(nextRuntime, agentName, port, host, options.apiKey);
           await app.close();
@@ -1960,28 +1975,796 @@ async function scheduleCommand(scorePath) {
   await new Promise(() => void 0);
 }
 
-// src/commands/schedules.ts
-import { existsSync as existsSync12 } from "fs";
+// 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";
+var TUTTI_PACKAGES = [
+  "@tuttiai/core",
+  "@tuttiai/cli",
+  "@tuttiai/types",
+  "@tuttiai/server",
+  "@tuttiai/filesystem",
+  "@tuttiai/github",
+  "@tuttiai/playwright",
+  "@tuttiai/mcp",
+  "@tuttiai/web",
+  "@tuttiai/sandbox",
+  "@tuttiai/rag"
+];
+function getInstalledVersion(pkg) {
+  try {
+    const out = execSync3(`npm list ${pkg} --depth=0 --json 2>/dev/null`, {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const data = JSON.parse(out);
+    const deps = data.dependencies;
+    if (!deps) return null;
+    for (const [name, info] of Object.entries(deps)) {
+      if (name === pkg && info.version) return info.version;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function getLatestVersion(pkg) {
+  try {
+    return execSync3(`npm view ${pkg} version 2>/dev/null`, {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+function detectPackageManager() {
+  const cwd = process.cwd();
+  if (existsSync12(resolve12(cwd, "yarn.lock"))) return "yarn";
+  if (existsSync12(resolve12(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  return "npm";
+}
+function isGlobalInstall() {
+  try {
+    const globalPrefix = execSync3("npm prefix -g", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    return process.argv[1]?.startsWith(globalPrefix) ?? false;
+  } catch {
+    return false;
+  }
+}
+function updateCommand() {
+  console.log();
+  console.log(chalk12.cyan.bold("  Tutti Update"));
+  console.log();
+  const spinner = ora7("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)
+    );
+    if (isGlobalInstall()) {
+      const updateSpinner2 = ora7("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"));
+      }
+    } else {
+      console.log(chalk12.dim("  Global: npm install -g tutti-ai@latest"));
+    }
+  } else {
+    console.log(chalk12.green("  CLI is up to date") + chalk12.dim(" (" + cliCurrent + ")"));
+  }
+  const pkgPath = resolve12(process.cwd(), "package.json");
+  if (!existsSync12(pkgPath)) {
+    console.log();
+    console.log(chalk12.dim("  No package.json found \u2014 skipping project dependency check."));
+    console.log();
+    return;
+  }
+  let pkg;
+  try {
+    pkg = JSON.parse(readFileSync5(pkgPath, "utf-8"));
+  } catch {
+    console.log(chalk12.dim("  Could not read package.json"));
+    return;
+  }
+  const allDeps = /* @__PURE__ */ new Map();
+  if (pkg.dependencies) {
+    for (const [name, version] of Object.entries(pkg.dependencies)) {
+      allDeps.set(name, version);
+    }
+  }
+  if (pkg.devDependencies) {
+    for (const [name, version] of Object.entries(pkg.devDependencies)) {
+      allDeps.set(name, version);
+    }
+  }
+  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();
+    return;
+  }
+  console.log();
+  console.log("  " + chalk12.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)"));
+      continue;
+    }
+    const cleanCurrent = current.replace(/^[\^~]/, "");
+    if (cleanCurrent === latest) {
+      console.log("  " + chalk12.green("\u2714") + " " + name + " " + chalk12.dim(latest));
+    } else {
+      console.log(
+        "  " + chalk12.yellow("\u2191") + " " + name + " " + chalk12.dim(cleanCurrent) + " \u2192 " + chalk12.green(latest)
+      );
+      toUpdate.push(name + "@latest");
+    }
+  }
+  if (toUpdate.length === 0) {
+    console.log();
+    console.log(chalk12.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();
+  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();
+}
+
+// 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";
+function getLatestVersion2(pkg) {
+  try {
+    return execSync4(`npm view ${pkg} version 2>/dev/null`, {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+function pad(s, len) {
+  return s.length >= len ? s : s + " ".repeat(len - s.length);
+}
+function outdatedCommand() {
+  const pkgPath = resolve13(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.'));
+    process.exit(1);
+  }
+  let pkg;
+  try {
+    pkg = JSON.parse(readFileSync6(pkgPath, "utf-8"));
+  } catch {
+    console.error(chalk13.red("Could not parse package.json"));
+    process.exit(1);
+  }
+  const allDeps = /* @__PURE__ */ new Map();
+  if (pkg.dependencies) {
+    for (const [name, version] of Object.entries(pkg.dependencies)) {
+      allDeps.set(name, version);
+    }
+  }
+  if (pkg.devDependencies) {
+    for (const [name, version] of Object.entries(pkg.devDependencies)) {
+      allDeps.set(name, version);
+    }
+  }
+  const tuttiDeps = [...allDeps.entries()].filter(([name]) => name.startsWith("@tuttiai/"));
+  if (tuttiDeps.length === 0) {
+    console.log(chalk13.dim("No @tuttiai packages found in this project."));
+    return;
+  }
+  const spinner = ora8("Checking npm registry...").start();
+  const results = [];
+  for (const [name, version] of tuttiDeps) {
+    const latest = getLatestVersion2(name);
+    const current = version.replace(/^[\^~]/, "");
+    results.push({
+      name,
+      current,
+      latest: latest ?? "?",
+      outdated: latest !== null && current !== latest
+    });
+  }
+  spinner.stop();
+  console.log();
+  console.log(
+    chalk13.dim(
+      "  " + pad("PACKAGE", 28) + pad("CURRENT", 12) + pad("LATEST", 12) + "STATUS"
+    )
+  );
+  console.log(chalk13.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");
+    if (r.outdated) outdatedCount++;
+    console.log(
+      "  " + pad(r.name, 28) + pad(r.current, 12) + pad(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")
+    );
+  } else {
+    console.log(chalk13.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) {
+  return s.length >= len ? s : s + " ".repeat(len - s.length);
+}
+async function infoCommand(scorePath) {
+  const pkgPath = resolve14(process.cwd(), "package.json");
+  let projectName = "(unknown)";
+  let projectVersion = "(unknown)";
+  const installedDeps = /* @__PURE__ */ new Map();
+  if (existsSync14(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync7(pkgPath, "utf-8"));
+      projectName = pkg.name ?? "(unnamed)";
+      projectVersion = pkg.version ?? "0.0.0";
+      if (pkg.dependencies) {
+        for (const [name, version] of Object.entries(pkg.dependencies)) {
+          installedDeps.set(name, version);
+        }
+      }
+      if (pkg.devDependencies) {
+        for (const [name, version] of Object.entries(pkg.devDependencies)) {
+          installedDeps.set(name, version);
+        }
+      }
+    } catch {
+    }
+  }
+  console.log();
+  console.log(chalk14.cyan.bold("  Tutti Project Info"));
+  console.log();
+  console.log("  " + chalk14.dim("Project:") + "  " + chalk14.bold(projectName) + " " + chalk14.dim(projectVersion));
+  const tuttiPkgs = [...installedDeps.entries()].filter(([name]) => name.startsWith("@tuttiai/"));
+  if (tuttiPkgs.length > 0) {
+    console.log();
+    console.log("  " + chalk14.bold("Packages:"));
+    for (const [name, version] of tuttiPkgs) {
+      console.log("    " + pad2(name, 28) + chalk14.dim(version));
+    }
+  }
+  const scoreFile = resolve14(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();
+    return;
+  }
+  let score;
+  try {
+    score = await ScoreLoader8.load(scoreFile);
+  } catch (err) {
+    logger12.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();
+    return;
+  }
+  console.log("  " + chalk14.dim("Score:") + "    " + (score.name ?? scoreFile));
+  const agentEntries = Object.entries(score.agents);
+  console.log();
+  console.log("  " + chalk14.bold("Agents:") + chalk14.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)";
+    const flags = [];
+    if (agent.streaming) flags.push("streaming");
+    if (agent.allow_human_input) flags.push("hitl");
+    if (agent.durable) flags.push("durable");
+    if (agent.schedule) flags.push("scheduled");
+    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);
+    if (flags.length > 0) {
+      console.log("      " + chalk14.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);
+    }
+  }
+  if (score.entry) {
+    const entry = typeof score.entry === "string" ? score.entry : "parallel";
+    console.log();
+    console.log("  " + chalk14.dim("Entry:") + "    " + entry);
+  }
+  console.log();
+}
+
+// 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";
+function detectPackageManager2() {
+  const cwd = process.cwd();
+  if (existsSync15(resolve15(cwd, "yarn.lock"))) return "yarn";
+  if (existsSync15(resolve15(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  return "npm";
+}
+function resolvePackageName2(input) {
+  const KNOWN = /* @__PURE__ */ new Map([
+    ["filesystem", "@tuttiai/filesystem"],
+    ["github", "@tuttiai/github"],
+    ["playwright", "@tuttiai/playwright"],
+    ["mcp", "@tuttiai/mcp"],
+    ["web", "@tuttiai/web"],
+    ["sandbox", "@tuttiai/sandbox"],
+    ["rag", "@tuttiai/rag"],
+    ["core", "@tuttiai/core"],
+    ["types", "@tuttiai/types"],
+    ["server", "@tuttiai/server"]
+  ]);
+  return KNOWN.get(input) ?? (input.startsWith("@") ? input : `@tuttiai/${input}`);
+}
+function getInstalledTuttiPackages() {
+  const pkgPath = resolve15(process.cwd(), "package.json");
+  if (!existsSync15(pkgPath)) return /* @__PURE__ */ new Map();
+  try {
+    const pkg = JSON.parse(readFileSync8(pkgPath, "utf-8"));
+    const result = /* @__PURE__ */ new Map();
+    if (pkg.dependencies) {
+      for (const [name, version] of Object.entries(pkg.dependencies)) {
+        if (name.startsWith("@tuttiai/")) result.set(name, version);
+      }
+    }
+    if (pkg.devDependencies) {
+      for (const [name, version] of Object.entries(pkg.devDependencies)) {
+        if (name.startsWith("@tuttiai/")) result.set(name, version);
+      }
+    }
+    return result;
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+}
+function upgradeCommand(target) {
+  const pkgPath = resolve15(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.'));
+    process.exit(1);
+  }
+  const pm = detectPackageManager2();
+  const installed = getInstalledTuttiPackages();
+  if (installed.size === 0) {
+    console.log(chalk15.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(", ")));
+      process.exit(1);
+    }
+    packages = [resolved + "@latest"];
+    console.log(chalk15.cyan("  Upgrading " + resolved + "..."));
+  } else {
+    packages = [...installed.keys()].map((p) => p + "@latest");
+    console.log(chalk15.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();
+  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));
+    process.exit(1);
+  }
+  console.log();
+  const newInstalled = getInstalledTuttiPackages();
+  for (const [name, oldVersion] of installed) {
+    const newVersion = newInstalled.get(name) ?? oldVersion;
+    const oldClean = oldVersion.replace(/^[\^~]/, "");
+    const newClean = newVersion.replace(/^[\^~]/, "");
+    if (oldClean !== newClean) {
+      console.log("  " + chalk15.green("\u2191") + " " + name + " " + chalk15.dim(oldClean) + " \u2192 " + chalk15.green(newClean));
+    } else {
+      console.log("  " + chalk15.dim("=") + " " + name + " " + chalk15.dim(newClean) + chalk15.dim(" (already latest)"));
+    }
+  }
+  console.log();
+}
+
+// src/commands/replay.ts
+import { existsSync as existsSync16 } from "fs";
+import { writeFile } from "fs/promises";
+import { resolve as resolve16 } from "path";
+import { createInterface as createInterface3 } from "readline/promises";
+import chalk17 from "chalk";
+import ora10 from "ora";
+import {
+  PostgresSessionStore,
+  ScoreLoader as ScoreLoader9,
+  TuttiRuntime as TuttiRuntime5,
+  SecretsManager as SecretsManager7,
+  createLogger as createLogger13
+} from "@tuttiai/core";
+
+// src/commands/replay-render.ts
+import chalk16 from "chalk";
+function messageToText2(msg) {
+  if (typeof msg.content === "string") return msg.content;
+  const parts = [];
+  for (const block of msg.content) {
+    if (block.type === "text") {
+      parts.push(block.text);
+    } else if (block.type === "tool_use") {
+      parts.push("[tool_use " + block.name + "]");
+    } else if (block.type === "tool_result") {
+      const preview = block.content.replace(/\s+/g, " ").trim();
+      parts.push("[tool_result " + (preview.length > 60 ? preview.slice(0, 59) + "\u2026" : preview) + "]");
+    }
+  }
+  return parts.join(" ");
+}
+function excerpt2(text, max) {
+  const oneLine = text.replace(/\s+/g, " ").trim();
+  return oneLine.length > max ? oneLine.slice(0, max - 1) + "\u2026" : oneLine;
+}
+function renderList(messages) {
+  const lines = [];
+  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 text = excerpt2(messageToText2(msg), 80);
+    lines.push(
+      chalk16.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));
+  }
+  const msg = messages.at(index);
+  if (!msg) return chalk16.red("Index out of range.");
+  const lines = [];
+  lines.push(chalk16.cyan.bold("Turn " + index) + "  " + chalk16.dim("[" + msg.role + "]"));
+  lines.push("");
+  if (typeof msg.content === "string") {
+    lines.push(msg.content);
+  } else {
+    for (const block of msg.content) {
+      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)));
+      } else if (block.type === "tool_result") {
+        const label = block.is_error ? chalk16.red("  tool_result (error):") : chalk16.green("  tool_result:");
+        lines.push(label);
+        lines.push(chalk16.dim("  tool_use_id: " + block.tool_use_id));
+        lines.push("  " + block.content);
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function renderInspect(messages, index) {
+  if (index < 0 || index >= messages.length) {
+    return chalk16.red("Index out of range.");
+  }
+  return JSON.stringify(messages.at(index), null, 2);
+}
+function exportJSON(session) {
+  return JSON.stringify(
+    {
+      id: session.id,
+      agent_name: session.agent_name,
+      created_at: session.created_at,
+      messages: session.messages
+    },
+    null,
+    2
+  );
+}
+function exportMarkdown(session) {
+  const lines = [];
+  lines.push("# Session " + session.id);
+  lines.push("");
+  lines.push("**Agent:** " + session.agent_name);
+  lines.push("**Created:** " + session.created_at.toISOString());
+  lines.push("**Messages:** " + session.messages.length);
+  lines.push("");
+  lines.push("---");
+  lines.push("");
+  for (let i = 0; i < session.messages.length; i++) {
+    const msg = session.messages.at(i);
+    if (!msg) continue;
+    lines.push("## Turn " + i + " (" + msg.role + ")");
+    lines.push("");
+    if (typeof msg.content === "string") {
+      lines.push(msg.content);
+    } else {
+      for (const block of msg.content) {
+        if (block.type === "text") {
+          lines.push(block.text);
+        } else if (block.type === "tool_use") {
+          lines.push("**Tool call:** `" + block.name + "`");
+          lines.push("```json\n" + JSON.stringify(block.input, null, 2) + "\n```");
+        } else if (block.type === "tool_result") {
+          const label = block.is_error ? "**Tool error:**" : "**Tool result:**";
+          lines.push(label);
+          lines.push("```\n" + block.content + "\n```");
+        }
+      }
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/commands/replay.ts
+var logger13 = createLogger13("tutti-cli");
+async function replayCommand(sessionId, opts = {}) {
+  const pgUrl = SecretsManager7.optional("TUTTI_PG_URL");
+  if (!pgUrl) {
+    console.error(chalk17.red("TUTTI_PG_URL is not set."));
+    console.error(
+      chalk17.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...");
+  let session;
+  try {
+    session = await store.getAsync(sessionId);
+  } catch (err) {
+    spinner.fail("Failed to load session");
+    logger13.error(
+      { error: err instanceof Error ? err.message : String(err) },
+      "Session store error"
+    );
+    process.exit(1);
+  }
+  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."));
+    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("");
+  console.log(chalk17.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 prompt3 = chalk17.cyan("replay [" + cursor + "/" + (messages.length - 1) + "]> ");
+      const raw = await rl.question(prompt3);
+      const input = raw.trim();
+      if (!input) continue;
+      const [cmd, ...args] = input.split(/\s+/);
+      switch (cmd) {
+        case "quit":
+        case "exit":
+        case "q":
+          console.log(chalk17.dim("Bye."));
+          return;
+        case "list":
+          console.log(renderList(messages));
+          break;
+        case "show": {
+          const n = parseInt(args[0] ?? String(cursor), 10);
+          console.log(renderShow(messages, n));
+          if (n >= 0 && n < messages.length) cursor = n;
+          break;
+        }
+        case "next":
+          if (cursor < messages.length - 1) {
+            cursor++;
+            console.log(renderShow(messages, cursor));
+          } else {
+            console.log(chalk17.dim("Already at last message."));
+          }
+          break;
+        case "prev":
+          if (cursor > 0) {
+            cursor--;
+            console.log(renderShow(messages, cursor));
+          } else {
+            console.log(chalk17.dim("Already at first message."));
+          }
+          break;
+        case "inspect":
+          console.log(renderInspect(messages, cursor));
+          break;
+        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>"));
+            break;
+          }
+          await handleReplayFrom(turn, session, rl, opts);
+          break;
+        }
+        case "export": {
+          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));
+          } 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));
+          } else {
+            console.log(chalk17.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")
+          );
+      }
+    }
+  } finally {
+    rl.close();
+    await store.close();
+  }
+}
+async function handleReplayFrom(turn, session, rl, opts) {
+  const scoreFile = resolve16(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."));
+    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) ")
+  );
+  const input = answer.trim().toLowerCase() === "y" || answer.trim() === "" ? originalInput : answer.trim();
+  if (!input) {
+    console.log(chalk17.dim("No input provided. Cancelled."));
+    return;
+  }
+  const spinnerLoad = ora10({ color: "cyan" }).start("Loading score...");
+  let score;
+  try {
+    score = await ScoreLoader9.load(scoreFile);
+  } catch (err) {
+    spinnerLoad.fail("Failed to load score");
+    logger13.error({ error: err instanceof Error ? err.message : String(err) }, "Score load error");
+    return;
+  }
+  spinnerLoad.stop();
+  const restoredMessages = session.messages.slice(0, turn);
+  const runtime = new TuttiRuntime5(score);
+  const sessions = runtime.sessions;
+  if ("save" in sessions && typeof sessions.save === "function") {
+    sessions.save({
+      id: session.id,
+      agent_name: session.agent_name,
+      messages: restoredMessages,
+      created_at: session.created_at,
+      updated_at: /* @__PURE__ */ new Date()
+    });
+  }
+  const agentName = session.agent_name;
+  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.'));
+    return;
+  }
+  const spinnerRun = ora10({ color: "cyan" }).start("Running from turn " + turn + "...");
+  runtime.events.on("token:stream", (e) => {
+    spinnerRun.stop();
+    process.stdout.write(e.text);
+  });
+  try {
+    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("");
+    console.log(result.output);
+  } catch (err) {
+    spinnerRun.fail("Replay failed");
+    logger13.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 {
-  ScoreLoader as ScoreLoader8,
+  ScoreLoader as ScoreLoader10,
   SchedulerEngine as SchedulerEngine2,
   PostgresScheduleStore as PostgresScheduleStore2,
   MemoryScheduleStore as MemoryScheduleStore2,
   AgentRunner as AgentRunner2,
   EventBus as EventBus2,
   InMemorySessionStore as InMemorySessionStore4,
-  SecretsManager as SecretsManager7,
-  createLogger as createLogger12
+  SecretsManager as SecretsManager8,
+  createLogger as createLogger14
 } from "@tuttiai/core";
-var logger12 = createLogger12("tutti-cli");
+var logger14 = createLogger14("tutti-cli");
 function resolveStore2() {
-  const pgUrl = SecretsManager7.optional("TUTTI_PG_URL");
+  const pgUrl = SecretsManager8.optional("TUTTI_PG_URL");
   if (pgUrl) {
     return new PostgresScheduleStore2({ connection_string: pgUrl });
   }
-  logger12.warn("TUTTI_PG_URL not set \u2014 using in-memory store (schedules are ephemeral)");
+  logger14.warn("TUTTI_PG_URL not set \u2014 using in-memory store (schedules are ephemeral)");
   return new MemoryScheduleStore2();
 }
 async function closeStore(store) {
@@ -1995,7 +2778,7 @@ function formatTrigger(r) {
   if (r.config.at) return "at " + r.config.at;
   return "?";
 }
-function pad(s, len) {
+function pad3(s, len) {
   return s.length >= len ? s : s + " ".repeat(len - s.length);
 }
 async function schedulesListCommand() {
@@ -2003,22 +2786,22 @@ async function schedulesListCommand() {
   try {
     const records = await store.list();
     if (records.length === 0) {
-      console.log(chalk12.dim("No schedules found."));
-      console.log(chalk12.dim('Run "tutti-ai schedule" to start the scheduler daemon.'));
+      console.log(chalk18.dim("No schedules found."));
+      console.log(chalk18.dim('Run "tutti-ai schedule" to start the scheduler daemon.'));
       return;
     }
     console.log("");
     console.log(
-      chalk12.dim(
-        "  " + pad("ID", 20) + pad("AGENT", 16) + pad("TRIGGER", 22) + pad("ENABLED", 10) + pad("RUNS", 8) + "CREATED"
+      chalk18.dim(
+        "  " + pad3("ID", 20) + pad3("AGENT", 16) + pad3("TRIGGER", 22) + pad3("ENABLED", 10) + pad3("RUNS", 8) + "CREATED"
       )
     );
-    console.log(chalk12.dim("  " + "\u2500".repeat(90)));
+    console.log(chalk18.dim("  " + "\u2500".repeat(90)));
     for (const r of records) {
-      const enabled = r.enabled ? chalk12.green("yes") : chalk12.red("no") + " ";
+      const enabled = r.enabled ? chalk18.green("yes") : chalk18.red("no") + " ";
       const maxLabel = r.config.max_runs ? r.run_count + "/" + r.config.max_runs : String(r.run_count);
       console.log(
-        "  " + chalk12.bold(pad(r.id, 20)) + pad(r.agent_id, 16) + pad(formatTrigger(r), 22) + pad(enabled, 10) + pad(maxLabel, 8) + chalk12.dim(r.created_at.toISOString().slice(0, 10))
+        "  " + 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))
       );
     }
     console.log("");
@@ -2031,11 +2814,11 @@ async function schedulesEnableCommand(id) {
   try {
     const record = await store.get(id);
     if (!record) {
-      console.error(chalk12.red('Schedule "' + id + '" not found.'));
+      console.error(chalk18.red('Schedule "' + id + '" not found.'));
       process.exit(1);
     }
     await store.setEnabled(id, true);
-    console.log(chalk12.green('Schedule "' + id + '" enabled.'));
+    console.log(chalk18.green('Schedule "' + id + '" enabled.'));
   } finally {
     await closeStore(store);
   }
@@ -2045,22 +2828,22 @@ async function schedulesDisableCommand(id) {
   try {
     const record = await store.get(id);
     if (!record) {
-      console.error(chalk12.red('Schedule "' + id + '" not found.'));
+      console.error(chalk18.red('Schedule "' + id + '" not found.'));
       process.exit(1);
     }
     await store.setEnabled(id, false);
-    console.log(chalk12.yellow('Schedule "' + id + '" disabled.'));
+    console.log(chalk18.yellow('Schedule "' + id + '" disabled.'));
   } finally {
     await closeStore(store);
   }
 }
 async function schedulesTriggerCommand(id, scorePath) {
-  const file = resolve12(scorePath ?? "./tutti.score.ts");
-  if (!existsSync12(file)) {
-    console.error(chalk12.red("Score file not found: " + file));
+  const file = resolve17(scorePath ?? "./tutti.score.ts");
+  if (!existsSync17(file)) {
+    console.error(chalk18.red("Score file not found: " + file));
     process.exit(1);
   }
-  const score = await ScoreLoader8.load(file);
+  const score = await ScoreLoader10.load(file);
   const events = new EventBus2();
   const sessions = new InMemorySessionStore4();
   const runner = new AgentRunner2(score.provider, events, sessions);
@@ -2068,30 +2851,30 @@ async function schedulesTriggerCommand(id, scorePath) {
   try {
     const record = await store.get(id);
     if (!record) {
-      console.error(chalk12.red('Schedule "' + id + '" not found.'));
+      console.error(chalk18.red('Schedule "' + id + '" not found.'));
       process.exit(1);
     }
     const agent = score.agents[record.agent_id];
     if (!agent) {
-      console.error(chalk12.red('Agent "' + record.agent_id + '" not found in score.'));
+      console.error(chalk18.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(chalk12.cyan('Triggering "' + id + '" (' + record.agent_id + ")..."));
+    console.log(chalk18.cyan('Triggering "' + id + '" (' + record.agent_id + ")..."));
     const run2 = await engine.trigger(id);
     engine.stop();
     if (run2.error) {
-      console.log(chalk12.red("  Error: " + run2.error));
+      console.log(chalk18.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(chalk12.green("  Completed in " + duration + "ms"));
+    console.log(chalk18.green("  Completed in " + duration + "ms"));
     if (run2.result) {
       const preview = run2.result.length > 200 ? run2.result.slice(0, 200) + "..." : run2.result;
-      console.log(chalk12.dim("  Output: " + preview));
+      console.log(chalk18.dim("  Output: " + preview));
     }
   } finally {
     await closeStore(store);
@@ -2102,50 +2885,316 @@ async function schedulesRunsCommand(id) {
   try {
     const record = await store.get(id);
     if (!record) {
-      console.error(chalk12.red('Schedule "' + id + '" not found.'));
+      console.error(chalk18.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(chalk12.dim("No runs recorded for this schedule."));
+        console.log(chalk18.dim("No runs recorded for this schedule."));
         return;
       }
       const recent = runs.slice(-20);
       console.log("");
-      console.log(chalk12.dim("  Showing last " + recent.length + " of " + runs.length + " runs:"));
+      console.log(chalk18.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 ? chalk12.red("error") : chalk12.green("ok");
+        const status = run2.error ? chalk18.red("error") : chalk18.green("ok");
         const preview = run2.error ? run2.error.slice(0, 80) : (run2.result ?? "").slice(0, 80);
         console.log(
-          "  " + chalk12.dim(run2.triggered_at.toISOString()) + "  " + status + "  " + chalk12.dim(duration) + "  " + preview
+          "  " + chalk18.dim(run2.triggered_at.toISOString()) + "  " + status + "  " + chalk18.dim(duration) + "  " + preview
         );
       }
       console.log("");
     } else {
-      console.log(chalk12.dim('Schedule "' + id + '" has completed ' + record.run_count + " runs."));
-      console.log(chalk12.dim("Full run history requires the MemoryScheduleStore or a future tutti_schedule_runs table."));
+      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."));
     }
   } finally {
     await closeStore(store);
   }
 }
 
+// src/commands/traces.ts
+import chalk20 from "chalk";
+import { SecretsManager as SecretsManager9 } from "@tuttiai/core";
+
+// src/commands/traces-render.ts
+import chalk19 from "chalk";
+function visibleLen(s) {
+  return s.replace(/\u001b\[[0-9;]*m/g, "").length;
+}
+function pad4(s, len) {
+  const v = visibleLen(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");
+}
+function formatCost(cost) {
+  if (cost === null) return chalk19.dim("\u2014");
+  if (cost === 0) return "$0";
+  return "$" + cost.toFixed(6);
+}
+function formatTokens(n) {
+  return n > 0 ? String(n) : chalk19.dim("\u2014");
+}
+function formatDuration(ms) {
+  if (ms === null) return chalk19.dim("\u2014");
+  return ms + "ms";
+}
+function renderTracesList(traces) {
+  if (traces.length === 0) {
+    return chalk19.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"
+    )
+  );
+  lines.push(chalk19.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)
+    );
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+var SPAN_ICONS = {
+  agent: "\u25B6",
+  llm: "\u25C6",
+  tool: "\u2699",
+  guardrail: "\u{1F6E1}",
+  checkpoint: "\u{1F4BE}"
+};
+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 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;
+}
+function formatAttrs(span) {
+  const a = span.attributes;
+  const parts = [];
+  if (span.kind === "agent") {
+    if (a.agent_id !== void 0) parts.push("agent=" + a.agent_id);
+    if (a.model !== void 0) parts.push("model=" + a.model);
+  } else if (span.kind === "llm") {
+    if (a.model !== void 0) parts.push("model=" + a.model);
+    if (a.total_tokens !== void 0) parts.push(a.total_tokens + " tok");
+    if (a.cost_usd !== void 0) parts.push(formatCost(a.cost_usd));
+  } else if (span.kind === "tool") {
+    if (a.tool_name !== void 0) parts.push(a.tool_name);
+  } else if (span.kind === "guardrail") {
+    if (a.guardrail_name !== void 0) parts.push(a.guardrail_name);
+    if (a.guardrail_action !== void 0) parts.push("\u2192 " + a.guardrail_action);
+  } else if (span.kind === "checkpoint") {
+    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));
+  }
+  return parts.join(" \xB7 ");
+}
+function renderTraceShow(spans) {
+  if (spans.length === 0) {
+    return chalk19.dim("No spans found for this trace.");
+  }
+  const childrenByParent = /* @__PURE__ */ new Map();
+  const presentSpanIds = new Set(spans.map((s) => s.span_id));
+  const roots = [];
+  for (const span of spans) {
+    const parent = span.parent_span_id;
+    if (parent === void 0 || !presentSpanIds.has(parent)) {
+      roots.push(span);
+      continue;
+    }
+    const arr = childrenByParent.get(parent) ?? [];
+    arr.push(span);
+    childrenByParent.set(parent, arr);
+  }
+  roots.sort((a, b) => a.started_at.getTime() - b.started_at.getTime());
+  const lines = [""];
+  function walk(span, indent) {
+    lines.push(renderSpanLine(span, indent));
+    const kids = childrenByParent.get(span.span_id);
+    if (!kids) return;
+    for (const child of kids) {
+      walk(child, indent + 1);
+    }
+  }
+  for (const root of roots) walk(root, 0);
+  let total_tokens = 0;
+  let total_cost = 0;
+  let any_cost = false;
+  for (const s of spans) {
+    if (s.name !== "llm.completion") continue;
+    total_tokens += s.attributes.total_tokens ?? 0;
+    if (s.attributes.cost_usd !== void 0) {
+      total_cost += s.attributes.cost_usd;
+      any_cost = true;
+    }
+  }
+  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(
+    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")
+  );
+  lines.push("");
+  return lines.join("\n");
+}
+
+// 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;
+}
+function resolveAuthHeader(opts) {
+  const key = opts.apiKey ?? SecretsManager9.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."));
+  process.exit(1);
+}
+async function tracesListCommand(opts) {
+  const baseUrl = resolveUrl(opts);
+  const url = baseUrl.replace(/\/$/, "") + "/traces";
+  let res;
+  try {
+    res = await fetch(url, { headers: resolveAuthHeader(opts) });
+  } catch (err) {
+    explainConnectionError(err, baseUrl);
+  }
+  if (res.status === 401) {
+    console.error(chalk20.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));
+    process.exit(1);
+  }
+  const body = await res.json();
+  console.log(renderTracesList(body.traces));
+}
+async function tracesShowCommand(traceId, opts) {
+  const baseUrl = resolveUrl(opts);
+  const url = baseUrl.replace(/\/$/, "") + "/traces/" + encodeURIComponent(traceId);
+  let res;
+  try {
+    res = await fetch(url, { headers: resolveAuthHeader(opts) });
+  } catch (err) {
+    explainConnectionError(err, baseUrl);
+  }
+  if (res.status === 404) {
+    console.error(chalk20.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."));
+    process.exit(1);
+  }
+  if (!res.ok) {
+    console.error(chalk20.red("Server returned " + res.status + " " + res.statusText));
+    process.exit(1);
+  }
+  const body = await res.json();
+  const spans = body.spans.map(reviveSpanDates);
+  console.log(renderTraceShow(spans));
+}
+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("");
+  const controller = new AbortController();
+  process.once("SIGINT", () => {
+    controller.abort();
+    console.error("");
+    console.error(chalk20.dim("Disconnected."));
+    process.exit(0);
+  });
+  let res;
+  try {
+    res = await fetch(url, {
+      headers: { ...resolveAuthHeader(opts), Accept: "text/event-stream" },
+      signal: controller.signal
+    });
+  } catch (err) {
+    if (controller.signal.aborted) return;
+    explainConnectionError(err, baseUrl);
+  }
+  if (res.status === 401) {
+    console.error(chalk20.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));
+    process.exit(1);
+  }
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  for (; ; ) {
+    let chunk;
+    try {
+      chunk = await reader.read();
+    } catch {
+      return;
+    }
+    if (chunk.done) break;
+    buffer += decoder.decode(chunk.value, { stream: true });
+    let frameEnd;
+    while ((frameEnd = buffer.indexOf("\n\n")) !== -1) {
+      const frame = buffer.slice(0, frameEnd);
+      buffer = buffer.slice(frameEnd + 2);
+      const dataLine = frame.split("\n").find((l) => l.startsWith("data: "));
+      if (!dataLine) continue;
+      try {
+        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))));
+      }
+    }
+  }
+}
+function reviveSpanDates(span) {
+  return {
+    ...span,
+    started_at: new Date(span.started_at),
+    ...span.ended_at !== void 0 ? { ended_at: new Date(span.ended_at) } : {}
+  };
+}
+
 // src/index.ts
 config();
-var logger13 = createLogger13("tutti-cli");
+var logger15 = createLogger15("tutti-cli");
 process.on("unhandledRejection", (reason) => {
-  logger13.error({ error: reason instanceof Error ? reason.message : String(reason) }, "Unhandled rejection");
+  logger15.error({ error: reason instanceof Error ? reason.message : String(reason) }, "Unhandled rejection");
   process.exit(1);
 });
 process.on("uncaughtException", (err) => {
-  logger13.error({ error: err.message }, "Fatal error");
+  logger15.error({ error: err.message }, "Fatal error");
   process.exit(1);
 });
 var program = new Command();
-program.name("tutti-ai").description("Tutti \u2014 multi-agent orchestration. All agents. All together.").version("0.12.0");
+program.name("tutti-ai").description("Tutti \u2014 multi-agent orchestration. All agents. All together.").version("0.13.0");
 program.command("init [project-name]").description("Create a new Tutti project").option("-t, --template <id>", "Project template to use").action(async (projectName, opts) => {
   await initCommand(projectName, opts.template);
 });
@@ -2201,6 +3250,21 @@ program.command("publish").description("Publish the current voice to npm and the
 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) => {
   await evalCommand(suitePath, opts);
 });
+program.command("update").description("Update @tuttiai packages to their latest versions").action(() => {
+  updateCommand();
+});
+program.command("outdated").description("Check installed @tuttiai packages for newer versions").action(() => {
+  outdatedCommand();
+});
+program.command("info [score]").description("Show project info \u2014 agents, voices, models, and package versions").action(async (score) => {
+  await infoCommand(score);
+});
+program.command("upgrade [voice]").description("Upgrade a specific voice or all @tuttiai packages to latest").action((voice) => {
+  upgradeCommand(voice);
+});
+program.command("replay <session-id>").description("Time-travel debugger \u2014 navigate and replay a session from PostgreSQL").option("-s, --score <path>", "Path to score file for replay-from (default: ./tutti.score.ts)").action(async (sessionId, opts) => {
+  await replayCommand(sessionId, { score: opts.score });
+});
 program.command("schedule [score]").description("Start the scheduler daemon \u2014 runs agents on their configured schedules").action(async (score) => {
   await scheduleCommand(score);
 });
@@ -2220,5 +3284,27 @@ schedulesCmd.command("trigger <id>").description("Manually trigger a scheduled r
 schedulesCmd.command("runs <id>").description("Show run history for a schedule (last 20 runs)").action(async (id) => {
   await schedulesRunsCommand(id);
 });
+var tracesCmd = program.command("traces").description("Inspect spans emitted by a running tutti-ai serve process");
+tracesCmd.command("list").description("Show the last 20 traces (most recent first)").option("-u, --url <url>", "Server URL (default: http://127.0.0.1:3847)").option("-k, --api-key <key>", "Bearer token (default: TUTTI_API_KEY env)").action(async (opts) => {
+  const resolved = {
+    ...opts.url !== void 0 ? { url: opts.url } : {},
+    ...opts.apiKey !== void 0 ? { apiKey: opts.apiKey } : {}
+  };
+  await tracesListCommand(resolved);
+});
+tracesCmd.command("show <trace-id>").description("Render every span in a trace as an indented tree").option("-u, --url <url>", "Server URL (default: http://127.0.0.1:3847)").option("-k, --api-key <key>", "Bearer token (default: TUTTI_API_KEY env)").action(async (traceId, opts) => {
+  const resolved = {
+    ...opts.url !== void 0 ? { url: opts.url } : {},
+    ...opts.apiKey !== void 0 ? { apiKey: opts.apiKey } : {}
+  };
+  await tracesShowCommand(traceId, resolved);
+});
+tracesCmd.command("tail").description("Live-tail spans as they are emitted (Ctrl+C to exit)").option("-u, --url <url>", "Server URL (default: http://127.0.0.1:3847)").option("-k, --api-key <key>", "Bearer token (default: TUTTI_API_KEY env)").action(async (opts) => {
+  const resolved = {
+    ...opts.url !== void 0 ? { url: opts.url } : {},
+    ...opts.apiKey !== void 0 ? { apiKey: opts.apiKey } : {}
+  };
+  await tracesTailCommand(resolved);
+});
 program.parse();
 //# sourceMappingURL=index.js.map