@kimbho/kimbho-cli 0.1.16 → 0.1.19

package/dist/index.cjs

@@ -10612,7 +10612,7 @@ var {
 // package.json
 var package_default = {
   name: "@kimbho/kimbho-cli",
-  version: "0.1.16",
+  version: "0.1.19",
   description: "Kimbho CLI is a terminal-native coding agent for planning, execution, and verification.",
   type: "module",
   engines: {
@@ -15029,7 +15029,9 @@ var PlanTaskSchema = external_exports.object({
   swarmDepth: external_exports.number().int().nonnegative().optional(),
   customAgentId: external_exports.string().min(1).optional(),
   teamId: external_exports.string().min(1).optional(),
-  teamMemberIds: external_exports.array(external_exports.string()).optional()
+  teamMemberIds: external_exports.array(external_exports.string()).optional(),
+  subagentLabel: external_exports.string().min(1).optional(),
+  subagentInstructions: external_exports.string().min(1).optional()
 });
 var PlanMilestoneSchema = external_exports.object({
   id: external_exports.string().min(1),
@@ -16122,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 }) => {
@@ -16140,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`);
@@ -16174,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`);
@@ -16197,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;
@@ -18288,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 = [
@@ -18346,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) {
@@ -18573,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 = {};
@@ -19362,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));
 }
@@ -19430,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") {
@@ -19443,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") {
@@ -27624,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";
@@ -27783,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: []
   };
@@ -27821,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
     } : {},
@@ -27840,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
   };
