@kimbho/kimbho-cli 0.1.18 → 0.1.19

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.19",
   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,46 @@ 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 looksLikeStaticLandingGoal(value) {
   const normalized = value.toLowerCase();
   const backendSignals = [
@@ -18348,6 +18406,9 @@ 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;
+  }
   return false;
 }
 function sanitizeName(value) {
@@ -18575,7 +18636,76 @@ 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 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 +19494,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);
+}
 function isDestructiveShellCommand(command) {
   return DESTRUCTIVE_SHELL_PATTERNS.some((pattern) => pattern.test(command));
 }
@@ -19432,8 +19565,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 +19579,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 +27763,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 +27953,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 +27992,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 +28012,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 +29348,66 @@ 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 looksLikeStaticSiteGoal(goal) {
   const lower = goal.toLowerCase();
   const backendSignals = [
@@ -29235,6 +29466,9 @@ 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;
+  }
   return false;
 }
 function inferProjectShape(goal) {
@@ -31151,7 +31385,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) && isStaticSiteTask(task, request)) {
+    return false;
+  }
   return (task.swarmDepth ?? 0) === 0 && task.type === "implementation" && ![
     "repo-analyst",
     "planner",
@@ -31168,7 +31405,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 +31554,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 +32236,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 +32373,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 +32831,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 +33052,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 +33931,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 +33957,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 +35898,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 +37189,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 +37225,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 +37300,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 +37345,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 +37389,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();