@poncho-ai/cli 0.8.2 → 0.8.3

package/dist/run-interactive-ink-XEK5ZPSU.js

@@ -0,0 +1,535 @@
+import {
+  consumeFirstRunIntro,
+  inferConversationTitle,
+  resolveHarnessEnvironment
+} from "./chunk-74HD63WM.js";
+
+// src/run-interactive-ink.ts
+import * as readline from "readline";
+import { stdout } from "process";
+import {
+  parseAgentFile
+} from "@poncho-ai/harness";
+var C = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  cyan: "\x1B[36m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m",
+  gray: "\x1B[90m",
+  magenta: "\x1B[35m"
+};
+var green = (s) => `${C.green}${s}${C.reset}`;
+var yellow = (s) => `${C.yellow}${s}${C.reset}`;
+var red = (s) => `${C.red}${s}${C.reset}`;
+var gray = (s) => `${C.gray}${s}${C.reset}`;
+var magenta = (s) => `${C.magenta}${s}${C.reset}`;
+var FAUX_TOOL_LOG_PATTERN = /Tool Used:|Tool Result:|\blist_skills\b|\bcreate_skill\b|\bedit_skill\b/i;
+var formatDuration = (ms) => ms < 1e3 ? `${ms}ms` : `${(ms / 1e3).toFixed(1)}s`;
+var stringifyValue = (v) => {
+  try {
+    return JSON.stringify(v);
+  } catch {
+    return String(v);
+  }
+};
+var truncate = (v, max) => v.length <= max ? v : `${v.slice(0, Math.max(0, max - 3))}...`;
+var compactPreview = (v, max = 120) => truncate(stringifyValue(v).replace(/\s+/g, " "), max);
+var loadMetadata = async (workingDir) => {
+  let agentName = "agent";
+  let model = "unknown";
+  let provider = "unknown";
+  try {
+    const parsed = await parseAgentFile(workingDir);
+    agentName = parsed.frontmatter.name ?? agentName;
+    model = parsed.frontmatter.model?.name ?? model;
+    provider = parsed.frontmatter.model?.provider ?? provider;
+  } catch {
+  }
+  return {
+    agentName,
+    model,
+    provider,
+    workingDir,
+    environment: resolveHarnessEnvironment()
+  };
+};
+var ask = (rl, prompt) => new Promise((res) => {
+  rl.question(prompt, (answer) => res(answer));
+});
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var streamTextAsTokens = async (text) => {
+  const tokens = text.match(/\S+\s*|\n/g) ?? [text];
+  for (const token of tokens) {
+    stdout.write(token);
+    const trimmed = token.trim();
+    const delay = trimmed.length === 0 ? 0 : Math.max(4, Math.min(18, Math.floor(trimmed.length / 2)));
+    await sleep(delay);
+  }
+};
+var OWNER_ID = "local-owner";
+var computeTurn = (messages) => Math.max(1, Math.floor(messages.length / 2) + 1);
+var formatDate = (value) => {
+  try {
+    return new Date(value).toLocaleString();
+  } catch {
+    return String(value);
+  }
+};
+var handleSlash = async (command, state, conversationStore) => {
+  const [rawCommand, ...args] = command.trim().split(/\s+/);
+  const norm = rawCommand.toLowerCase();
+  if (norm === "/help") {
+    console.log(
+      gray(
+        "commands> /help /clear /exit /tools /list /open <id> /new [title] /delete [id] /continue /reset [all]"
+      )
+    );
+    return { shouldExit: false };
+  }
+  if (norm === "/clear") {
+    process.stdout.write("\x1B[2J\x1B[H");
+    return { shouldExit: false };
+  }
+  if (norm === "/exit") {
+    return { shouldExit: true };
+  }
+  if (norm === "/list") {
+    const conversations = await conversationStore.list(OWNER_ID);
+    if (conversations.length === 0) {
+      console.log(gray("conversations> none"));
+      return { shouldExit: false };
+    }
+    console.log(gray("conversations>"));
+    for (const conversation of conversations) {
+      const activeMarker = state.activeConversationId === conversation.conversationId ? "*" : " ";
+      const maxTitleLen = 40;
+      const title = conversation.title.length > maxTitleLen ? conversation.title.slice(0, maxTitleLen - 1) + "\u2026" : conversation.title;
+      console.log(
+        gray(
+          `${activeMarker} ${conversation.conversationId} | ${title} | ${formatDate(conversation.updatedAt)}`
+        )
+      );
+    }
+    return { shouldExit: false };
+  }
+  if (norm === "/open") {
+    const conversationId = args[0];
+    if (!conversationId) {
+      console.log(yellow("usage> /open <conversationId>"));
+      return { shouldExit: false };
+    }
+    const conversation = await conversationStore.get(conversationId);
+    if (!conversation) {
+      console.log(yellow(`conversations> not found: ${conversationId}`));
+      return { shouldExit: false };
+    }
+    state.activeConversationId = conversation.conversationId;
+    state.messages = [...conversation.messages];
+    state.turn = computeTurn(state.messages);
+    console.log(gray(`conversations> opened ${conversation.conversationId}`));
+    return { shouldExit: false };
+  }
+  if (norm === "/new") {
+    const title = args.join(" ").trim();
+    const conversation = await conversationStore.create(OWNER_ID, title || void 0);
+    state.activeConversationId = conversation.conversationId;
+    state.messages = [];
+    state.turn = 1;
+    console.log(gray(`conversations> new ${conversation.conversationId}`));
+    return { shouldExit: false };
+  }
+  if (norm === "/delete") {
+    const targetConversationId = args[0] ?? state.activeConversationId ?? "";
+    if (!targetConversationId) {
+      console.log(yellow("usage> /delete <conversationId>"));
+      return { shouldExit: false };
+    }
+    const removed = await conversationStore.delete(targetConversationId);
+    if (!removed) {
+      console.log(yellow(`conversations> not found: ${targetConversationId}`));
+      return { shouldExit: false };
+    }
+    if (state.activeConversationId === targetConversationId) {
+      state.activeConversationId = null;
+      state.messages = [];
+      state.turn = 1;
+    }
+    console.log(gray(`conversations> deleted ${targetConversationId}`));
+    return { shouldExit: false };
+  }
+  if (norm === "/continue") {
+    const conversations = await conversationStore.list(OWNER_ID);
+    const latest = conversations[0];
+    if (!latest) {
+      console.log(yellow("conversations> no conversations to continue"));
+      return { shouldExit: false };
+    }
+    state.activeConversationId = latest.conversationId;
+    state.messages = [...latest.messages];
+    state.turn = computeTurn(state.messages);
+    console.log(gray(`conversations> continued ${latest.conversationId}`));
+    return { shouldExit: false };
+  }
+  if (norm === "/reset") {
+    if (args[0]?.toLowerCase() === "all") {
+      const conversations = await conversationStore.list(OWNER_ID);
+      for (const conversation2 of conversations) {
+        await conversationStore.delete(conversation2.conversationId);
+      }
+      state.activeConversationId = null;
+      state.messages = [];
+      state.turn = 1;
+      console.log(gray("conversations> reset all"));
+      return { shouldExit: false };
+    }
+    if (!state.activeConversationId) {
+      state.messages = [];
+      state.turn = 1;
+      console.log(gray("conversations> current session reset"));
+      return { shouldExit: false };
+    }
+    const conversation = await conversationStore.get(state.activeConversationId);
+    if (!conversation) {
+      state.activeConversationId = null;
+      state.messages = [];
+      state.turn = 1;
+      console.log(yellow("conversations> active conversation no longer exists"));
+      return { shouldExit: false };
+    }
+    await conversationStore.update({
+      ...conversation,
+      messages: []
+    });
+    state.messages = [];
+    state.turn = 1;
+    console.log(gray(`conversations> reset ${conversation.conversationId}`));
+    return { shouldExit: false };
+  }
+  console.log(yellow(`Unknown command: ${command}`));
+  return { shouldExit: false };
+};
+var runInteractiveInk = async ({
+  harness,
+  params,
+  workingDir,
+  config,
+  conversationStore,
+  onSetApprovalCallback
+}) => {
+  const metadata = await loadMetadata(workingDir);
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: true
+  });
+  if (onSetApprovalCallback) {
+    onSetApprovalCallback((req) => {
+      process.stdout.write("\n");
+      const preview = compactPreview(req.input, 100);
+      rl.question(
+        `${C.yellow}${C.bold}Tool "${req.tool}" requires approval${C.reset}
+${C.gray}input: ${preview}${C.reset}
+${C.yellow}approve? (y/n): ${C.reset}`,
+        (answer) => {
+          const approved = answer.trim().toLowerCase() === "y";
+          console.log(
+            approved ? green(`  approved ${req.tool}`) : magenta(`  denied ${req.tool}`)
+          );
+          req.resolve(approved);
+        }
+      );
+    });
+  }
+  const mascot = [
+    `${C.yellow}      \u28C0\u28C0\u28C0\u28C0\u28C0\u28C0${C.reset}`,
+    `${C.yellow}    \u2820\u283E\u281B\u281B\u281B\u281B\u281B\u281B\u2837\u2804${C.reset}`,
+    `${C.gray}     \u2847${C.cyan} \u2836  \u2836 ${C.gray}\u28B8${C.reset}`,
+    `${C.gray}     \u2823\u2840${C.cyan}  \u2812\u281A${C.gray}\u2880\u281C${C.reset}`,
+    `${C.yellow}      \u28FF\u28FF\u28FF\u28FF\u28FF\u28FF${C.reset}`,
+    `${C.gray}       \u2803  \u2818${C.reset}`
+  ];
+  console.log("");
+  for (const line of mascot) {
+    console.log(line);
+  }
+  console.log(`${C.bold}${C.cyan}      poncho${C.reset}`);
+  console.log("");
+  console.log(
+    gray(
+      `  ${metadata.agentName} \xB7 ${metadata.provider}/${metadata.model} \xB7 ${metadata.environment}`
+    )
+  );
+  console.log(gray('  Type "exit" to quit, "/help" for commands'));
+  console.log(gray("  Press Ctrl+C during a run to stop streaming output."));
+  console.log(
+    gray("  Conversation controls: /list /open <id> /new [title] /delete [id] /continue /reset [all]\n")
+  );
+  const intro = await consumeFirstRunIntro(workingDir, {
+    agentName: metadata.agentName,
+    provider: metadata.provider,
+    model: metadata.model,
+    config
+  });
+  if (intro) {
+    console.log(green("assistant>"));
+    await streamTextAsTokens(intro);
+    stdout.write("\n\n");
+  }
+  let messages = intro ? [{ role: "assistant", content: intro }] : [];
+  let turn = 1;
+  let activeConversationId = null;
+  let showToolPayloads = false;
+  let activeRunAbortController = null;
+  rl.on("SIGINT", () => {
+    if (activeRunAbortController && !activeRunAbortController.signal.aborted) {
+      activeRunAbortController.abort();
+      process.stdout.write("\n");
+      console.log(gray("stop> cancelling current run..."));
+      return;
+    }
+    rl.close();
+  });
+  const prompt = `${C.cyan}you> ${C.reset}`;
+  while (true) {
+    let task;
+    try {
+      task = await ask(rl, prompt);
+    } catch {
+      break;
+    }
+    const trimmed = task.trim();
+    if (!trimmed) continue;
+    if (trimmed.toLowerCase() === "exit") break;
+    if (trimmed.startsWith("/")) {
+      if (trimmed.toLowerCase() === "/exit") break;
+      if (trimmed.toLowerCase() === "/tools") {
+        showToolPayloads = !showToolPayloads;
+        console.log(gray(`tool payloads: ${showToolPayloads ? "on" : "off"}`));
+        continue;
+      }
+      const interactiveState = {
+        messages,
+        turn,
+        activeConversationId
+      };
+      const slashResult = await handleSlash(
+        trimmed,
+        interactiveState,
+        conversationStore
+      );
+      if (slashResult.shouldExit) {
+        break;
+      }
+      messages = interactiveState.messages;
+      turn = interactiveState.turn;
+      activeConversationId = interactiveState.activeConversationId;
+      continue;
+    }
+    console.log(gray(`
+--- turn ${turn} ---`));
+    process.stdout.write(gray("thinking..."));
+    let thinkingCleared = false;
+    const clearThinking = () => {
+      if (thinkingCleared) return;
+      thinkingCleared = true;
+      readline.clearLine(process.stdout, 0);
+      readline.cursorTo(process.stdout, 0);
+    };
+    let responseText = "";
+    let streamedText = "";
+    let committedText = false;
+    let sawChunk = false;
+    let toolEvents = 0;
+    const toolTimeline = [];
+    const sections = [];
+    let currentText = "";
+    let currentTools = [];
+    let runFailed = false;
+    let runCancelled = false;
+    let usage;
+    let latestRunId = "";
+    const startedAt = Date.now();
+    activeRunAbortController = new AbortController();
+    try {
+      for await (const event of harness.run({
+        task: trimmed,
+        parameters: params,
+        messages,
+        abortSignal: activeRunAbortController.signal
+      })) {
+        if (event.type === "run:started") {
+          latestRunId = event.runId;
+        }
+        if (event.type === "model:chunk") {
+          sawChunk = true;
+          if (currentTools.length > 0) {
+            sections.push({ type: "tools", content: currentTools });
+            currentTools = [];
+          }
+          responseText += event.content;
+          streamedText += event.content;
+          currentText += event.content;
+          if (!thinkingCleared) {
+            clearThinking();
+            process.stdout.write(`${C.green}assistant> ${C.reset}`);
+          }
+          process.stdout.write(event.content);
+        } else if (event.type === "tool:started" || event.type === "tool:completed" || event.type === "tool:error" || event.type === "tool:approval:required" || event.type === "tool:approval:granted" || event.type === "tool:approval:denied") {
+          if (streamedText.length > 0) {
+            committedText = true;
+            streamedText = "";
+            process.stdout.write("\n");
+          }
+          clearThinking();
+          if (event.type === "tool:started") {
+            if (currentText.length > 0) {
+              sections.push({ type: "text", content: currentText });
+              currentText = "";
+            }
+            const preview = showToolPayloads ? compactPreview(event.input, 400) : compactPreview(event.input, 100);
+            console.log(yellow(`tools> start ${event.tool} input=${preview}`));
+            const toolText = `- start \`${event.tool}\``;
+            toolTimeline.push(toolText);
+            currentTools.push(toolText);
+            toolEvents += 1;
+          } else if (event.type === "tool:completed") {
+            const preview = showToolPayloads ? compactPreview(event.output, 400) : compactPreview(event.output, 100);
+            console.log(
+              yellow(
+                `tools> done  ${event.tool} in ${formatDuration(event.duration)}`
+              )
+            );
+            if (showToolPayloads) {
+              console.log(yellow(`tools> output ${preview}`));
+            }
+            const toolText = `- done \`${event.tool}\` in ${formatDuration(event.duration)}`;
+            toolTimeline.push(toolText);
+            currentTools.push(toolText);
+          } else if (event.type === "tool:error") {
+            console.log(
+              red(`tools> error ${event.tool}: ${event.error}`)
+            );
+            const toolText = `- error \`${event.tool}\`: ${event.error}`;
+            toolTimeline.push(toolText);
+            currentTools.push(toolText);
+          } else if (event.type === "tool:approval:required") {
+            console.log(
+              magenta(`tools> approval required for ${event.tool}`)
+            );
+            const toolText = `- approval required \`${event.tool}\``;
+            toolTimeline.push(toolText);
+            currentTools.push(toolText);
+          } else if (event.type === "tool:approval:granted") {
+            console.log(
+              gray(`tools> approval granted (${event.approvalId})`)
+            );
+            const toolText = `- approval granted (${event.approvalId})`;
+            toolTimeline.push(toolText);
+            currentTools.push(toolText);
+          } else if (event.type === "tool:approval:denied") {
+            console.log(
+              magenta(`tools> approval denied (${event.approvalId})`)
+            );
+            const toolText = `- approval denied (${event.approvalId})`;
+            toolTimeline.push(toolText);
+            currentTools.push(toolText);
+          }
+        } else if (event.type === "run:error") {
+          clearThinking();
+          runFailed = true;
+          console.log(red(`error> ${event.error.message}`));
+        } else if (event.type === "run:cancelled") {
+          clearThinking();
+          runCancelled = true;
+        } else if (event.type === "model:response") {
+          usage = event.usage;
+        } else if (event.type === "run:completed" && !sawChunk) {
+          clearThinking();
+          responseText = event.result.response ?? "";
+          if (responseText.length > 0) {
+            process.stdout.write(
+              `${C.green}assistant> ${C.reset}${responseText}
+`
+            );
+          }
+        }
+      }
+    } catch (error) {
+      clearThinking();
+      if (activeRunAbortController.signal.aborted) {
+        runCancelled = true;
+      } else {
+        runFailed = true;
+        console.log(
+          red(
+            `error> ${error instanceof Error ? error.message : "Unknown error"}`
+          )
+        );
+      }
+    } finally {
+      activeRunAbortController = null;
+    }
+    if (sawChunk && streamedText.length > 0) {
+      process.stdout.write("\n");
+    } else if (!sawChunk && !runFailed && !runCancelled && responseText.length === 0) {
+      clearThinking();
+      console.log(green("assistant> (no response)"));
+    }
+    const fullResponse = responseText || streamedText;
+    if (!runFailed && toolEvents === 0 && FAUX_TOOL_LOG_PATTERN.test(fullResponse)) {
+      console.log(
+        magenta(
+          "warning> assistant described tool execution but no real tool events occurred."
+        )
+      );
+    }
+    const durationMs = Date.now() - startedAt;
+    console.log(
+      gray(`meta> ${formatDuration(durationMs)} | tools: ${toolEvents}
+`)
+    );
+    if (!activeConversationId) {
+      const created = await conversationStore.create(
+        OWNER_ID,
+        inferConversationTitle(trimmed)
+      );
+      activeConversationId = created.conversationId;
+    }
+    if (currentTools.length > 0) {
+      sections.push({ type: "tools", content: currentTools });
+    }
+    if (currentText.length > 0) {
+      sections.push({ type: "text", content: currentText });
+    }
+    messages.push({ role: "user", content: trimmed });
+    const hasAssistantContent = responseText.length > 0 || toolTimeline.length > 0 || sections.length > 0;
+    if (hasAssistantContent) {
+      messages.push({
+        role: "assistant",
+        content: responseText,
+        metadata: toolTimeline.length > 0 || sections.length > 0 ? {
+          toolActivity: toolTimeline,
+          sections: sections.length > 0 ? sections : void 0
+        } : void 0
+      });
+    }
+    turn = computeTurn(messages);
+    const conversation = await conversationStore.get(activeConversationId);
+    if (conversation) {
+      const maybeTitle = conversation.messages.length === 0 && (conversation.title === "New conversation" || conversation.title.trim().length === 0) ? inferConversationTitle(trimmed) : conversation.title;
+      await conversationStore.update({
+        ...conversation,
+        title: maybeTitle,
+        messages: [...messages],
+        runtimeRunId: latestRunId || conversation.runtimeRunId
+      });
+    }
+  }
+  rl.close();
+};
+export {
+  runInteractiveInk
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poncho-ai/cli",
-  "version": "0.8.2",
+  "version": "0.8.3",
   "description": "CLI for building and deploying AI agents",
   "repository": {
     "type": "git",

package/src/index.ts

@@ -478,10 +478,14 @@ ${name}/
 ├── tests/
 │   └── basic.yaml     # Test suite
 └── skills/
-    └── starter/
+    ├── starter/
+    │   ├── SKILL.md
+    │   └── scripts/
+    │       └── starter-echo.ts
+    └── fetch-page/
         ├── SKILL.md
         └── scripts/
-            └── starter-echo.ts
+            └── fetch-page.ts
 \`\`\`
 
 ## Deployment
@@ -545,6 +549,69 @@ const SKILL_TOOL_TEMPLATE = `export default async function run(input) {
 }
 `;
 
+const FETCH_PAGE_SKILL_TEMPLATE = `---
+name: fetch-page
+description: Fetch a web page and return its text content
+allowed-tools:
+  - ./scripts/fetch-page.ts
+---
+
+# Fetch Page
+
+Fetches a URL and returns the page body as plain text (HTML tags stripped).
+
+## Usage
+
+Call \`run_skill_script\` with:
+- **skill**: \`fetch-page\`
+- **script**: \`./scripts/fetch-page.ts\`
+- **input**: \`{ "url": "https://example.com" }\`
+
+The script returns \`{ url, status, content }\` where \`content\` is the
+text-only body (capped at ~32 000 chars to stay context-friendly).
+`;
+
+const FETCH_PAGE_SCRIPT_TEMPLATE = `export default async function run(input) {
+  const url = typeof input?.url === "string" ? input.url.trim() : "";
+  if (!url) {
+    return { error: "A \\"url\\" string is required." };
+  }
+
+  const MAX_LENGTH = 32_000;
+
+  const response = await fetch(url, {
+    headers: { "User-Agent": "poncho-fetch-page/1.0" },
+    redirect: "follow",
+  });
+
+  if (!response.ok) {
+    return { url, status: response.status, error: response.statusText };
+  }
+
+  const html = await response.text();
+
+  // Lightweight HTML-to-text: strip tags, collapse whitespace.
+  const text = html
+    .replace(/<script[\\s\\S]*?<\\/script>/gi, "")
+    .replace(/<style[\\s\\S]*?<\\/style>/gi, "")
+    .replace(/<[^>]+>/g, " ")
+    .replace(/&nbsp;/gi, " ")
+    .replace(/&amp;/gi, "&")
+    .replace(/&lt;/gi, "<")
+    .replace(/&gt;/gi, ">")
+    .replace(/&quot;/gi, '"')
+    .replace(/&#39;/gi, "'")
+    .replace(/\\s+/g, " ")
+    .trim();
+
+  const content = text.length > MAX_LENGTH
+    ? text.slice(0, MAX_LENGTH) + "… (truncated)"
+    : text;
+
+  return { url, status: response.status, content };
+}
+`;
+
 const ensureFile = async (path: string, content: string): Promise<void> => {
   await mkdir(dirname(path), { recursive: true });
   await writeFile(path, content, { encoding: "utf8", flag: "wx" });
@@ -765,6 +832,8 @@ export const initProject = async (
     { path: "tests/basic.yaml", content: TEST_TEMPLATE },
     { path: "skills/starter/SKILL.md", content: SKILL_TEMPLATE },
     { path: "skills/starter/scripts/starter-echo.ts", content: SKILL_TOOL_TEMPLATE },
+    { path: "skills/fetch-page/SKILL.md", content: FETCH_PAGE_SKILL_TEMPLATE },
+    { path: "skills/fetch-page/scripts/fetch-page.ts", content: FETCH_PAGE_SCRIPT_TEMPLATE },
   ];
   if (onboarding.envFile) {
     scaffoldFiles.push({ path: ".env", content: onboarding.envFile });

package/src/run-interactive-ink.ts

@@ -354,15 +354,29 @@ export const runInteractiveInk = async ({
 
   // --- Print header ----------------------------------------------------------
 
+  const mascot = [
+    `${C.yellow}      ⣀⣀⣀⣀⣀⣀${C.reset}`,
+    `${C.yellow}    ⠠⠾⠛⠛⠛⠛⠛⠛⠷⠄${C.reset}`,
+    `${C.gray}     ⡇${C.cyan} ⠶  ⠶ ${C.gray}⢸${C.reset}`,
+    `${C.gray}     ⠣⡀${C.cyan}  ⠒⠚${C.gray}⢀⠜${C.reset}`,
+    `${C.yellow}      ⣿⣿⣿⣿⣿⣿${C.reset}`,
+    `${C.gray}       ⠃  ⠘${C.reset}`,
+  ];
+  console.log("");
+  for (const line of mascot) {
+    console.log(line);
+  }
+  console.log(`${C.bold}${C.cyan}      poncho${C.reset}`);
+  console.log("");
   console.log(
     gray(
-      `\n${metadata.agentName} | ${metadata.provider}/${metadata.model} | ${metadata.environment}`,
+      `  ${metadata.agentName} · ${metadata.provider}/${metadata.model} · ${metadata.environment}`,
     ),
   );
-  console.log(gray('Type "exit" to quit, "/help" for commands'));
-  console.log(gray("Press Ctrl+C during a run to stop streaming output."));
+  console.log(gray('  Type "exit" to quit, "/help" for commands'));
+  console.log(gray("  Press Ctrl+C during a run to stop streaming output."));
   console.log(
-    gray("Conversation controls: /list /open <id> /new [title] /delete [id] /continue /reset [all]\n"),
+    gray("  Conversation controls: /list /open <id> /new [title] /delete [id] /continue /reset [all]\n"),
   );
   const intro = await consumeFirstRunIntro(workingDir, {
     agentName: metadata.agentName,