@@ -28070,6 +28243,9 @@ function buildSystemPrompt(agent, task, request, allowedTools, plan, extraInstru
   return [
     `You are Kimbho's ${agent.role}.`,
     `Purpose: ${agent.purpose}`,
+    ...task.subagentLabel ? [
+      `Delegated worker: ${task.subagentLabel}`
+    ] : [],
     `Goal: ${request.goal}`,
     `Current task: ${task.id} - ${task.title}`,
     `Task description: ${task.description}`,
@@ -28103,6 +28279,10 @@ function buildSystemPrompt(agent, task, request, allowedTools, plan, extraInstru
     `- After changing code, run verification with tests.run or shell.exec when appropriate.`,
     `- Do not claim success unless the task acceptance criteria are satisfied.`,
     `- If the task is underspecified, make a pragmatic implementation choice and continue.`,
+    ...task.subagentInstructions ? [
+      `Delegation instructions:`,
+      task.subagentInstructions
+    ] : [],
     ...extraInstructions ? [
       `Custom instructions:`,
       extraInstructions
@@ -29168,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 = [
@@ -29226,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) {
@@ -31142,6 +31385,330 @@ 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, request) {
+  if (looksLikeVisualAdjustmentGoal(request.goal) && isStaticSiteTask(task, request)) {
+    return false;
+  }
+  return (task.swarmDepth ?? 0) === 0 && task.type === "implementation" && ![
+    "repo-analyst",
+    "planner",
+    "reviewer",
+    "integrator",
+    "test-debugger",
+    "session-orchestrator",
+    "execution-manager"
+  ].includes(task.agentRole);
+}
+function terminalExpansionTaskIds(tasks) {
+  const referencedIds = new Set(tasks.flatMap((task) => task.dependsOn));
+  const terminalIds = tasks.filter((task) => !referencedIds.has(task.id)).map((task) => task.id);
+  return terminalIds.length > 0 ? terminalIds : tasks.map((task) => task.id);
+}
+function createDefaultDelegationPlan(task, request) {
+  if (!shouldDelegateTask(task, request)) {
+    return null;
+  }
+  if (task.agentRole === "frontend-specialist" || isStaticSiteTask(task, request)) {
+    return {
+      label: "auto-frontend-swarm",
+      strategy: "parallel",
+      members: [
+        {
+          id: "content-architect",
+          label: "content-architect",
+          agentRole: "frontend-specialist",
+          description: "Own information architecture, page composition, navigation, copy structure, and section flow.",
+          instructions: "Prioritize semantic layout, page structure, routes, content hierarchy, and component composition. Leave purely visual polish to the visual worker unless structure blocks it.",
+          acceptanceCriteria: [
+            "The page structure, sections, and navigation flow are clear and coherent.",
+            "Content hierarchy reflects the requested product, brand, or venue."
+          ],
+          outputs: [
+            "Structured page/content update"
+          ]
+        },
+        {
+          id: "visual-polisher",
+          label: "visual-polisher",
+          agentRole: "frontend-specialist",
+          description: "Own styling, gradients, motion, responsiveness, spacing, and visual finishing.",
+          instructions: "Focus on visual quality, gradients, motion, responsiveness, spacing, and interaction polish after inspecting the current structure. Keep edits aligned with the existing design language when present.",
+          acceptanceCriteria: [
+            "Visual styling and responsiveness are meaningfully improved.",
+            "Motion and polish remain consistent with the requested UI direction."
+          ],
+          outputs: [
+            "Visual polish update"
+          ]
+        }
+      ]
+    };
+  }
+  if (task.agentRole === "backend-specialist") {
+    return {
+      label: "auto-backend-swarm",
+      strategy: "sequential",
+      members: [
+        {
+          id: "contract-architect",
+          label: "contract-architect",
+          agentRole: "backend-specialist",
+          description: "Define the API/service surface, request-response shapes, and failure behavior.",
+          instructions: "Focus on service and API contracts, input/output shapes, handlers, and edge cases before broad implementation changes.",
+          acceptanceCriteria: [
+            "Contracts and failure cases are explicit.",
+            "The implementation path is narrowed to concrete handlers or services."
+          ],
+          outputs: [
+            "Backend contract design"
+          ]
+        },
+        {
+          id: "service-implementer",
+          label: "service-implementer",
+          agentRole: "backend-specialist",
+          description: "Implement handlers, services, and domain logic against the agreed contract.",
+          instructions: "Implement the core backend behavior against the established contract. Prefer targeted file edits and verification over broad rewrites.",
+          acceptanceCriteria: [
+            "Business logic is implemented against the contract.",
+            "The backend behavior satisfies the task acceptance criteria."
+          ],
+          outputs: [
+            "Backend implementation"
+          ]
+        }
+      ]
+    };
+  }
+  if (task.agentRole === "database-specialist") {
+    return {
+      label: "auto-database-swarm",
+      strategy: "sequential",
+      members: [
+        {
+          id: "schema-designer",
+          label: "schema-designer",
+          agentRole: "database-specialist",
+          description: "Design models, fields, relations, constraints, and persistence boundaries.",
+          instructions: "Focus on schema structure, data modeling, constraints, and identifiers. Keep the migration path safe and explicit.",
+          acceptanceCriteria: [
+            "Schema design reflects the requested domain.",
+            "Constraints and data relationships are explicit."
+          ],
+          outputs: [
+            "Schema design"
+          ]
+        },
+        {
+          id: "migration-planner",
+          label: "migration-planner",
+          agentRole: "database-specialist",
+          description: "Apply or prepare migrations and persistence wiring around the approved schema.",
+          instructions: "Translate the schema design into migrations or persistence updates. Keep destructive changes obvious and verification-friendly.",
+          acceptanceCriteria: [
+            "Persistence updates align with the intended schema.",
+            "Migration risk and verification needs are explicit."
+          ],
+          outputs: [
+            "Migration/persistence update"
+          ]
+        }
+      ]
+    };
+  }
+  if (task.agentRole === "infra-specialist") {
+    return {
+      label: "auto-infra-swarm",
+      strategy: "sequential",
+      members: [
+        {
+          id: "workspace-scaffolder",
+          label: "workspace-scaffolder",
+          agentRole: "infra-specialist",
+          description: "Set up required files, scripts, package wiring, and environment plumbing.",
+          instructions: "Focus on scaffolding, package manifests, scripts, environment wiring, and local runtime setup. Keep the workspace runnable.",
+          acceptanceCriteria: [
+            "Required scaffolding and environment wiring are in place.",
+            "The workspace can proceed into implementation or verification."
+          ],
+          outputs: [
+            "Workspace scaffolding"
+          ]
+        },
+        {
+          id: "runtime-verifier",
+          label: "runtime-verifier",
+          agentRole: "infra-specialist",
+          description: "Verify build/runtime setup and tighten any configuration or tooling gaps.",
+          instructions: "Focus on runtime, toolchain, script, and build verification after the initial setup work has landed.",
+          acceptanceCriteria: [
+            "The environment or app can be verified locally.",
+            "Tooling and configuration gaps are closed."
+          ],
+          outputs: [
+            "Runtime/config verification"
+          ]
+        }
+      ]
+    };
+  }
+  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);
+  const generatedTaskIds = members.map((member, index) => createUniqueTaskId2(`${task.id}-${slugify2(member.id) || `worker-${index + 1}`}`, existingIds));
+  return members.map((member, index) => {
+    const taskId = generatedTaskIds[index];
+    const dependsOn = strategy === "parallel" ? [
+      ...task.dependsOn
+    ] : index === 0 ? [
+      ...task.dependsOn
+    ] : [
+      generatedTaskIds[index - 1]
+    ];
+    return {
+      ...task,
+      id: taskId,
+      title: `${task.title} (${member.label})`,
+      description: [
+        task.description,
+        `Delegated worker: ${member.label}.`,
+        member.description
+      ].join("\n\n"),
+      agentRole: member.agentRole,
+      dependsOn,
+      acceptanceCriteria: member.acceptanceCriteria?.length ? member.acceptanceCriteria : index === members.length - 1 ? task.acceptanceCriteria : [
+        `Advance ${task.title.toLowerCase()} from the ${member.label} perspective.`,
+        "Leave concrete implementation evidence for the next worker."
+      ],
+      outputs: member.outputs?.length ? member.outputs : index === members.length - 1 ? task.outputs : [
+        `Delegated handoff from ${member.id}`
+      ],
+      filesLikelyTouched: member.filesLikelyTouched?.length ? member.filesLikelyTouched : task.filesLikelyTouched,
+      originTaskId: task.id,
+      swarmDepth: (task.swarmDepth ?? 0) + 1,
+      teamId: label,
+      teamMemberIds,
+      subagentLabel: member.label,
+      subagentInstructions: member.instructions
+    };
+  });
+}
+function appendReviewAndIntegrationTasks(plan, originalTask, expandedTasks, delegationLabel) {
+  const existingIds = new Set(flattenPlanTasks(plan).filter((candidate) => candidate.id !== originalTask.id).map((candidate) => candidate.id));
+  for (const task of expandedTasks) {
+    existingIds.add(task.id);
+  }
+  const terminalIds = terminalExpansionTaskIds(expandedTasks);
+  const reviewerId = createUniqueTaskId2(`${originalTask.id}-review`, existingIds);
+  const integratorId = createUniqueTaskId2(`${originalTask.id}-integrate`, existingIds);
+  const reviewerTask = {
+    ...originalTask,
+    id: reviewerId,
+    title: `Review ${originalTask.title.toLowerCase()}`,
+    description: `Inspect delegated worker output from ${delegationLabel} before integration and call out correctness or verification risk.`,
+    type: "verification",
+    agentRole: "reviewer",
+    dependsOn: terminalIds,
+    acceptanceCriteria: [
+      "Inspect the delegated changes for regressions or missing coverage.",
+      "Confirm whether the worker output is ready for integration."
+    ],
+    outputs: [
+      "Review summary"
+    ],
+    originTaskId: originalTask.id,
+    swarmDepth: (originalTask.swarmDepth ?? 0) + 1,
+    teamId: delegationLabel,
+    teamMemberIds: [
+      ...originalTask.teamMemberIds ?? [],
+      "reviewer"
+    ],
+    subagentLabel: "reviewer",
+    subagentInstructions: "Inspect the delegated changes, diff, and verification evidence. Surface concrete risks before integration."
+  };
+  const integratorTask = {
+    ...originalTask,
+    id: integratorId,
+    title: `Integrate ${originalTask.title.toLowerCase()}`,
+    description: `Finalize and integrate delegated worker output after reviewer sign-off for ${delegationLabel}.`,
+    type: "integration",
+    agentRole: "integrator",
+    dependsOn: [
+      reviewerId
+    ],
+    acceptanceCriteria: originalTask.acceptanceCriteria,
+    outputs: mergeUnique([
+      ...originalTask.outputs,
+      "Integrated change set"
+    ]),
+    originTaskId: originalTask.id,
+    swarmDepth: (originalTask.swarmDepth ?? 0) + 1,
+    teamId: delegationLabel,
+    teamMemberIds: [
+      ...originalTask.teamMemberIds ?? [],
+      "integrator"
+    ],
+    subagentLabel: "integrator",
+    subagentInstructions: "Finalize the accepted worker output, preserve repository consistency, and leave the workspace ready for downstream verification."
+  };
+  return {
+    tasks: [
+      ...expandedTasks,
+      reviewerTask,
+      integratorTask
+    ],
+    noteSuffix: `review tail ${reviewerId} -> integration tail ${integratorId}`
+  };
+}
 function renderToolResultSection(results) {
   return results.map((result) => {
     const lines = [
@@ -31669,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);
     }
@@ -31803,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,
@@ -32199,15 +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) => (task.swarmDepth ?? 0) === 0 && task.type === "implementation" && ![
-      "repo-analyst",
-      "planner",
-      "reviewer",
-      "integrator",
-      "test-debugger",
-      "session-orchestrator",
-      "execution-manager"
-    ].includes(task.agentRole));
+    const candidate = envelope.readyTasks.find((task) => shouldDelegateTask(task, request));
     if (!candidate) {
       return {
         plan
@@ -32215,47 +32839,37 @@ var ExecutionOrchestrator = class {
     }
     const matchedTeam = await selectAgentTeam(request.cwd, candidate, request);
     if (matchedTeam && matchedTeam.members.length > 1) {
-      const existingIds = new Set(flattenPlanTasks(plan).filter((task) => task.id !== candidate.id).map((task) => task.id));
-      const teamMemberIds = matchedTeam.members.map((member) => member.id);
-      const generatedTaskIds = matchedTeam.members.map((member, index) => createUniqueTaskId2(`${candidate.id}-${slugify2(member.id) || `member-${index + 1}`}`, existingIds));
-      const teamTasks = matchedTeam.members.map((member, index) => {
-        const taskId = generatedTaskIds[index];
-        const dependsOn = matchedTeam.team.strategy === "parallel" ? [
-          ...candidate.dependsOn
-        ] : index === 0 ? [
-          ...candidate.dependsOn
-        ] : [
-          generatedTaskIds[index - 1] ?? candidate.dependsOn[0] ?? ""
-        ].filter((value) => value.length > 0);
-        return {
-          ...candidate,
-          id: taskId,
-          title: `${candidate.title} (${member.label})`,
-          description: [
-            candidate.description,
-            `Assigned team member: ${member.label} (${member.id}).`,
-            member.purpose ? `Purpose: ${member.purpose}` : "",
-            matchedTeam.team.description ? `Team context: ${matchedTeam.team.description}` : ""
-          ].filter((part) => part.length > 0).join("\n\n"),
-          agentRole: member.baseRole,
-          dependsOn,
-          acceptanceCriteria: index === matchedTeam.members.length - 1 ? candidate.acceptanceCriteria : [
-            `Advance ${candidate.title.toLowerCase()} from the ${member.label} perspective.`,
-            "Leave clear handoff notes and concrete changed-file intent for the next team member."
-          ],
-          outputs: index === matchedTeam.members.length - 1 ? candidate.outputs : [
-            `Team handoff from ${member.id}`
-          ],
-          originTaskId: candidate.id,
-          swarmDepth: (candidate.swarmDepth ?? 0) + 1,
-          customAgentId: member.id,
-          teamId: matchedTeam.team.id,
-          teamMemberIds
-        };
-      });
-      const note = `Agent team ${matchedTeam.team.label} expanded ${candidate.id} into ${teamTasks.length} ${matchedTeam.team.strategy} subtasks: ${teamTasks.map((task) => task.id).join(", ")}.`;
+      const teamTasks = materializeDelegatedTasks(plan, candidate, matchedTeam.team.id, matchedTeam.team.strategy, matchedTeam.members.map((member) => ({
+        id: member.id,
+        label: member.label,
+        agentRole: member.baseRole,
+        description: [
+          `Assigned team member: ${member.label} (${member.id}).`,
+          member.purpose ? `Purpose: ${member.purpose}` : "",
+          matchedTeam.team.description ? `Team context: ${matchedTeam.team.description}` : ""
+        ].filter((part) => part.length > 0).join("\n\n"),
+        instructions: member.instructions
+      }))).map((task) => ({
+        ...task,
+        customAgentId: task.customAgentId ?? task.subagentLabel ? matchedTeam.members.find((member) => member.label === task.subagentLabel)?.id : void 0,
+        teamId: matchedTeam.team.id,
+        teamMemberIds: matchedTeam.members.map((member) => member.id)
+      }));
+      const augmented = appendReviewAndIntegrationTasks(plan, candidate, teamTasks, matchedTeam.team.label);
+      const note = `Agent team ${matchedTeam.team.label} expanded ${candidate.id} into ${teamTasks.length} worker subtasks with reviewer/integrator follow-through: ${augmented.tasks.map((task) => task.id).join(", ")}.`;
+      return {
+        plan: integratePlanTaskExpansion(plan, candidate.id, augmented.tasks, note),
+        note,
+        expandedTaskId: candidate.id
+      };
+    }
+    const defaultDelegation = createDefaultDelegationPlan(candidate, request);
+    if (defaultDelegation && defaultDelegation.members.length > 1) {
+      const delegatedTasks = materializeDelegatedTasks(plan, candidate, defaultDelegation.label, defaultDelegation.strategy, defaultDelegation.members);
+      const augmented = appendReviewAndIntegrationTasks(plan, candidate, delegatedTasks, defaultDelegation.label);
+      const note = `Execution manager delegated ${candidate.id} into ${delegatedTasks.length} subagents plus reviewer/integrator: ${augmented.tasks.map((task) => task.id).join(", ")}.`;
       return {
-        plan: integratePlanTaskExpansion(plan, candidate.id, teamTasks, note),
+        plan: integratePlanTaskExpansion(plan, candidate.id, augmented.tasks, note),
         note,
         expandedTaskId: candidate.id
       };
@@ -32317,12 +32931,14 @@ var ExecutionOrchestrator = class {
           plan
         };
       }
+      const expandedTasks = flattenPlanTasks(result.plan).filter((task) => result.createdTaskIds.includes(task.id));
+      const augmented = appendReviewAndIntegrationTasks(plan, candidate, expandedTasks, "planner-swarm");
       const noteParts = [
-        result.note,
+        result.note ? `${result.note} | Added reviewer/integrator pass: ${augmented.noteSuffix}.` : `Added reviewer/integrator pass: ${augmented.noteSuffix}.`,
         result.warning && result.source !== "model" ? `expander note: ${result.warning}` : ""
       ].filter(Boolean);
       return {
-        plan: result.plan,
+        plan: integratePlanTaskExpansion(plan, candidate.id, augmented.tasks, noteParts.join(" | ")),
         ...noteParts.length > 0 ? {
           note: noteParts.join(" | ")
         } : {},
@@ -32436,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;
 }
 
@@ -32877,7 +33552,15 @@ async function generateProjectInitFile(cwd, outputFileName = "kimbho_init.md") {
   return {
     outputPath,
     indexArtifactPath: artifactPath,
-    summary: `Generated ${outputFileName} with indexed project context for ${import_node_path15.default.basename(cwd)}.`
+    summary: `Generated ${outputFileName} with indexed project context for ${import_node_path15.default.basename(cwd)}.`,
+    purpose,
+    frameworks,
+    entrypoints,
+    verificationCommands,
+    indexedFiles: index.summary.totalFiles,
+    sourceFiles: index.summary.sourceFiles,
+    routes: index.summary.routes,
+    schemas: index.summary.schemas
   };
 }
 
@@ -32934,7 +33617,15 @@ async function refreshMemoryFiles(cwd) {
     initFilePath: init.outputPath,
     projectMemoryPath,
     userMemoryPath,
-    summary: `Refreshed project bootstrap and memory files for ${import_node_path16.default.basename(cwd)}.`
+    summary: `Refreshed project bootstrap and memory files for ${import_node_path16.default.basename(cwd)}.`,
+    purpose: init.purpose,
+    frameworks: init.frameworks,
+    entrypoints: init.entrypoints,
+    verificationCommands: init.verificationCommands,
+    indexedFiles: init.indexedFiles,
+    sourceFiles: init.sourceFiles,
+    routes: init.routes,
+    schemas: init.schemas
   };
 }
 async function appendMemoryNote(cwd, scope, text, agentId) {
@@ -33076,6 +33767,22 @@ function createDoctorCommand() {
 
 // src/commands/init.ts
 var import_node_process7 = __toESM(require("node:process"), 1);
+function printProjectUnderstanding(result) {
+  console.log(result.summary);
+  console.log("Now I have a durable understanding of the current project structure.");
+  console.log(`Purpose: ${result.purpose}`);
+  console.log(`Indexed: ${result.indexedFiles} files (${result.sourceFiles} source files), ${result.routes} routes, ${result.schemas} schemas`);
+  console.log(`Frameworks: ${result.frameworks.length > 0 ? result.frameworks.join(", ") : "unknown"}`);
+  if (result.entrypoints.length > 0) {
+    console.log(`Entrypoints: ${result.entrypoints.slice(0, 5).join(", ")}`);
+  }
+  if (result.verificationCommands.length > 0) {
+    console.log(`Verification: ${result.verificationCommands.join(" -> ")}`);
+  }
+  console.log(`Wrote ${result.initFilePath}`);
+  console.log(`Wrote ${result.projectMemoryPath}`);
+  console.log(`Wrote ${result.userMemoryPath}`);
+}
 function createInitCommand() {
   return new Command("init").description("Create or refresh local Kimbho config and project bootstrap memory.").option("--template <template>", "Provider template to use for the initial provider").option("--provider-id <id>", "Identifier for the initial provider").option("--driver <driver>", "Provider driver to use when no template is supplied").option("--label <label>", "Human-readable provider label").option("--model <model>", "Default model to use for planner/coder/reviewer brains").option("--fast-model <model>", "Model to use for the fast utility brain").option("--api-key-env <env>", "Environment variable that stores the provider API key").option("--base-url <url>", "Base URL or endpoint for the provider driver").option("--module-path <path>", "Module path for a custom provider driver").option("--config-only", "Only write .kimbho/config.json and skip project memory generation", false).option("--memory-only", "Only generate kimbho_init.md and keep the existing config untouched", false).option("--memory-file <file>", "Project memory file to write", "kimbho_init.md").option("--force", "Overwrite an existing config file", false).action(async (options) => {
     const existing = await loadConfig(import_node_process7.default.cwd());
@@ -33141,10 +33848,7 @@ function createInitCommand() {
     }
     if (!options.configOnly) {
       const result = await refreshMemoryFiles(import_node_process7.default.cwd());
-      console.log(result.summary);
-      console.log(`Wrote ${result.initFilePath}`);
-      console.log(`Wrote ${result.projectMemoryPath}`);
-      console.log(`Wrote ${result.userMemoryPath}`);
+      printProjectUnderstanding(result);
     }
   });
 }
@@ -33227,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) => [
@@ -33253,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"
     ]
@@ -34889,6 +35593,9 @@ var PLAN_PREFIXES = [
   "outline ",
   "propose "
 ];
+function looksLikeExecutionRequest(input) {
+  return /\b(build|create|make|scaffold|implement|fix|refactor|setup|set up|generate|add|change|update|edit|rewrite|restyle|redesign|improve|enhance)\b/.test(input);
+}
 function color(code, value) {
   return `${code}${value}${RESET}`;
 }
@@ -35191,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");
@@ -35282,20 +36001,20 @@ function inferPromptIntent(input) {
   if (/^(hi|hello|hey|yo|sup)\b/.test(normalized)) {
     return "chat";
   }
-  if (normalized.endsWith("?")) {
-    return "chat";
-  }
   if (PLAN_PREFIXES.some((prefix) => normalized.startsWith(prefix))) {
     return "plan";
   }
   if (EXECUTION_PREFIXES.some((prefix) => normalized.startsWith(prefix))) {
     return "run";
   }
-  if (CHAT_PREFIXES.some((prefix) => normalized.startsWith(prefix))) {
+  if (looksLikeExecutionRequest(normalized)) {
+    return "run";
+  }
+  if (normalized.endsWith("?")) {
     return "chat";
   }
-  if (/\b(build|create|make|scaffold|implement|fix|refactor|setup|set up|generate)\b/.test(normalized)) {
-    return "run";
+  if (CHAT_PREFIXES.some((prefix) => normalized.startsWith(prefix))) {
+    return "chat";
   }
   return normalized.split(/\s+/).length >= 4 ? "plan" : "chat";
 }
@@ -36377,6 +37096,16 @@ async function handleMemoryCommand(cwd, tokens) {
   if (subcommand === "refresh") {
     const result = await refreshMemoryFiles(cwd);
     console.log(result.summary);
+    console.log("Now I have a durable understanding of the current project structure.");
+    console.log(`Purpose: ${result.purpose}`);
+    console.log(`Indexed: ${result.indexedFiles} files (${result.sourceFiles} source files), ${result.routes} routes, ${result.schemas} schemas`);
+    console.log(`Frameworks: ${result.frameworks.length > 0 ? result.frameworks.join(", ") : "unknown"}`);
+    if (result.entrypoints.length > 0) {
+      console.log(`Entrypoints: ${result.entrypoints.slice(0, 5).join(", ")}`);
+    }
+    if (result.verificationCommands.length > 0) {
+      console.log(`Verification: ${result.verificationCommands.join(" -> ")}`);
+    }
     console.log(`Wrote ${result.initFilePath}`);
     console.log(`Wrote ${result.projectMemoryPath}`);
     console.log(`Wrote ${result.userMemoryPath}`);
@@ -36460,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);
@@ -36496,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);
@@ -36569,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();
@@ -36614,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("--"));
@@ -36626,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();