@kimbho/kimbho-cli 0.1.18 → 0.1.20

package/dist/index.cjs

@@ -10612,7 +10612,7 @@ var {
 // package.json
 var package_default = {
   name: "@kimbho/kimbho-cli",
-  version: "0.1.18",
+  version: "0.1.20",
   description: "Kimbho CLI is a terminal-native coding agent for planning, execution, and verification.",
   type: "module",
   engines: {
@@ -16124,6 +16124,10 @@ async function loadCustomAgents(cwd) {
     ];
   });
 }
+async function loadCustomAgentById(cwd, id) {
+  const agents = await loadCustomAgents(cwd);
+  return agents.find((agent) => agent.id === id) ?? null;
+}
 async function loadAgentTeams(cwd) {
   const records = await loadMarkdownRecords(resolveAgentTeamDir(cwd));
   return records.map(({ filePath, source }) => {
@@ -16142,6 +16146,10 @@ async function loadAgentTeams(cwd) {
     };
   });
 }
+async function loadAgentTeamById(cwd, id) {
+  const teams = await loadAgentTeams(cwd);
+  return teams.find((team) => team.id === id) ?? null;
+}
 async function createCustomAgentFile(cwd, id, baseRole, options = {}) {
   const directory = resolveCustomAgentDir(cwd);
   const filePath = import_node_path5.default.join(directory, `${id}.md`);
@@ -16176,6 +16184,11 @@ async function createCustomAgentFile(cwd, id, baseRole, options = {}) {
 `, "utf8");
   return filePath;
 }
+async function deleteCustomAgentFile(cwd, id) {
+  const filePath = import_node_path5.default.join(resolveCustomAgentDir(cwd), `${id}.md`);
+  await (0, import_promises5.rm)(filePath);
+  return filePath;
+}
 async function createAgentTeamFile(cwd, id, agentIds, label) {
   const directory = resolveAgentTeamDir(cwd);
   const filePath = import_node_path5.default.join(directory, `${id}.md`);
@@ -16199,6 +16212,11 @@ async function createAgentTeamFile(cwd, id, agentIds, label) {
 `, "utf8");
   return filePath;
 }
