@tuttiai/cli 0.11.1 → 0.13.0

package/dist/index.js

@@ -2,7 +2,7 @@
 
 // src/index.ts
 import { config } from "dotenv";
-import { createLogger as createLogger11 } from "@tuttiai/core";
+import { createLogger as createLogger14 } from "@tuttiai/core";
 import { Command } from "commander";
 
 // src/commands/init.ts
@@ -1865,19 +1865,597 @@ function printBanner(port, host, agentName, score, file, watch) {
   console.log();
 }
 
+// src/commands/schedule.ts
+import { existsSync as existsSync11 } from "fs";
+import { resolve as resolve11 } from "path";
+import chalk11 from "chalk";
+import {
+  ScoreLoader as ScoreLoader7,
+  SchedulerEngine,
+  PostgresScheduleStore,
+  MemoryScheduleStore,
+  AgentRunner,
+  EventBus,
+  InMemorySessionStore as InMemorySessionStore3,
+  SecretsManager as SecretsManager6,
+  createLogger as createLogger11
+} from "@tuttiai/core";
+var logger11 = createLogger11("tutti-cli");
+function resolveStore() {
+  const pgUrl = SecretsManager6.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)");
+  return new MemoryScheduleStore();
+}
+async function scheduleCommand(scorePath) {
+  const file = resolve11(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.'));
+    process.exit(1);
+  }
+  const score = await ScoreLoader7.load(file);
+  const events = new EventBus();
+  const sessions = new InMemorySessionStore3();
+  const runner = new AgentRunner(
+    score.provider,
+    events,
+    sessions
+  );
+  const store = resolveStore();
+  const engine = new SchedulerEngine(store, runner, events);
+  let registered = 0;
+  for (const [agentId, agent] of Object.entries(score.agents)) {
+    if (!agent.schedule) continue;
+    const resolvedAgent = agent.model ? agent : { ...agent, model: score.default_model ?? "claude-sonnet-4-20250514" };
+    await engine.schedule(agentId, resolvedAgent, agent.schedule);
+    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."));
+    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
+      );
+    }
+    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)")
+      );
+    }
+    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
+      );
+    }
+  });
+  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("");
+  console.log(chalk11.dim("  Press Ctrl+C to stop."));
+  console.log("");
+  const shutdown = () => {
+    console.log(chalk11.dim("\n  Shutting down scheduler..."));
+    engine.stop();
+    if ("close" in store && typeof store.close === "function") {
+      void store.close();
+    }
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  await new Promise(() => void 0);
+}
+
+// src/commands/replay.ts
+import { existsSync as existsSync12 } from "fs";
+import { writeFile } from "fs/promises";
+import { resolve as resolve12 } from "path";
+import { createInterface as createInterface3 } from "readline/promises";
+import chalk12 from "chalk";
+import ora7 from "ora";
+import {
+  PostgresSessionStore,
+  ScoreLoader as ScoreLoader8,
+  TuttiRuntime as TuttiRuntime5,
+  SecretsManager as SecretsManager7,
+  createLogger as createLogger12
+} from "@tuttiai/core";
+var logger12 = createLogger12("tutti-cli");
+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[i];
+    const role = msg.role === "user" ? chalk12.blue("user     ") : chalk12.green("assistant");
+    const text = excerpt2(messageToText2(msg), 80);
+    lines.push(
+      chalk12.dim(String(i).padStart(3)) + "  " + role + "  " + text
+    );
+  }
+  return lines.join("\n");
+}
+function renderShow(messages, index) {
+  if (index < 0 || index >= messages.length) {
+    return chalk12.red("Index out of range. Valid: 0\u2013" + (messages.length - 1));
+  }
+  const msg = messages[index];
+  const lines = [];
+  lines.push(chalk12.cyan.bold("Turn " + index) + "  " + chalk12.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(chalk12.yellow("  tool_use: " + block.name));
+        lines.push(chalk12.dim("  id: " + block.id));
+        lines.push(chalk12.dim("  input: " + JSON.stringify(block.input, null, 2)));
+      } else if (block.type === "tool_result") {
+        const label = block.is_error ? chalk12.red("  tool_result (error):") : chalk12.green("  tool_result:");
+        lines.push(label);
+        lines.push(chalk12.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 chalk12.red("Index out of range.");
+  }
+  return JSON.stringify(messages[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[i];
+    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");
+}
+async function replayCommand(sessionId, opts = {}) {
+  const pgUrl = SecretsManager7.optional("TUTTI_PG_URL");
+  if (!pgUrl) {
+    console.error(chalk12.red("TUTTI_PG_URL is not set."));
+    console.error(
+      chalk12.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 = ora7({ color: "cyan" }).start("Loading session...");
+  let session;
+  try {
+    session = await store.getAsync(sessionId);
+  } catch (err) {
+    spinner.fail("Failed to load session");
+    logger12.error(
+      { error: err instanceof Error ? err.message : String(err) },
+      "Session store error"
+    );
+    process.exit(1);
+  }
+  spinner.stop();
+  if (!session) {
+    console.error(chalk12.red("Session not found: " + sessionId));
+    console.error(chalk12.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(chalk12.cyan.bold("  Tutti Replay"));
+  console.log(chalk12.dim("  Session: " + session.id));
+  console.log(chalk12.dim("  Agent:   " + session.agent_name));
+  console.log(chalk12.dim("  Created: " + session.created_at.toISOString()));
+  console.log(chalk12.dim("  Messages: " + messages.length));
+  console.log("");
+  console.log(chalk12.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 = chalk12.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(chalk12.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(chalk12.dim("Already at last message."));
+          }
+          break;
+        case "prev":
+          if (cursor > 0) {
+            cursor--;
+            console.log(renderShow(messages, cursor));
+          } else {
+            console.log(chalk12.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(chalk12.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(chalk12.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(chalk12.green("Exported to " + filename));
+          } else {
+            console.log(chalk12.dim("Usage: export <json|md>"));
+          }
+          break;
+        }
+        default:
+          console.log(
+            chalk12.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 = resolve12(opts.score ?? "./tutti.score.ts");
+  if (!existsSync12(scoreFile)) {
+    console.log(chalk12.red("Score file not found: " + scoreFile));
+    console.log(chalk12.dim("Use --score to specify the score file."));
+    return;
+  }
+  const originalMsg = session.messages[turn];
+  const originalInput = originalMsg ? messageToText2(originalMsg) : "";
+  const answer = await rl.question(
+    chalk12.cyan("Replay from turn " + turn + " with original input? ") + chalk12.dim("(y / enter new input) ")
+  );
+  const input = answer.trim().toLowerCase() === "y" || answer.trim() === "" ? originalInput : answer.trim();
+  if (!input) {
+    console.log(chalk12.dim("No input provided. Cancelled."));
+    return;
+  }
+  const spinnerLoad = ora7({ color: "cyan" }).start("Loading score...");
+  let score;
+  try {
+    score = await ScoreLoader8.load(scoreFile);
+  } catch (err) {
+    spinnerLoad.fail("Failed to load score");
+    logger12.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 agent = score.agents[agentName];
+  if (!agent) {
+    console.log(chalk12.red('Agent "' + agentName + '" not found in score.'));
+    return;
+  }
+  const spinnerRun = ora7({ 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(chalk12.green("Replay complete."));
+    console.log(chalk12.dim("  Turns: " + result.turns));
+    console.log(chalk12.dim("  Tokens: " + result.usage.input_tokens + " in / " + result.usage.output_tokens + " out"));
+    console.log("");
+    console.log(result.output);
+  } catch (err) {
+    spinnerRun.fail("Replay failed");
+    logger12.error({ error: err instanceof Error ? err.message : String(err) }, "Replay error");
+  }
+}
+
+// src/commands/schedules.ts
+import { existsSync as existsSync13 } from "fs";
+import { resolve as resolve13 } from "path";
+import chalk13 from "chalk";
+import {
+  ScoreLoader as ScoreLoader9,
+  SchedulerEngine as SchedulerEngine2,
+  PostgresScheduleStore as PostgresScheduleStore2,
+  MemoryScheduleStore as MemoryScheduleStore2,
+  AgentRunner as AgentRunner2,
+  EventBus as EventBus2,
+  InMemorySessionStore as InMemorySessionStore4,
+  SecretsManager as SecretsManager8,
+  createLogger as createLogger13
+} from "@tuttiai/core";
+var logger13 = createLogger13("tutti-cli");
+function resolveStore2() {
+  const pgUrl = SecretsManager8.optional("TUTTI_PG_URL");
+  if (pgUrl) {
+    return new PostgresScheduleStore2({ connection_string: pgUrl });
+  }
+  logger13.warn("TUTTI_PG_URL not set \u2014 using in-memory store (schedules are ephemeral)");
+  return new MemoryScheduleStore2();
+}
+async function closeStore(store) {
+  if ("close" in store && typeof store.close === "function") {
+    await store.close();
+  }
+}
+function formatTrigger(r) {
+  if (r.config.cron) return "cron: " + r.config.cron;
+  if (r.config.every) return "every " + r.config.every;
+  if (r.config.at) return "at " + r.config.at;
+  return "?";
+}
+function pad(s, len) {
+  return s.length >= len ? s : s + " ".repeat(len - s.length);
+}
+async function schedulesListCommand() {
+  const store = resolveStore2();
+  try {
+    const records = await store.list();
+    if (records.length === 0) {
+      console.log(chalk13.dim("No schedules found."));
+      console.log(chalk13.dim('Run "tutti-ai schedule" to start the scheduler daemon.'));
+      return;
+    }
+    console.log("");
+    console.log(
+      chalk13.dim(
+        "  " + pad("ID", 20) + pad("AGENT", 16) + pad("TRIGGER", 22) + pad("ENABLED", 10) + pad("RUNS", 8) + "CREATED"
+      )
+    );
+    console.log(chalk13.dim("  " + "\u2500".repeat(90)));
+    for (const r of records) {
+      const enabled = r.enabled ? chalk13.green("yes") : chalk13.red("no") + " ";
+      const maxLabel = r.config.max_runs ? r.run_count + "/" + r.config.max_runs : String(r.run_count);
+      console.log(
+        "  " + chalk13.bold(pad(r.id, 20)) + pad(r.agent_id, 16) + pad(formatTrigger(r), 22) + pad(enabled, 10) + pad(maxLabel, 8) + chalk13.dim(r.created_at.toISOString().slice(0, 10))
+      );
+    }
+    console.log("");
+  } finally {
+    await closeStore(store);
+  }
+}
+async function schedulesEnableCommand(id) {
+  const store = resolveStore2();
+  try {
+    const record = await store.get(id);
+    if (!record) {
+      console.error(chalk13.red('Schedule "' + id + '" not found.'));
+      process.exit(1);
+    }
+    await store.setEnabled(id, true);
+    console.log(chalk13.green('Schedule "' + id + '" enabled.'));
+  } finally {
+    await closeStore(store);
+  }
+}
+async function schedulesDisableCommand(id) {
+  const store = resolveStore2();
+  try {
+    const record = await store.get(id);
+    if (!record) {
+      console.error(chalk13.red('Schedule "' + id + '" not found.'));
+      process.exit(1);
+    }
+    await store.setEnabled(id, false);
+    console.log(chalk13.yellow('Schedule "' + id + '" disabled.'));
+  } finally {
+    await closeStore(store);
+  }
+}
+async function schedulesTriggerCommand(id, scorePath) {
+  const file = resolve13(scorePath ?? "./tutti.score.ts");
+  if (!existsSync13(file)) {
+    console.error(chalk13.red("Score file not found: " + file));
+    process.exit(1);
+  }
+  const score = await ScoreLoader9.load(file);
+  const events = new EventBus2();
+  const sessions = new InMemorySessionStore4();
+  const runner = new AgentRunner2(score.provider, events, sessions);
+  const store = resolveStore2();
+  try {
+    const record = await store.get(id);
+    if (!record) {
+      console.error(chalk13.red('Schedule "' + id + '" not found.'));
+      process.exit(1);
+    }
+    const agent = score.agents[record.agent_id];
+    if (!agent) {
+      console.error(chalk13.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(chalk13.cyan('Triggering "' + id + '" (' + record.agent_id + ")..."));
+    const run2 = await engine.trigger(id);
+    engine.stop();
+    if (run2.error) {
+      console.log(chalk13.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(chalk13.green("  Completed in " + duration + "ms"));
+    if (run2.result) {
+      const preview = run2.result.length > 200 ? run2.result.slice(0, 200) + "..." : run2.result;
+      console.log(chalk13.dim("  Output: " + preview));
+    }
+  } finally {
+    await closeStore(store);
+  }
+}
+async function schedulesRunsCommand(id) {
+  const store = resolveStore2();
+  try {
+    const record = await store.get(id);
+    if (!record) {
+      console.error(chalk13.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(chalk13.dim("No runs recorded for this schedule."));
+        return;
+      }
+      const recent = runs.slice(-20);
+      console.log("");
+      console.log(chalk13.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 ? chalk13.red("error") : chalk13.green("ok");
+        const preview = run2.error ? run2.error.slice(0, 80) : (run2.result ?? "").slice(0, 80);
+        console.log(
+          "  " + chalk13.dim(run2.triggered_at.toISOString()) + "  " + status + "  " + chalk13.dim(duration) + "  " + preview
+        );
+      }
+      console.log("");
+    } else {
+      console.log(chalk13.dim('Schedule "' + id + '" has completed ' + record.run_count + " runs."));
+      console.log(chalk13.dim("Full run history requires the MemoryScheduleStore or a future tutti_schedule_runs table."));
+    }
+  } finally {
+    await closeStore(store);
+  }
+}
+
 // src/index.ts
 config();
-var logger11 = createLogger11("tutti-cli");
+var logger14 = createLogger14("tutti-cli");
 process.on("unhandledRejection", (reason) => {
-  logger11.error({ error: reason instanceof Error ? reason.message : String(reason) }, "Unhandled rejection");
+  logger14.error({ error: reason instanceof Error ? reason.message : String(reason) }, "Unhandled rejection");
   process.exit(1);
 });
 process.on("uncaughtException", (err) => {
-  logger11.error({ error: err.message }, "Fatal error");
+  logger14.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.11.1");
+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);
 });
@@ -1933,5 +2511,27 @@ 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("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);
+});
+var schedulesCmd = program.command("schedules").description("Manage scheduled agents");
+schedulesCmd.command("list").description("Show all registered schedules").action(async () => {
+  await schedulesListCommand();
+});
+schedulesCmd.command("enable <id>").description("Enable a disabled schedule").action(async (id) => {
+  await schedulesEnableCommand(id);
+});
+schedulesCmd.command("disable <id>").description("Disable a schedule without deleting it").action(async (id) => {
+  await schedulesDisableCommand(id);
+});
+schedulesCmd.command("trigger <id>").description("Manually trigger a scheduled run immediately").option("-s, --score <path>", "Path to score file (default: ./tutti.score.ts)").action(async (id, opts) => {
+  await schedulesTriggerCommand(id, opts.score);
+});
+schedulesCmd.command("runs <id>").description("Show run history for a schedule (last 20 runs)").action(async (id) => {
+  await schedulesRunsCommand(id);
+});
 program.parse();
 //# sourceMappingURL=index.js.map