+async function deleteAgentTeamFile(cwd, id) {
+  const filePath = import_node_path5.default.join(resolveAgentTeamDir(cwd), `${id}.md`);
+  await (0, import_promises5.rm)(filePath);
+  return filePath;
+}
 function scoreCustomAgentMatch(definition, task, request) {
   if (definition.baseRole !== task.agentRole) {
     return -1;
@@ -18290,6 +18308,175 @@ var KNOWN_SCAFFOLD_PRESETS = [
   "static-landing",
   "kimbho-cli-monorepo"
 ];
+function inferVisualAdjustment(goal) {
+  const normalized = goal.toLowerCase();
+  if (!normalized.includes("background") && !normalized.includes("gradient") && !normalized.includes("theme")) {
+    return null;
+  }
+  if (normalized.includes("green")) {
+    return {
+      summaryLabel: "green background",
+      background: "linear-gradient(180deg, #f4fff6 0%, #d8f3dc 100%)"
+    };
+  }
+  if (normalized.includes("amber") || normalized.includes("gold") || normalized.includes("orange")) {
+    return {
+      summaryLabel: "amber background",
+      background: "linear-gradient(180deg, #fff8e7 0%, #f7d08a 100%)"
+    };
+  }
+  if (normalized.includes("blue")) {
+    return {
+      summaryLabel: "blue background",
+      background: "linear-gradient(180deg, #eef6ff 0%, #cfe3ff 100%)"
+    };
+  }
+  if (normalized.includes("pink") || normalized.includes("rose")) {
+    return {
+      summaryLabel: "rose background",
+      background: "linear-gradient(180deg, #fff3f8 0%, #ffd6e7 100%)"
+    };
+  }
+  if (normalized.includes("purple") || normalized.includes("violet")) {
+    return {
+      summaryLabel: "violet background",
+      background: "linear-gradient(180deg, #f6f2ff 0%, #ddd1ff 100%)"
+    };
+  }
+  return null;
+}
+function looksLikeVisualAdjustmentGoal(value) {
+  return inferVisualAdjustment(value) !== null;
+}
+function inferSupplementalPages(goal, kind) {
+  const normalized = goal.toLowerCase();
+  const requestSignals = [
+    "add more pages",
+    "add pages",
+    "more pages",
+    "new pages",
+    "new page",
+    "additional pages",
+    "additional page"
+  ];
+  const requested = /* @__PURE__ */ new Set();
+  const specificPageSignals = [
+    ["about", "about"],
+    ["contact", "contact"],
+    ["archive", "archive"],
+    ["journal", "journal"],
+    ["stories", "stories"],
+    ["story", "story"],
+    ["menu", "menu"],
+    ["reservation", "reservations"],
+    ["reservations", "reservations"],
+    ["shop", "shop"],
+    ["services", "services"]
+  ];
+  for (const [signal, slug] of specificPageSignals) {
+    if (normalized.includes(signal)) {
+      requested.add(slug);
+    }
+  }
+  const isPageExpansionRequest = requested.size > 0 || requestSignals.some((signal) => normalized.includes(signal));
+  if (!isPageExpansionRequest) {
+    return null;
+  }
+  if (requested.size === 0) {
+    if (kind === "blog") {
+      requested.add("about");
+      requested.add("archive");
+      requested.add("contact");
+    } else if (kind === "restaurant") {
+      requested.add("menu");
+      requested.add("story");
+      requested.add("reservations");
+    } else if (kind === "storefront") {
+      requested.add("shop");
+      requested.add("story");
+      requested.add("contact");
+    } else {
+      requested.add("about");
+      requested.add("services");
+      requested.add("contact");
+    }
+  }
+  const copyBySlug = {
+    about: {
+      title: "About",
+      eyebrow: "Studio notes",
+      lede: "A calmer overview of the people, perspective, and intent behind the project.",
+      body: "Use this page to explain what the site stands for, who it is for, and why the work matters. Keep it human and specific."
+    },
+    contact: {
+      title: "Contact",
+      eyebrow: "Get in touch",
+      lede: "A simple route for collaborations, questions, bookings, or thoughtful replies.",
+      body: "Replace this copy with the right contact method, social links, newsletter details, or inquiry instructions."
+    },
+    archive: {
+      title: "Archive",
+      eyebrow: "Browse the back catalog",
+      lede: "A clean index for essays, notes, dispatches, and the posts worth resurfacing.",
+      body: "Turn this into a chronological archive, tag explorer, or featured reading list as the site grows."
+    },
+    journal: {
+      title: "Journal",
+      eyebrow: "Field notes",
+      lede: "A lighter-weight stream for updates, drafts, studio notes, and ongoing experiments.",
+      body: "Use this page for smaller entries that do not need the weight of longform essays."
+    },
+    stories: {
+      title: "Stories",
+      eyebrow: "Featured writing",
+      lede: "A front door for standout essays, case studies, or narrative pieces.",
+      body: "Pull your strongest writing forward here so visitors can quickly see the tone and quality of the work."
+    },
+    story: {
+      title: "Our Story",
+      eyebrow: "Behind the project",
+      lede: "A richer page for origin, process, values, and the details that build trust.",
+      body: "Tell the story behind the brand or studio in a way that feels personal instead of corporate."
+    },
+    menu: {
+      title: "Menu",
+      eyebrow: "Current offerings",
+      lede: "A dedicated place for featured dishes, seasonal highlights, and signature favorites.",
+      body: "Replace this with menu sections, tasting notes, pricing context, and dietary guidance."
+    },
+    reservations: {
+      title: "Reservations",
+      eyebrow: "Plan your visit",
+      lede: "A conversion-focused page for table bookings, group dining, and private events.",
+      body: "Use this space for booking links, service windows, cancellation policy, and special-event details."
+    },
+    shop: {
+      title: "Shop",
+      eyebrow: "Browse the collection",
+      lede: "A tighter landing point for products, drops, featured items, or curated collections.",
+      body: "Turn this into a product grid, collection overview, or conversion path into your checkout flow."
+    },
+    services: {
+      title: "Services",
+      eyebrow: "What we do",
+      lede: "A practical overview of offers, engagements, deliverables, and working style.",
+      body: "Use this page to clarify the services, retainers, or project formats you want visitors to understand."
+    }
+  };
+  return Array.from(requested).map((slug) => {
+    const resolved = copyBySlug[slug] ?? copyBySlug.about;
+    return {
+      slug,
+      title: resolved.title,
+      eyebrow: resolved.eyebrow,
+      lede: resolved.lede,
+      body: resolved.body
+    };
+  });
+}
+function looksLikePageExpansionGoal(value) {
+  return inferSupplementalPages(value, inferLandingKind(value)) !== null;
+}
 function looksLikeStaticLandingGoal(value) {
   const normalized = value.toLowerCase();
   const backendSignals = [
@@ -18348,6 +18535,12 @@ function looksLikeStaticLandingGoal(value) {
   if (normalized.includes("blog") && (normalized.includes("make") || normalized.includes("improve") || normalized.includes("enhance") || normalized.includes("redesign")) && !backendSignals.some((signal) => normalized.includes(signal))) {
     return true;
   }
+  if (looksLikeVisualAdjustmentGoal(normalized) && !backendSignals.some((signal) => normalized.includes(signal))) {
+    return true;
+  }
+  if (looksLikePageExpansionGoal(normalized) && !backendSignals.some((signal) => normalized.includes(signal))) {
+    return true;
+  }
   return false;
 }
 function sanitizeName(value) {
@@ -18550,6 +18743,195 @@ function renderNextLandingPage(title, content) {
 function renderPagesRouterLandingPage(title, content) {
   return renderNextLandingPage(title, content);
 }
+function renderNextSupplementalPage(siteTitle, page) {
+  return [
+    `const siteTitle = ${JSON.stringify(siteTitle)};`,
+    `const pageTitle = ${JSON.stringify(page.title)};`,
+    "",
+    "export default function SupplementalPage() {",
+    "  return (",
+    "    <main",
+    "      style={{",
+    "        minHeight: '100vh',",
+    "        background: 'linear-gradient(180deg, #fffaf2 0%, #f4ede2 100%)',",
+    "        color: '#1f1812',",
+    `        fontFamily: "Georgia, 'Times New Roman', serif"`,
+    "      }}",
+    "    >",
+    "      <section style={{ maxWidth: 920, margin: '0 auto', padding: '72px 20px 96px' }}>",
+    `        <p style={{ textTransform: 'uppercase', letterSpacing: '0.18em', fontSize: 12, color: '#9b5c34', margin: 0 }}>{${JSON.stringify(page.eyebrow)}}</p>`,
+    "        <h1 style={{ fontSize: 'clamp(2.8rem, 7vw, 4.8rem)', lineHeight: 0.95, margin: '16px 0 18px' }}>{pageTitle}</h1>",
+    `        <p style={{ maxWidth: 680, lineHeight: 1.7, fontSize: '1.08rem', color: '#46372d', margin: 0 }}>{${JSON.stringify(page.lede)}}</p>`,
+    "        <section",
+    "          style={{",
+    "            marginTop: 28,",
+    "            background: 'rgba(255,255,255,0.82)',",
+    "            border: '1px solid rgba(31,24,18,0.12)',",
+    "            borderRadius: 28,",
+    "            padding: 28,",
+    "            boxShadow: '0 18px 40px rgba(31,24,18,0.06)'",
+    "          }}",
+    "        >",
+    `          <p style={{ marginTop: 0, marginBottom: 0, lineHeight: 1.75, color: '#56453a' }}>{${JSON.stringify(page.body)}}</p>`,
+    "        </section>",
+    "        <div style={{ display: 'flex', gap: 12, flexWrap: 'wrap', marginTop: 28 }}>",
+    "          <a href='/' style={{ background: '#c96f3b', color: '#fff', padding: '14px 20px', borderRadius: 999, textDecoration: 'none', fontWeight: 700 }}>Back home</a>",
+    "          <span style={{ alignSelf: 'center', color: '#7b6659' }}>{siteTitle}</span>",
+    "        </div>",
+    "      </section>",
+    "    </main>",
+    "  );",
+    "}"
+  ].join("\n");
+}
+function renderStaticSupplementalPage(siteTitle, page) {
+  return [
+    "<!doctype html>",
+    '<html lang="en">',
+    "  <head>",
+    '    <meta charset="UTF-8" />',
+    '    <meta name="viewport" content="width=device-width, initial-scale=1.0" />',
+    `    <title>${page.title} | ${siteTitle}</title>`,
+    '    <link rel="stylesheet" href="./styles.css" />',
+    "  </head>",
+    "  <body>",
+    '    <main class="shell">',
+    '      <section class="hero">',
+    `        <p class="eyebrow">${page.eyebrow}</p>`,
+    `        <h1>${page.title}</h1>`,
+    `        <p class="lede">${page.lede}</p>`,
+    "      </section>",
+    '      <section class="story">',
+    `        <p>${page.body}</p>`,
+    "      </section>",
+    '      <div class="actions">',
+    '        <a href="./index.html" class="button primary">Back home</a>',
+    `        <a href="./index.html" class="button secondary">${siteTitle}</a>`,
+    "      </div>",
+    "    </main>",
+    "  </body>",
+    "</html>"
+  ].join("\n");
+}
+async function inferExistingSiteTitle(cwd, target, fallbackTitle) {
+  const source = await (0, import_promises10.readFile)(import_node_path10.default.join(cwd, target.pagePath), "utf8");
+  const constantMatch = source.match(/const\s+title\s*=\s*["'`](.+?)["'`]/);
+  if (constantMatch?.[1]) {
+    return constantMatch[1];
+  }
+  const headingMatch = source.match(/<h1[^>]*>\s*([^<]+?)\s*<\/h1>/);
+  if (headingMatch?.[1]) {
+    return headingMatch[1];
+  }
+  return fallbackTitle;
+}
+function insertNextPageLinks(source, pages) {
+  if (pages.every((page) => source.includes(`href='/${page.slug}'`) || source.includes(`href="/${page.slug}"`))) {
+    return source;
+  }
+  const block = [
+    "        <section style={{ marginTop: 26, display: 'grid', gridTemplateColumns: 'repeat(auto-fit, minmax(180px, 1fr))', gap: 14 }}>",
+    ...pages.map((page) => `          <a href='/${page.slug}' style={{ display: 'block', textDecoration: 'none', padding: '18px 20px', borderRadius: 22, background: 'rgba(255,255,255,0.82)', border: '1px solid rgba(31,24,18,0.1)', color: '#1f1812', boxShadow: '0 14px 32px rgba(31,24,18,0.05)' }}><strong>${page.title}</strong><br /><span style={{ color: '#6c5a4e' }}>Explore ${page.title.toLowerCase()}.</span></a>`),
+    "        </section>"
+  ].join("\n");
+  if (source.includes("</main>")) {
+    return source.replace(/(\s*)<\/main>/, `
+${block}
+$1</main>`);
+  }
+  return source;
+}
+function insertStaticPageLinks(source, pages) {
+  if (pages.every((page) => source.includes(`./${page.slug}.html`) || source.includes(`"${page.slug}.html"`))) {
+    return source;
+  }
+  const block = [
+    '      <section class="grid">',
+    ...pages.map((page) => `        <article class="card"><h2>${page.title}</h2><p>${page.lede}</p><a class="button secondary" href="./${page.slug}.html">Open ${page.title}</a></article>`),
+    "      </section>"
+  ].join("\n");
+  if (source.includes("</main>")) {
+    return source.replace(/(\s*)<\/main>/, `
+${block}
+$1</main>`);
+  }
+  return source;
+}
+async function applyExistingStaticPageExpansion(cwd, goal, target) {
+  const pages = inferSupplementalPages(goal, inferLandingKind(goal));
+  if (!pages) {
+    return null;
+  }
+  const projectName = inferProjectName(goal, cwd);
+  const siteTitle = await inferExistingSiteTitle(cwd, target, inferLandingTitle(goal, projectName));
+  const files = {};
+  const artifacts = [];
+  let createdPages = 0;
+  if (target.kind === "next-app") {
+    for (const page of pages) {
+      const relativePath = `src/app/${page.slug}/page.tsx`;
+      const absolutePath = import_node_path10.default.join(cwd, relativePath);
+      if (!await pathExists(absolutePath)) {
+        files[relativePath] = renderNextSupplementalPage(siteTitle, page);
+        createdPages += 1;
+      }
+      artifacts.push(absolutePath);
+    }
+    const currentSource = await (0, import_promises10.readFile)(import_node_path10.default.join(cwd, target.pagePath), "utf8");
+    const nextSource = insertNextPageLinks(currentSource, pages);
+    if (nextSource !== currentSource) {
+      files[target.pagePath] = nextSource;
+    }
+  } else if (target.kind === "next-pages") {
+    for (const page of pages) {
+      const relativePath = `src/pages/${page.slug}.tsx`;
+      const absolutePath = import_node_path10.default.join(cwd, relativePath);
+      if (!await pathExists(absolutePath)) {
+        files[relativePath] = renderNextSupplementalPage(siteTitle, page);
+        createdPages += 1;
+      }
+      artifacts.push(absolutePath);
+    }
+    const currentSource = await (0, import_promises10.readFile)(import_node_path10.default.join(cwd, target.pagePath), "utf8");
+    const nextSource = insertNextPageLinks(currentSource, pages);
+    if (nextSource !== currentSource) {
+      files[target.pagePath] = nextSource;
+    }
+  } else {
+    for (const page of pages) {
+      const relativePath = `${page.slug}.html`;
+      const absolutePath = import_node_path10.default.join(cwd, relativePath);
+      if (!await pathExists(absolutePath)) {
+        files[relativePath] = renderStaticSupplementalPage(siteTitle, page);
+        createdPages += 1;
+      }
+      artifacts.push(absolutePath);
+    }
+    const currentSource = await (0, import_promises10.readFile)(import_node_path10.default.join(cwd, target.pagePath), "utf8");
+    const nextSource = insertStaticPageLinks(currentSource, pages);
+    if (nextSource !== currentSource) {
+      files[target.pagePath] = nextSource;
+    }
+  }
+  const writtenArtifacts = Object.keys(files).length > 0 ? await writeFiles(cwd, files) : [];
+  if (createdPages === 0 && writtenArtifacts.length === 0) {
+    return {
+      preset: "static-landing",
+      projectName,
+      summary: `Confirmed the requested pages already exist: ${pages.map((page) => page.title).join(", ")}.`,
+      artifacts: artifacts.sort((left, right) => left.localeCompare(right))
+    };
+  }
+  return {
+    preset: "static-landing",
+    projectName,
+    summary: `Added ${createdPages > 0 ? createdPages : pages.length} supplemental page${(createdPages > 0 ? createdPages : pages.length) === 1 ? "" : "s"}: ${pages.map((page) => page.title).join(", ")}.`,
+    artifacts: Array.from(/* @__PURE__ */ new Set([
+      ...artifacts,
+      ...writtenArtifacts
+    ])).sort((left, right) => left.localeCompare(right))
+  };
+}
 async function detectExistingStaticTarget(cwd) {
   const nextAppPage = import_node_path10.default.join(cwd, "src/app/page.tsx");
   if (await pathExists(nextAppPage)) {
@@ -18575,7 +18957,80 @@ async function detectExistingStaticTarget(cwd) {
   }
   return null;
 }
+function rewriteBackgroundInSource(source, background) {
+  const inlinePatterns = [
+    [/background:\s*'[^']*'/, `background: '${background}'`],
+    [/background:\s*"[^"]*"/, `background: "${background}"`],
+    [/background:\s*`[^`]*`/, `background: \`${background}\``]
+  ];
+  for (const [pattern, replacement] of inlinePatterns) {
+    if (pattern.test(source)) {
+      return source.replace(pattern, replacement);
+    }
+  }
+  const cssPatterns = [
+    [/background:\s*[^;]+;/, `background: ${background};`],
+    [/background-color:\s*[^;]+;/, `background: ${background};`]
+  ];
+  for (const [pattern, replacement] of cssPatterns) {
+    if (pattern.test(source)) {
+      return source.replace(pattern, replacement);
+    }
+  }
+  return source;
+}
+async function applyExistingStaticVisualAdjustment(cwd, goal, target) {
+  const adjustment = inferVisualAdjustment(goal);
+  if (!adjustment) {
+    return null;
+  }
+  const candidatePaths = [
+    target.pagePath,
+    target.kind === "next-app" ? "src/app/globals.css" : null,
+    target.kind === "next-pages" ? "styles.css" : null,
+    target.kind === "static-html" ? "styles.css" : null
+  ].filter((value) => Boolean(value));
+  for (const relativePath of candidatePaths) {
+    const absolutePath = import_node_path10.default.join(cwd, relativePath);
+    if (!await pathExists(absolutePath)) {
+      continue;
+    }
+    const currentSource = await (0, import_promises10.readFile)(absolutePath, "utf8");
+    if (currentSource.includes(adjustment.background)) {
+      return {
+        preset: "static-landing",
+        projectName: inferProjectName(goal, cwd),
+        summary: `${relativePath} already uses the requested ${adjustment.summaryLabel}.`,
+        artifacts: [
+          absolutePath
+        ]
+      };
+    }
+    const nextSource = rewriteBackgroundInSource(currentSource, adjustment.background);
+    if (nextSource === currentSource) {
+      continue;
+    }
+    const artifacts = await writeFiles(cwd, {
+      [relativePath]: nextSource
+    });
+    return {
+      preset: "static-landing",
+      projectName: inferProjectName(goal, cwd),
+      summary: `Updated ${relativePath} with a ${adjustment.summaryLabel}.`,
+      artifacts
+    };
+  }
+  return null;
+}
 async function adaptExistingStaticLanding(cwd, projectName, goal, target) {
+  const pageExpansionResult = await applyExistingStaticPageExpansion(cwd, goal, target);
+  if (pageExpansionResult) {
+    return pageExpansionResult;
+  }
+  const adjustedResult = await applyExistingStaticVisualAdjustment(cwd, goal, target);
+  if (adjustedResult) {
+    return adjustedResult;
+  }
   const title = inferLandingTitle(goal, projectName);
   const content = buildLandingContent(title, inferLandingKind(goal));
   const files = {};
@@ -19364,6 +19819,9 @@ function isVerificationShellCommand(command) {
   const normalized = command.trim().toLowerCase();
   return VERIFICATION_SHELL_PREFIXES.some((prefix) => normalized === prefix || normalized.startsWith(`${prefix} `));
 }
+function isLowRiskScaffoldRequest(input) {
+  return input.preset === "static-landing" && typeof input.goal === "string" && (looksLikeVisualAdjustmentGoal(input.goal) || looksLikePageExpansionGoal(input.goal));
+}
 function isDestructiveShellCommand(command) {
   return DESTRUCTIVE_SHELL_PATTERNS.some((pattern) => pattern.test(command));
 }
@@ -19432,8 +19890,9 @@ function enforceToolPolicy(toolId, input, descriptor, context) {
   const sandboxMode = context.sandboxMode ?? "workspace-write";
   const approvalMode = context.approvalMode ?? "manual";
   const command = typeof input.command === "string" ? input.command : "";
+  const isVerificationCommand2 = isVerificationShellCommand(command);
   if (sandboxMode === "read-only") {
-    if (toolId === "shell.exec" && (isReadOnlyShellCommand(command) || isVerificationShellCommand(command))) {
+    if ((toolId === "shell.exec" || toolId === "tests.run") && (isReadOnlyShellCommand(command) || isVerificationCommand2)) {
       return null;
     }
     if (descriptor.permission !== "safe") {
@@ -19445,7 +19904,10 @@ function enforceToolPolicy(toolId, input, descriptor, context) {
       return new ToolApprovalRequiredError(createApprovalRequest(toolId, input, descriptor, context, `Approval required for destructive shell command: ${command}`));
     }
   }
-  if (toolId === "shell.exec" && isVerificationShellCommand(command)) {
+  if ((toolId === "shell.exec" || toolId === "tests.run") && isVerificationCommand2) {
+    return null;
+  }
+  if (toolId === "scaffold.generate" && isLowRiskScaffoldRequest(input)) {
     return null;
   }
   if ((toolId === "file.write" || toolId === "file.patch") && sandboxMode === "workspace-write") {
@@ -27626,6 +28088,37 @@ var MCP_INVENTORY_TIMEOUT_MS = 8e3;
 function toMcpToolId(serverName, toolName) {
   return `mcp.${serverName}.${toolName}`;
 }
+function normalizeMcpCommandSegment(value) {
+  return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+}
+async function resolveMcpServerInventoryByReference(cwd, serverReference) {
+  const inventory = await loadMcpServerInventory(cwd);
+  const normalizedReference = normalizeMcpCommandSegment(serverReference);
+  const server = inventory.find((candidate) => candidate.name === serverReference || normalizeMcpCommandSegment(candidate.name) === normalizedReference);
+  if (!server) {
+    throw new Error(`MCP server ${serverReference} is not configured or did not respond.`);
+  }
+  if (server.warning) {
+    throw new Error(`MCP server ${server.name} is unavailable: ${server.warning}`);
+  }
+  return server;
+}
+async function resolveMcpPromptReference(cwd, serverReference, promptReference) {
+  const server = await resolveMcpServerInventoryByReference(cwd, serverReference);
+  const normalizedPromptReference = normalizeMcpCommandSegment(promptReference);
+  const prompt = server.prompts.find((candidate) => candidate.name === promptReference || normalizeMcpCommandSegment(candidate.name) === normalizedPromptReference);
+  if (!prompt) {
+    throw new Error(`MCP prompt ${promptReference} was not found on server ${server.name}.`);
+  }
+  return {
+    serverName: server.name,
+    promptName: prompt.name
+  };
+}
+async function resolveMcpServerName(cwd, serverReference) {
+  const server = await resolveMcpServerInventoryByReference(cwd, serverReference);
+  return server.name;
+}
 function permissionFromAnnotations(annotations) {
   if (annotations?.destructiveHint) {
     return "destructive";
@@ -27785,23 +28278,24 @@ async function discoverMcpTools(cwd) {
 }
 async function callMcpTool(cwd, serverName, toolName, input) {
   const config2 = await loadMcpConfig(cwd);
-  const server = config2.mcpServers[serverName];
+  const resolvedServerName = await resolveMcpServerName(cwd, serverName).catch(() => serverName);
+  const server = config2.mcpServers[resolvedServerName];
   if (!server || server.enabled === false) {
     return {
-      toolId: toMcpToolId(serverName, toolName),
+      toolId: toMcpToolId(resolvedServerName, toolName),
       success: false,
-      summary: `MCP server ${serverName} is not configured or is disabled.`,
+      summary: `MCP server ${resolvedServerName} is not configured or is disabled.`,
       artifacts: []
     };
   }
-  const result = await withMcpClient(cwd, serverName, server, async (client) => client.callTool({
+  const result = await withMcpClient(cwd, resolvedServerName, server, async (client) => client.callTool({
     name: toolName,
     arguments: Object.fromEntries(Object.entries(input).filter(([, value]) => value !== void 0))
   }));
   return {
-    toolId: toMcpToolId(serverName, toolName),
+    toolId: toMcpToolId(resolvedServerName, toolName),
     success: !result.isError,
-    summary: result.isError ? `MCP tool ${serverName}/${toolName} reported an error.` : `Ran MCP tool ${serverName}/${toolName}.`,
+    summary: result.isError ? `MCP tool ${resolvedServerName}/${toolName} reported an error.` : `Ran MCP tool ${resolvedServerName}/${toolName}.`,
     stdout: renderMcpContent(result),
     artifacts: []
   };
@@ -27823,18 +28317,19 @@ ${"text" in resource ? resource.text : `[binary ${resource.mimeType ?? "resource
   }).join("\n\n");
 }
 async function invokeMcpPrompt(cwd, serverName, promptName, args) {
+  const { serverName: resolvedServerName, promptName: resolvedPromptName } = await resolveMcpPromptReference(cwd, serverName, promptName);
   const config2 = await loadMcpConfig(cwd);
-  const server = config2.mcpServers[serverName];
+  const server = config2.mcpServers[resolvedServerName];
   if (!server || server.enabled === false) {
-    throw new Error(`MCP server ${serverName} is not configured or is disabled.`);
+    throw new Error(`MCP server ${resolvedServerName} is not configured or is disabled.`);
   }
-  const result = await withMcpClient(cwd, serverName, server, async (client) => client.getPrompt({
-    name: promptName,
+  const result = await withMcpClient(cwd, resolvedServerName, server, async (client) => client.getPrompt({
+    name: resolvedPromptName,
     arguments: args
   }));
   return {
-    serverName,
-    promptName,
+    serverName: resolvedServerName,
+    promptName: resolvedPromptName,
     ...result.description ? {
       description: result.description
     } : {},
@@ -27842,19 +28337,20 @@ async function invokeMcpPrompt(cwd, serverName, promptName, args) {
   };
 }
 async function readMcpResource(cwd, serverName, uri) {
+  const resolvedServerName = await resolveMcpServerName(cwd, serverName);
   const config2 = await loadMcpConfig(cwd);
-  const server = config2.mcpServers[serverName];
+  const server = config2.mcpServers[resolvedServerName];
   if (!server || server.enabled === false) {
-    throw new Error(`MCP server ${serverName} is not configured or is disabled.`);
+    throw new Error(`MCP server ${resolvedServerName} is not configured or is disabled.`);
   }
-  const result = await withMcpClient(cwd, serverName, server, async (client) => client.readResource({
+  const result = await withMcpClient(cwd, resolvedServerName, server, async (client) => client.readResource({
     uri
   }));
   const content = result.contents.map((item) => "text" in item ? `resource: ${item.uri}
 ${item.text}` : `resource: ${item.uri}
 [binary ${item.mimeType ?? "resource"}]`).join("\n\n");
   return {
-    serverName,
+    serverName: resolvedServerName,
     uri,
     content
   };
@@ -29177,6 +29673,109 @@ var import_node_path14 = __toESM(require("node:path"), 1);
 function normalizeGoal(goal) {
   return goal.trim().replace(/\s+/g, " ");
 }
+function looksLikeVisualAdjustmentGoal2(goal) {
+  const lower = goal.toLowerCase();
+  const backendSignals = [
+    "api",
+    "database",
+    "backend",
+    "server",
+    "migration",
+    "schema",
+    "prisma",
+    "postgres",
+    "sqlite",
+    "auth",
+    "billing",
+    "webhook"
+  ];
+  const editSignals = [
+    "make",
+    "change",
+    "update",
+    "turn",
+    "switch",
+    "set",
+    "use",
+    "refresh",
+    "restyle",
+    "redesign"
+  ];
+  const visualSignals = [
+    "background",
+    "color",
+    "green",
+    "amber",
+    "blue",
+    "pink",
+    "purple",
+    "gradient",
+    "theme",
+    "palette",
+    "styling",
+    "style",
+    "look",
+    "visual",
+    "hero"
+  ];
+  const pageContextSignals = [
+    "page",
+    "landing",
+    "lnding",
+    "homepage",
+    "home page",
+    "site",
+    "website",
+    "blog"
+  ];
+  if (backendSignals.some((signal) => lower.includes(signal))) {
+    return false;
+  }
+  return editSignals.some((signal) => lower.includes(signal)) && visualSignals.some((signal) => lower.includes(signal)) && (pageContextSignals.some((signal) => lower.includes(signal)) || lower.includes("background"));
+}
+function looksLikePageExpansionGoal2(goal) {
+  const lower = goal.toLowerCase();
+  const backendSignals = [
+    "api",
+    "database",
+    "backend",
+    "server",
+    "migration",
+    "schema",
+    "prisma",
+    "postgres",
+    "sqlite",
+    "auth",
+    "billing",
+    "webhook"
+  ];
+  const directSignals = [
+    "add more pages",
+    "add pages",
+    "more pages",
+    "new pages",
+    "new page",
+    "additional pages",
+    "additional page"
+  ];
+  const namedPages = [
+    "about",
+    "contact",
+    "archive",
+    "journal",
+    "stories",
+    "story",
+    "menu",
+    "reservation",
+    "reservations",
+    "shop",
+    "services"
+  ];
+  if (backendSignals.some((signal) => lower.includes(signal))) {
+    return false;
+  }
+  return directSignals.some((signal) => lower.includes(signal)) || (lower.includes("add") || lower.includes("create") || lower.includes("make")) && lower.includes("page") && namedPages.some((name) => lower.includes(name));
+}
 function looksLikeStaticSiteGoal(goal) {
   const lower = goal.toLowerCase();
   const backendSignals = [
@@ -29235,6 +29834,12 @@ function looksLikeStaticSiteGoal(goal) {
   if (lower.includes("blog") && (lower.includes("make") || lower.includes("improve") || lower.includes("enhance") || lower.includes("redesign")) && !backendSignals.some((signal) => lower.includes(signal))) {
     return true;
   }
+  if (looksLikeVisualAdjustmentGoal2(lower)) {
+    return true;
+  }
+  if (looksLikePageExpansionGoal2(lower)) {
+    return true;
+  }
   return false;
 }
 function inferProjectShape(goal) {
@@ -31151,7 +31756,10 @@ function isStaticSiteTask(task, request) {
   }
   return task.filesLikelyTouched.some((filePath) => filePath === "src/app/page.tsx" || filePath === "src/app/layout.tsx" || filePath === "src/pages/index.tsx" || filePath === "index.html" || filePath === "styles.css");
 }
-function shouldDelegateTask(task) {
+function shouldDelegateTask(task, request) {
+  if ((looksLikeVisualAdjustmentGoal(request.goal) || looksLikePageExpansionGoal(request.goal)) && isStaticSiteTask(task, request)) {
+    return false;
+  }
   return (task.swarmDepth ?? 0) === 0 && task.type === "implementation" && ![
     "repo-analyst",
     "planner",
@@ -31168,7 +31776,7 @@ function terminalExpansionTaskIds(tasks) {
   return terminalIds.length > 0 ? terminalIds : tasks.map((task) => task.id);
 }
 function createDefaultDelegationPlan(task, request) {
-  if (!shouldDelegateTask(task)) {
+  if (!shouldDelegateTask(task, request)) {
     return null;
   }
   if (task.agentRole === "frontend-specialist" || isStaticSiteTask(task, request)) {
@@ -31317,6 +31925,53 @@ function createDefaultDelegationPlan(task, request) {
   }
   return null;
 }
+async function detectAppliedVisualAdjustment(cwd, request) {
+  const adjustment = inferVisualAdjustment(request.goal);
+  if (!adjustment) {
+    return null;
+  }
+  const candidates = [
+    "src/app/page.tsx",
+    "src/pages/index.tsx",
+    "src/app/globals.css",
+    "styles.css",
+    "index.html"
+  ];
+  for (const relativePath of candidates) {
+    const absolutePath = import_node_path14.default.join(cwd, relativePath);
+    try {
+      await (0, import_promises14.access)(absolutePath);
+      const contents = await (0, import_promises14.readFile)(absolutePath, "utf8");
+      if (contents.includes(adjustment.background)) {
+        return absolutePath;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+async function detectPreferredVerificationCommand(cwd) {
+  const packagePath = import_node_path14.default.join(cwd, "package.json");
+  try {
+    await (0, import_promises14.access)(packagePath);
+    const raw = await (0, import_promises14.readFile)(packagePath, "utf8");
+    const parsed = JSON.parse(raw);
+    const scripts = parsed.scripts ?? {};
+    const packageManager = parsed.packageManager?.startsWith("pnpm") ? "pnpm" : parsed.packageManager?.startsWith("yarn") ? "yarn" : "npm";
+    if (scripts.build) {
+      return packageManager === "yarn" ? "yarn build" : `${packageManager} run build`;
+    }
+    if (scripts.lint) {
+      return packageManager === "yarn" ? "yarn lint" : `${packageManager} run lint`;
+    }
+    if (scripts.test) {
+      return packageManager === "yarn" ? "yarn test" : `${packageManager} run test`;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
 function materializeDelegatedTasks(plan, task, label, strategy, members) {
   const existingIds = new Set(flattenPlanTasks(plan).filter((candidate) => candidate.id !== task.id).map((candidate) => candidate.id));
   const teamMemberIds = members.map((member) => member.id);
@@ -31952,6 +32607,9 @@ var ExecutionOrchestrator = class {
     if (request.workspaceState === "existing" && isStaticSiteTask(task, request) && (task.type === "scaffold" || task.type === "implementation")) {
       return this.executeDeterministicStaticSiteTask(sessionId, task, request, resolvedApproval, options, emitProgress);
     }
+    if (request.workspaceState === "existing" && looksLikeStaticLandingGoal(request.goal) && task.type === "verification") {
+      return this.executeDeterministicVerificationTask(sessionId, task, request, emitProgress, options.signal);
+    }
     if (task.type === "scaffold") {
       return this.executeScaffoldTask(sessionId, task, request, plan, resolvedApproval, options, emitProgress);
     }
@@ -32086,7 +32744,69 @@ var ExecutionOrchestrator = class {
       ]))
     };
   }
+  async executeDeterministicVerificationTask(sessionId, task, request, emitProgress, signal) {
+    const command = await detectPreferredVerificationCommand(request.cwd);
+    if (!command) {
+      return {
+        status: "completed",
+        summary: "No build, lint, or test script was found; verification was recorded as not applicable.",
+        toolResults: [],
+        artifacts: []
+      };
+    }
+    const input = {
+      command
+    };
+    if (emitProgress) {
+      await emitProgress({
+        type: "tool-started",
+        sessionId,
+        taskId: task.id,
+        agentRole: task.agentRole,
+        toolId: "tests.run",
+        input
+      });
+    }
+    const result = await this.safeRunTool("tests.run", input, {
+      cwd: request.cwd,
+      taskId: task.id,
+      agentRole: task.agentRole,
+      ...signal ? {
+        signal
+      } : {}
+    });
+    if (emitProgress) {
+      await emitProgress({
+        type: "tool-finished",
+        sessionId,
+        taskId: task.id,
+        agentRole: task.agentRole,
+        toolResult: result
+      });
+    }
+    return {
+      status: result.success ? "completed" : "blocked",
+      summary: result.success ? `Verification passed via ${command}.` : `Verification failed via ${command}.`,
+      toolResults: [
+        result
+      ],
+      artifacts: result.artifacts
+    };
+  }
   async executeDeterministicStaticSiteTask(sessionId, task, request, resolvedApproval, options, emitProgress) {
+    if (looksLikeVisualAdjustmentGoal(request.goal)) {
+      const appliedArtifact = await detectAppliedVisualAdjustment(request.cwd, request);
+      if (appliedArtifact) {
+        return {
+          status: "completed",
+          summary: `Confirmed the requested visual adjustment in ${import_node_path14.default.relative(request.cwd, appliedArtifact) || appliedArtifact}.`,
+          toolResults: [],
+          artifacts: [
+            appliedArtifact
+          ]
+        };
+      }
+    }
     const config2 = await loadConfig(request.cwd);
     const scaffoldInput = {
       goal: request.goal,
@@ -32482,7 +33202,7 @@ var ExecutionOrchestrator = class {
   }
   async maybeExpandReadyTaskGraph(sessionId, request, plan, events, emitProgress) {
     const envelope = this.buildEnvelope(request, plan, sessionId);
-    const candidate = envelope.readyTasks.find((task) => shouldDelegateTask(task));
+    const candidate = envelope.readyTasks.find((task) => shouldDelegateTask(task, request));
     if (!candidate) {
       return {
         plan
@@ -32703,10 +33423,69 @@ function createAgentsCommand() {
     });
     console.log(`Created ${outputPath}`);
   });
+  command.command("show").description("Show one custom agent or team.").argument("<id>", "Agent or team id").option("--team", "Show a team instead of an agent", false).action(async (id, options) => {
+    if (options.team) {
+      const team = await loadAgentTeamById(process.cwd(), id);
+      if (!team) {
+        throw new Error(`Unknown team "${id}".`);
+      }
+      console.log(team.id);
+      console.log(`  label: ${team.label}`);
+      console.log(`  agents: ${team.agents.join(", ") || "-"}`);
+      console.log(`  match: ${team.match.join(", ") || "-"}`);
+      console.log(`  strategy: ${team.strategy}`);
+      console.log(`  file: ${team.filePath}`);
+      if (team.description) {
+        console.log("");
+        console.log(team.description);
+      }
+      return;
+    }
+    const agent = await loadCustomAgentById(process.cwd(), id);
+    if (!agent) {
+      throw new Error(`Unknown custom agent "${id}".`);
+    }
+    console.log(agent.id);
+    console.log(`  label: ${agent.label}`);
+    console.log(`  baseRole: ${agent.baseRole}`);
+    console.log(`  brainRole: ${agent.brainRole ?? "-"}`);
+    console.log(`  purpose: ${agent.purpose ?? "-"}`);
+    console.log(`  match: ${agent.match.join(", ") || "-"}`);
+    console.log(`  tools: ${agent.tools.join(", ") || "(inherits base role tools)"}`);
+    console.log(`  file: ${agent.filePath}`);
+    if (agent.instructions.trim()) {
+      console.log("");
+      console.log(agent.instructions.trim());
+    }
+  });
+  command.command("delete").description("Delete a custom agent or team markdown file.").argument("<id>", "Agent or team id").option("--team", "Delete a team instead of an agent", false).action(async (id, options) => {
+    const outputPath = options.team ? await deleteAgentTeamFile(process.cwd(), id) : await deleteCustomAgentFile(process.cwd(), id);
+    console.log(`Deleted ${outputPath}`);
+  });
   command.command("team-create").description("Create a markdown-backed agent team definition.").argument("<id>", "Team id").argument("<agents...>", "Member agent ids").option("--label <label>", "Human-readable label").action(async (id, agents, options) => {
     const outputPath = await createAgentTeamFile(process.cwd(), id, agents, options.label);
     console.log(`Created ${outputPath}`);
   });
+  command.command("team-show").description("Show one markdown-backed team definition.").argument("<id>", "Team id").action(async (id) => {
+    const team = await loadAgentTeamById(process.cwd(), id);
+    if (!team) {
+      throw new Error(`Unknown team "${id}".`);
+    }
+    console.log(team.id);
+    console.log(`  label: ${team.label}`);
+    console.log(`  agents: ${team.agents.join(", ") || "-"}`);
+    console.log(`  match: ${team.match.join(", ") || "-"}`);
+    console.log(`  strategy: ${team.strategy}`);
+    console.log(`  file: ${team.filePath}`);
+    if (team.description) {
+      console.log("");
+      console.log(team.description);
+    }
+  });
+  command.command("team-delete").description("Delete one markdown-backed team definition.").argument("<id>", "Team id").action(async (id) => {
+    const outputPath = await deleteAgentTeamFile(process.cwd(), id);
+    console.log(`Deleted ${outputPath}`);
+  });
   return command;
 }
 
@@ -33523,7 +34302,7 @@ async function renderMcpInventory(cwd, name) {
     `  prompts: ${server.prompts.length}`,
     ...server.prompts.slice(0, 10).flatMap((prompt) => [
       `    - ${prompt.name}${prompt.arguments.length > 0 ? ` (${prompt.arguments.map((argument) => `${argument.name}${argument.required ? "*" : ""}`).join(", ")})` : ""}`,
-      `      command: /mcp__${server.name}__${prompt.name}`
+      `      command: /mcp__${normalizeMcpCommandSegment(server.name)}__${normalizeMcpCommandSegment(prompt.name)}`
     ]),
     `  resources: ${server.resources.length}`,
     ...server.resources.slice(0, 10).flatMap((resource) => [
@@ -33549,7 +34328,7 @@ async function renderMcpPromptList(cwd, name) {
     ] : [],
     ...server.prompts.length > 0 ? server.prompts.flatMap((prompt) => [
       `  - ${prompt.name}${prompt.arguments.length > 0 ? ` (${prompt.arguments.map((argument) => `${argument.name}${argument.required ? "*" : ""}`).join(", ")})` : ""}`,
-      `    command: /mcp__${server.name}__${prompt.name}`
+      `    command: /mcp__${normalizeMcpCommandSegment(server.name)}__${normalizeMcpCommandSegment(prompt.name)}`
     ]) : [
       "  - no prompts"
     ]
@@ -35490,53 +36269,65 @@ function renderBox(lines) {
 function renderHelp() {
   return [
     `${color(DIM, "Commands")}`,
-    "/status                  Show the active role, provider, and workspace state.",
-    "/ask <prompt>            Send a prompt to the active model without running the agent.",
-    "/chat <prompt>           Alias for /ask <prompt>.",
-    "/reset-chat              Clear the active model conversation history.",
-    "/model                   Show current model, provider, and role state.",
+    `${color(BOLD, "Core")}`,
+    "/status                  Show active model, workspace, approvals, and sandbox state.",
+    "/ask <prompt>            Chat with the focused model without running the agent.",
+    "/plan <goal>             Create a structured plan only.",
+    "/run <goal>              Execute a goal immediately.",
+    "/resume                  Continue the latest paused or awaiting-approval session.",
+    "/review                  Review the current git diff and summarize risk.",
+    "/clear                   Redraw the shell.",
+    "/quit, /exit             Leave the shell.",
+    "",
+    `${color(BOLD, "Model")}`,
+    "/model                   Show current provider/model state.",
     "/model providers         List configured providers.",
     "/model add <tpl> [id]    Add a provider template.",
     "/model use <provider> [model]  Switch provider/model for all roles.",
     "/model find [search]     Discover models for the active provider.",
-    "/model select <n>        Pick a model from the last numbered list.",
-    "/model focus <role>      Change shell focus to planner, coder, reviewer, or fast.",
-    "/permissions             Show approval, sandbox, and trusted directory settings.",
+    "/model select <n>        Pick from the last numbered model list.",
+    "/model focus <role>      Change focus to planner, coder, reviewer, or fast.",
+    "",
+    `${color(BOLD, "Permissions")}`,
+    "/permissions             Show layered approval, sandbox, and trust settings.",
     "/permissions auto|manual Change approval mode.",
     "/permissions sandbox <mode>  Set read-only, workspace-write, or full.",
     "/permissions trust <path>    Add a trusted directory.",
     "/permissions untrust <path>  Remove a trusted directory.",
-    "/memory                  Show project, user, and agent memory paths.",
-    "/memory refresh          Refresh kimbho_init.md and project memory.",
+    "/approve [id]            Approve a pending risky action and continue.",
+    "/approve-all             Approve every pending action in the current session.",
+    "/deny [id]               Deny a pending risky action.",
+    "",
+    `${color(BOLD, "Memory")}`,
+    "/init [--memory-only]    Build config and durable project understanding files.",
+    "/memory                  Show init/project/user/agent memory paths.",
+    "/memory refresh          Re-scan the project and refresh markdown memory.",
     "/memory show <scope>     Print init, project, user, or agent memory.",
-    "/memory add <scope> <text>  Append a markdown memory note.",
+    "/memory add <scope> ...  Append a markdown memory note.",
     "/config                  Show config, memory, and MCP file locations.",
+    "",
+    `${color(BOLD, "MCP")}`,
     "/mcp                     List configured MCP servers.",
+    "/mcp discover [server]   Show MCP tools, prompts-as-commands, and resources.",
+    "/mcp prompt <server> <prompt> [key=value ...]  Render one MCP prompt.",
+    "/mcp read <server> <uri> Read one MCP resource.",
     "/mcp add <name> --command <cmd> [--arg <value>] [--env KEY=VALUE]",
     "                         Add an MCP stdio server to .mcp.json.",
-    "/mcp tools [server]      Discover tools/prompts/resources from MCP servers.",
-    "/mcp prompts [server]    List MCP prompts.",
-    "/mcp resources [server]  List MCP resources and templates.",
-    "/mcp prompt <server> <prompt> [key=value ...]",
-    "                         Render an MCP prompt.",
-    "/mcp read <server> <uri> Read one MCP resource.",
+    "/mcp__server__prompt ... Invoke an MCP prompt directly from the shell.",
+    "@server:uri              Attach an MCP resource inside /ask, /plan, or /run prompts.",
+    "",
+    `${color(BOLD, "Agents")}`,
     "/agents                  List custom agents and teams.",
+    "/agents show <id>        Show one custom agent definition.",
+    "/agents delete <id>      Delete one custom agent definition.",
     "/agents create <id> --base <role>  Create a markdown custom agent.",
     "/agents team create <id> <agent...>  Create a markdown team file.",
-    "/init [--memory-only]    Create or refresh config and markdown memory files.",
-    "/plan <goal>             Create a structured implementation plan.",
-    "/run <goal>              Start a Kimbho execution session for a goal.",
-    "/resume                  Show the latest saved session.",
-    "/approve [id]            Approve a pending risky action and continue the session.",
-    "/approve-all             Approve all pending actions in the current session.",
-    "/deny [id]               Deny a pending risky action.",
-    "/review                  Review the current git diff and summarize risk.",
-    "/doctor                  Check local environment and config.",
-    "/clear                   Redraw the shell.",
-    "/quit, /exit             Leave the shell.",
+    "/agents team show <id>   Show one team definition.",
+    "/agents team delete <id> Delete one team definition.",
     "",
     `${color(DIM, "Tip")}`,
     "Type build/change requests directly to run the agent. Type plan/design prompts for planning. Use /ask when you want plain chat.",
+    "MCP prompts behave like slash commands, and MCP resources can be attached inline with @server:uri.",
     "Legacy aliases like /providers, /models, /select, /use-model, /brain, and /approval still work.",
     "Press Ctrl+C during an active run to pause it and return to the shell, then use /resume to continue."
   ].join("\n");
@@ -36769,7 +37560,7 @@ async function handleMcpCommand(cwd, tokens) {
     }
     return;
   }
-  if (subcommand === "tools" || subcommand === "inspect") {
+  if (subcommand === "tools" || subcommand === "inspect" || subcommand === "discover") {
     const name = tokens[2]?.trim();
     for (const line of await renderMcpInventory(cwd, name)) {
       console.log(line);
@@ -36805,10 +37596,12 @@ async function handleMcpCommand(cwd, tokens) {
     return;
   }
   if (subcommand === "read") {
-    const serverName = tokens[2]?.trim();
-    const uri = tokens.slice(3).join(" ").trim();
+    const shorthand = tokens[2]?.trim();
+    const shorthandMatch = shorthand?.match(/^@([^:\s]+):(.+)$/);
+    const serverName = shorthandMatch ? shorthandMatch[1] : tokens[2]?.trim();
+    const uri = shorthandMatch ? shorthandMatch[2] : tokens.slice(3).join(" ").trim();
     if (!serverName || !uri) {
-      throw new Error("Usage: /mcp read <server> <uri>");
+      throw new Error("Usage: /mcp read <server> <uri> | /mcp read @server:uri");
     }
     for (const line of await renderMcpResourceRead(cwd, serverName, uri)) {
       console.log(line);
@@ -36878,7 +37671,7 @@ async function handleMcpCommand(cwd, tokens) {
     console.log(`Added MCP server ${name}`);
     return;
   }
-  throw new Error("Usage: /mcp [list|tools [server]|prompts [server]|resources [server]|prompt <server> <prompt>|read <server> <uri>|add <name> --command <cmd>|remove <name>|enable <name>|disable <name>]");
+  throw new Error("Usage: /mcp [list|discover [server]|prompts [server]|resources [server]|prompt <server> <prompt>|read <server> <uri>|read @server:uri|add <name> --command <cmd>|remove <name>|enable <name>|disable <name>]");
 }
 async function handleAgentsCommand(cwd, tokens) {
   const subcommand = tokens[1]?.trim().toLowerCase();
@@ -36923,6 +37716,38 @@ async function handleAgentsCommand(cwd, tokens) {
     console.log(`Created ${outputPath}`);
     return;
   }
+  if (subcommand === "show") {
+    const id = tokens[2]?.trim();
+    if (!id) {
+      throw new Error("Usage: /agents show <id>");
+    }
+    const agent = await loadCustomAgentById(cwd, id);
+    if (!agent) {
+      throw new Error(`Unknown custom agent "${id}".`);
+    }
+    console.log(`${agent.id}`);
+    console.log(`  label: ${agent.label}`);
+    console.log(`  baseRole: ${agent.baseRole}`);
+    console.log(`  brainRole: ${agent.brainRole ?? "-"}`);
+    console.log(`  purpose: ${agent.purpose ?? "-"}`);
+    console.log(`  match: ${agent.match.join(", ") || "-"}`);
+    console.log(`  tools: ${agent.tools.join(", ") || "(inherits base role tools)"}`);
+    console.log(`  file: ${agent.filePath}`);
+    if (agent.instructions.trim()) {
+      console.log("");
+      console.log(agent.instructions.trim());
+    }
+    return;
+  }
+  if (subcommand === "delete") {
+    const id = tokens[2]?.trim();
+    if (!id) {
+      throw new Error("Usage: /agents delete <id>");
+    }
+    const outputPath = await deleteCustomAgentFile(cwd, id);
+    console.log(`Deleted ${outputPath}`);
+    return;
+  }
   if (subcommand === "team" && tokens[2]?.trim().toLowerCase() === "create") {
     const id = tokens[3]?.trim();
     const agentIds = tokens.slice(4).filter((token) => !token.startsWith("--"));
@@ -36935,7 +37760,37 @@ async function handleAgentsCommand(cwd, tokens) {
     console.log(`Created ${outputPath}`);
     return;
   }
-  throw new Error("Usage: /agents [list|create <id> --base <role>|team create <id> <agent...>]");
+  if (subcommand === "team" && tokens[2]?.trim().toLowerCase() === "show") {
+    const id = tokens[3]?.trim();
+    if (!id) {
+      throw new Error("Usage: /agents team show <id>");
+    }
+    const team = await loadAgentTeamById(cwd, id);
+    if (!team) {
+      throw new Error(`Unknown team "${id}".`);
+    }
+    console.log(`${team.id}`);
+    console.log(`  label: ${team.label}`);
+    console.log(`  agents: ${team.agents.join(", ") || "-"}`);
+    console.log(`  match: ${team.match.join(", ") || "-"}`);
+    console.log(`  strategy: ${team.strategy}`);
+    console.log(`  file: ${team.filePath}`);
+    if (team.description) {
+      console.log("");
+      console.log(team.description);
+    }
+    return;
+  }
+  if (subcommand === "team" && tokens[2]?.trim().toLowerCase() === "delete") {
+    const id = tokens[3]?.trim();
+    if (!id) {
+      throw new Error("Usage: /agents team delete <id>");
+    }
+    const outputPath = await deleteAgentTeamFile(cwd, id);
+    console.log(`Deleted ${outputPath}`);
+    return;
+  }
+  throw new Error("Usage: /agents [list|show <id>|delete <id>|create <id> --base <role>|team create <id> <agent...>|team show <id>|team delete <id>]");
 }
 async function handleModelSurfaceCommand(cwd, tokens, runtime) {
   const subcommand = tokens[1]?.trim().toLowerCase();