hoomanjs 1.11.3 → 1.12.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hoomanjs",
-  "version": "1.11.3",
+  "version": "1.12.0",
   "description": "Bun-powered local AI agent CLI with chat, exec, ACP, MCP, and skills support.",
   "author": {
     "name": "Vaibhav Pandey",

package/src/acp/acp-agent.ts

@@ -337,8 +337,10 @@ export class AcpAgent implements AgentContract {
       {
         userId: bootstrapUserId,
         sessionId,
-        mcpServers,
-        ...(clientSystemPrompt ? { systemPrompt: clientSystemPrompt } : {}),
+        acp: {
+          mcpServers,
+          ...(clientSystemPrompt ? { systemPrompt: clientSystemPrompt } : {}),
+        },
       },
       false,
     );
@@ -433,8 +435,10 @@ export class AcpAgent implements AgentContract {
       {
         userId: bootstrapUserId,
         sessionId: params.sessionId,
-        mcpServers,
-        ...(clientSystemPrompt ? { systemPrompt: clientSystemPrompt } : {}),
+        acp: {
+          mcpServers,
+          ...(clientSystemPrompt ? { systemPrompt: clientSystemPrompt } : {}),
+        },
       },
       false,
     );

package/src/acp/sessions/config-options.ts

@@ -63,8 +63,8 @@ export function applySessionConfigOption(
   if (params.configId === HOOMAN_LTM_CONFIG_ID) {
     const chroma = config.ltm.chroma;
     config.update({
-      features: {
-        ...config.features,
+      tools: {
+        ...config.tools,
         ltm: {
           enabled: value === "on",
           chroma: {
@@ -79,8 +79,8 @@ export function applySessionConfigOption(
 
   const chroma = config.wiki.chroma;
   config.update({
-    features: {
-      ...config.features,
+    tools: {
+      ...config.tools,
       wiki: {
         enabled: value === "on",
         chroma: {

package/src/configure/app.tsx

@@ -132,7 +132,6 @@ export function ConfigureApp({
         name: config.name,
         llm: config.llm,
         tools: config.tools,
-        features: config.features,
         compaction: config.compaction,
       }) satisfies ConfigData,
     [config, revision],
@@ -433,79 +432,98 @@ export function ConfigureApp({
           }),
       },
       {
-        label: `Allowed tools • ${truncate(compactJson(configData.tools.allowed))}`,
-        value: () =>
-          promptValue({
-            title: "Update allowed list",
-            label: "Allowed",
-            initialValue: compactJson(configData.tools.allowed),
-            placeholder: '["tool_a","tool_b"]',
-            onSubmit: async (value) => {
-              const allowed = parseStringArray(value, "Allowed");
-              updateConfig({ tools: { allowed } }, "Updated allowed list.");
-              setPrompt(null);
-            },
-          }),
-      },
-      {
-        label: `Fetch feature • ${configData.features.fetch.enabled ? "Enabled" : "Disabled"}`,
+        label: `Fetch tool • ${configData.tools.fetch.enabled ? "Enabled" : "Disabled"}`,
         value: () => {
           updateConfig(
             {
-              features: {
-                ...config.features,
+              tools: {
+                ...config.tools,
                 fetch: {
-                  enabled: !configData.features.fetch.enabled,
+                  enabled: !configData.tools.fetch.enabled,
                 },
               },
             },
-            `Fetch feature ${configData.features.fetch.enabled ? "disabled" : "enabled"}.`,
+            `Fetch tool ${configData.tools.fetch.enabled ? "disabled" : "enabled"}.`,
           );
           setScreen({ kind: "config" });
         },
       },
       {
-        label: `Filesystem feature • ${configData.features.filesystem.enabled ? "Enabled" : "Disabled"}`,
+        label: `Filesystem tool • ${configData.tools.filesystem.enabled ? "Enabled" : "Disabled"}`,
         value: () => {
           updateConfig(
             {
-              features: {
-                ...config.features,
+              tools: {
+                ...config.tools,
                 filesystem: {
-                  enabled: !configData.features.filesystem.enabled,
+                  enabled: !configData.tools.filesystem.enabled,
                 },
               },
             },
-            `Filesystem feature ${configData.features.filesystem.enabled ? "disabled" : "enabled"}.`,
+            `Filesystem tool ${configData.tools.filesystem.enabled ? "disabled" : "enabled"}.`,
           );
           setScreen({ kind: "config" });
         },
       },
       {
-        label: `Shell feature • ${configData.features.shell.enabled ? "Enabled" : "Disabled"}`,
+        label: `Shell tool • ${configData.tools.shell.enabled ? "Enabled" : "Disabled"}`,
         value: () => {
           updateConfig(
             {
-              features: {
-                ...config.features,
+              tools: {
+                ...config.tools,
                 shell: {
-                  enabled: !configData.features.shell.enabled,
+                  enabled: !configData.tools.shell.enabled,
                 },
               },
             },
-            `Shell feature ${configData.features.shell.enabled ? "disabled" : "enabled"}.`,
+            `Shell tool ${configData.tools.shell.enabled ? "disabled" : "enabled"}.`,
           );
           setScreen({ kind: "config" });
         },
       },
       {
-        label: `Long-term memory • ${configData.features.ltm.enabled ? "Enabled" : "Disabled"} • ${configData.features.ltm.chroma.collection.memory}`,
+        label: `Long-term memory • ${configData.tools.ltm.enabled ? "Enabled" : "Disabled"} • ${configData.tools.ltm.chroma.collection.memory}`,
         value: () => setScreen({ kind: "config-ltm" }),
       },
       {
-        label: `Wiki feature • ${configData.features.wiki.enabled ? "Enabled" : "Disabled"} • ${configData.features.wiki.chroma.collection.wiki}`,
+        label: `Wiki tool • ${configData.tools.wiki.enabled ? "Enabled" : "Disabled"} • ${configData.tools.wiki.chroma.collection.wiki}`,
         value: () => setScreen({ kind: "config-wiki" }),
       },
+      {
+        label: `MCP tools • ${configData.tools.mcp.enabled ? "Enabled" : "Disabled"}`,
+        value: () => {
+          updateConfig(
+            {
+              tools: {
+                ...config.tools,
+                mcp: {
+                  enabled: !configData.tools.mcp.enabled,
+                },
+              },
+            },
+            `MCP tools ${configData.tools.mcp.enabled ? "disabled" : "enabled"}.`,
+          );
+          setScreen({ kind: "config" });
+        },
+      },
+      {
+        label: `Skills tools • ${configData.tools.skills.enabled ? "Enabled" : "Disabled"}`,
+        value: () => {
+          updateConfig(
+            {
+              tools: {
+                ...config.tools,
+                skills: {
+                  enabled: !configData.tools.skills.enabled,
+                },
+              },
+            },
+            `Skills tools ${configData.tools.skills.enabled ? "disabled" : "enabled"}.`,
+          );
+          setScreen({ kind: "config" });
+        },
+      },
       {
         label: `Compaction ratio • ${configData.compaction.ratio}`,
         value: () =>
@@ -604,30 +622,30 @@ export function ConfigureApp({
   const renderLtmConfigMenu = () => {
     const items: MenuItem[] = [
       {
-        label: `Enabled • ${configData.features.ltm.enabled ? "On" : "Off"}`,
+        label: `Enabled • ${configData.tools.ltm.enabled ? "On" : "Off"}`,
         value: () => {
           updateConfig(
             {
-              features: {
-                ...config.features,
+              tools: {
+                ...config.tools,
                 ltm: {
-                  ...config.features.ltm,
-                  enabled: !configData.features.ltm.enabled,
+                  ...config.tools.ltm,
+                  enabled: !configData.tools.ltm.enabled,
                 },
               },
             },
-            `Long-term memory ${configData.features.ltm.enabled ? "disabled" : "enabled"}.`,
+            `Long-term memory ${configData.tools.ltm.enabled ? "disabled" : "enabled"}.`,
           );
           setScreen({ kind: "config-ltm" });
         },
       },
       {
-        label: `Chroma URL • ${configData.features.ltm.chroma.url}`,
+        label: `Chroma URL • ${configData.tools.ltm.chroma.url}`,
         value: () =>
           promptValue({
             title: "Update LTM Chroma URL",
             label: "URL",
-            initialValue: configData.features.ltm.chroma.url,
+            initialValue: configData.tools.ltm.chroma.url,
             onSubmit: async (value) => {
               const url = value.trim();
               if (!url) {
@@ -635,12 +653,12 @@ export function ConfigureApp({
               }
               updateConfig(
                 {
-                  features: {
-                    ...config.features,
+                  tools: {
+                    ...config.tools,
                     ltm: {
-                      ...config.features.ltm,
+                      ...config.tools.ltm,
                       chroma: {
-                        ...config.features.ltm.chroma,
+                        ...config.tools.ltm.chroma,
                         url,
                       },
                     },
@@ -653,12 +671,12 @@ export function ConfigureApp({
           }),
       },
       {
-        label: `Chroma collection • ${configData.features.ltm.chroma.collection.memory}`,
+        label: `Chroma collection • ${configData.tools.ltm.chroma.collection.memory}`,
         value: () =>
           promptValue({
             title: "Update LTM Chroma collection",
             label: "Collection name",
-            initialValue: configData.features.ltm.chroma.collection.memory,
+            initialValue: configData.tools.ltm.chroma.collection.memory,
             onSubmit: async (value) => {
               const memory = value.trim();
               if (!memory) {
@@ -666,12 +684,12 @@ export function ConfigureApp({
               }
               updateConfig(
                 {
-                  features: {
-                    ...config.features,
+                  tools: {
+                    ...config.tools,
                     ltm: {
-                      ...config.features.ltm,
+                      ...config.tools.ltm,
                       chroma: {
-                        ...config.features.ltm.chroma,
+                        ...config.tools.ltm.chroma,
                         collection: { memory },
                       },
                     },
@@ -701,30 +719,30 @@ export function ConfigureApp({
   const renderWikiConfigMenu = () => {
     const items: MenuItem[] = [
       {
-        label: `Enabled • ${configData.features.wiki.enabled ? "On" : "Off"}`,
+        label: `Enabled • ${configData.tools.wiki.enabled ? "On" : "Off"}`,
         value: () => {
           updateConfig(
             {
-              features: {
-                ...config.features,
+              tools: {
+                ...config.tools,
                 wiki: {
-                  ...config.features.wiki,
-                  enabled: !configData.features.wiki.enabled,
+                  ...config.tools.wiki,
+                  enabled: !configData.tools.wiki.enabled,
                 },
               },
             },
-            `Wiki feature ${configData.features.wiki.enabled ? "disabled" : "enabled"}.`,
+            `Wiki tool ${configData.tools.wiki.enabled ? "disabled" : "enabled"}.`,
           );
           setScreen({ kind: "config-wiki" });
         },
       },
       {
-        label: `Chroma URL • ${configData.features.wiki.chroma.url}`,
+        label: `Chroma URL • ${configData.tools.wiki.chroma.url}`,
         value: () =>
           promptValue({
             title: "Update Wiki Chroma URL",
             label: "URL",
-            initialValue: configData.features.wiki.chroma.url,
+            initialValue: configData.tools.wiki.chroma.url,
             onSubmit: async (value) => {
               const url = value.trim();
               if (!url) {
@@ -732,12 +750,12 @@ export function ConfigureApp({
               }
               updateConfig(
                 {
-                  features: {
-                    ...config.features,
+                  tools: {
+                    ...config.tools,
                     wiki: {
-                      ...config.features.wiki,
+                      ...config.tools.wiki,
                       chroma: {
-                        ...config.features.wiki.chroma,
+                        ...config.tools.wiki.chroma,
                         url,
                       },
                     },
@@ -750,12 +768,12 @@ export function ConfigureApp({
           }),
       },
       {
-        label: `Chroma collection • ${configData.features.wiki.chroma.collection.wiki}`,
+        label: `Chroma collection • ${configData.tools.wiki.chroma.collection.wiki}`,
         value: () =>
           promptValue({
             title: "Update Wiki Chroma collection",
             label: "Collection name",
-            initialValue: configData.features.wiki.chroma.collection.wiki,
+            initialValue: configData.tools.wiki.chroma.collection.wiki,
             onSubmit: async (value) => {
               const wiki = value.trim();
               if (!wiki) {
@@ -763,12 +781,12 @@ export function ConfigureApp({
               }
               updateConfig(
                 {
-                  features: {
-                    ...config.features,
+                  tools: {
+                    ...config.tools,
                     wiki: {
-                      ...config.features.wiki,
+                      ...config.tools.wiki,
                       chroma: {
-                        ...config.features.wiki.chroma,
+                        ...config.tools.wiki.chroma,
                         collection: { wiki },
                       },
                     },
@@ -789,7 +807,7 @@ export function ConfigureApp({
     return (
       <MenuScreen
         title="Wiki"
-        description="Configure wiki features and Chroma-backed wiki search."
+        description="Configure wiki tool and Chroma-backed wiki search."
         items={items}
       />
     );

package/src/core/agent/index.ts

@@ -1,7 +1,11 @@
 import { Agent } from "@strands-agents/sdk";
 import type { Config } from "../config.ts";
 import { modelProviders } from "../models";
-import { type Config as McpConfig, type Manager as McpManager } from "../mcp";
+import {
+  createMcpTools,
+  type Config as McpConfig,
+  type Manager as McpManager,
+} from "../mcp";
 import type { System as SystemPrompt } from "../prompts";
 import { skills as createSkillsPrompt } from "../prompts";
 import {
@@ -9,7 +13,7 @@ import {
   createLongTermMemoryStore,
   createLongTermMemoryTools,
 } from "../memory";
-import type { Registry } from "../skills";
+import { createSkillsTools, type Registry } from "../skills";
 import {
   createFetchTools,
   createFilesystemTools,
@@ -37,13 +41,19 @@ export async function create(
   const userId = meta.userId ?? sessionId;
   const llm = await modelProviders[config.llm.provider]!();
   const stm = createShortTermMemory(sessionId);
-  const ltm = config.features.ltm.enabled
+  const ltm = config.tools.ltm.enabled
     ? createLongTermMemoryStore(config)
     : null;
-  const skills = await createSkillsPrompt(registry);
-  const tools = await mcp.manager.listPrefixedTools();
-  const append = await mcp.manager.listServerInstructions();
-  const prompt = [system.content, meta.systemPrompt, ...append, skills.content]
+  const skills = config.tools.skills.enabled
+    ? (await createSkillsPrompt(registry)).content
+    : "";
+  const tools = config.tools.mcp.enabled
+    ? await mcp.manager.listPrefixedTools()
+    : [];
+  const append = config.tools.mcp.enabled
+    ? await mcp.manager.listServerInstructions()
+    : [];
+  const prompt = [system.content, meta.systemPrompt, ...append, skills]
     .filter((x) => !!x)
     .join(SECTION_BREAK);
   return new Agent({
@@ -56,11 +66,13 @@ export async function create(
     },
     tools: [
       ...createTimeTools(),
-      ...(config.features.fetch.enabled ? createFetchTools() : []),
+      ...(config.tools.fetch.enabled ? createFetchTools() : []),
       ...(ltm ? createLongTermMemoryTools(ltm) : []),
-      ...(config.features.filesystem.enabled ? createFilesystemTools() : []),
-      ...(config.features.shell.enabled ? createShellTools() : []),
-      ...(config.features.wiki.enabled ? createWikiTools(config) : []),
+      ...(config.tools.filesystem.enabled ? createFilesystemTools() : []),
+      ...(config.tools.shell.enabled ? createShellTools() : []),
+      ...(config.tools.wiki.enabled ? createWikiTools(config) : []),
+      ...(config.tools.mcp.enabled ? createMcpTools(mcp.config) : []),
+      ...(config.tools.skills.enabled ? createSkillsTools(registry) : []),
       ...createThinkingTools(),
       ...tools,
     ],

package/src/core/config.ts

@@ -67,49 +67,45 @@ const WikiPartialSchema = z.object({
   chroma: WikiChromaPartialSchema.optional(),
 });
 
-const FeatureTogglePartialSchema = z.object({
+const ToolTogglePartialSchema = z.object({
   enabled: z.boolean().optional(),
 });
 
-const FeaturesPartialSchema = z.object({
-  fetch: FeatureTogglePartialSchema.optional(),
-  filesystem: FeatureTogglePartialSchema.optional(),
-  shell: FeatureTogglePartialSchema.optional(),
+const ToolsPartialSchema = z.object({
+  fetch: ToolTogglePartialSchema.optional(),
+  filesystem: ToolTogglePartialSchema.optional(),
+  shell: ToolTogglePartialSchema.optional(),
   ltm: LtmPartialSchema.optional(),
   wiki: WikiPartialSchema.optional(),
-});
-
-const ToolsPartialSchema = z.object({
-  allowed: z.array(z.string().min(1)).default([]),
+  mcp: ToolTogglePartialSchema.optional(),
+  skills: ToolTogglePartialSchema.optional(),
 });
 
 const ConfigSchema = z
   .object({
     name: z.string().min(1),
     llm: LlmSchema,
-    tools: ToolsPartialSchema.default({ allowed: [] }),
-    features: FeaturesPartialSchema.nullish(),
+    tools: ToolsPartialSchema.nullish(),
     compaction: CompactionPartialSchema.nullish().transform((c) => ({
       ratio: c?.ratio ?? DEFAULT_COMPACTION.ratio,
       keep: c?.keep ?? DEFAULT_COMPACTION.keep,
     })),
   })
   .transform((input) => {
-    const ltm = input.features?.ltm;
-    const wiki = input.features?.wiki;
+    const ltm = input.tools?.ltm;
+    const wiki = input.tools?.wiki;
     return {
       name: input.name,
       llm: input.llm,
-      tools: input.tools,
-      features: {
+      tools: {
         fetch: {
-          enabled: input.features?.fetch?.enabled ?? true,
+          enabled: input.tools?.fetch?.enabled ?? true,
         },
         filesystem: {
-          enabled: input.features?.filesystem?.enabled ?? true,
+          enabled: input.tools?.filesystem?.enabled ?? true,
         },
         shell: {
-          enabled: input.features?.shell?.enabled ?? true,
+          enabled: input.tools?.shell?.enabled ?? true,
         },
         ltm: {
           enabled: ltm?.enabled ?? false,
@@ -133,6 +129,12 @@ const ConfigSchema = z
             },
           },
         },
+        mcp: {
+          enabled: input.tools?.mcp?.enabled ?? false,
+        },
+        skills: {
+          enabled: input.tools?.skills?.enabled ?? false,
+        },
       },
       compaction: input.compaction,
     };
@@ -141,10 +143,9 @@ const ConfigSchema = z
 export type ConfigData = z.infer<typeof ConfigSchema>;
 export type LlmConfig = z.infer<typeof LlmSchema>;
 export type CompactionConfig = ConfigData["compaction"];
-export type LtmConfig = ConfigData["features"]["ltm"];
-export type WikiConfig = ConfigData["features"]["wiki"];
+export type LtmConfig = ConfigData["tools"]["ltm"];
+export type WikiConfig = ConfigData["tools"]["wiki"];
 export type ToolsConfig = ConfigData["tools"];
-export type FeaturesConfig = ConfigData["features"];
 
 const defaultConfigData = (): ConfigData => ({
   name: "Hooman",
@@ -154,9 +155,6 @@ const defaultConfigData = (): ConfigData => ({
     params: {},
   },
   tools: {
-    allowed: [],
-  },
-  features: {
     fetch: {
       enabled: true,
     },
@@ -180,6 +178,12 @@ const defaultConfigData = (): ConfigData => ({
         collection: { wiki: "wiki" },
       },
     },
+    mcp: {
+      enabled: false,
+    },
+    skills: {
+      enabled: false,
+    },
   },
   compaction: {
     ratio: 0.75,
@@ -207,43 +211,38 @@ export class Config {
   get tools(): ToolsConfig {
     return {
       ...this.data.tools,
-      allowed: [...this.data.tools.allowed],
-    };
-  }
-
-  get compaction(): CompactionConfig {
-    return this.data.compaction;
-  }
-
-  get features(): FeaturesConfig {
-    return {
-      ...this.data.features,
-      fetch: { ...this.data.features.fetch },
-      filesystem: { ...this.data.features.filesystem },
-      shell: { ...this.data.features.shell },
+      fetch: { ...this.data.tools.fetch },
+      filesystem: { ...this.data.tools.filesystem },
+      shell: { ...this.data.tools.shell },
       ltm: {
-        ...this.data.features.ltm,
+        ...this.data.tools.ltm,
         chroma: {
-          ...this.data.features.ltm.chroma,
-          collection: { ...this.data.features.ltm.chroma.collection },
+          ...this.data.tools.ltm.chroma,
+          collection: { ...this.data.tools.ltm.chroma.collection },
         },
       },
       wiki: {
-        ...this.data.features.wiki,
+        ...this.data.tools.wiki,
         chroma: {
-          ...this.data.features.wiki.chroma,
-          collection: { ...this.data.features.wiki.chroma.collection },
+          ...this.data.tools.wiki.chroma,
+          collection: { ...this.data.tools.wiki.chroma.collection },
         },
       },
+      mcp: { ...this.data.tools.mcp },
+      skills: { ...this.data.tools.skills },
     };
   }
 
+  get compaction(): CompactionConfig {
+    return this.data.compaction;
+  }
+
   get ltm(): LtmConfig {
-    return this.features.ltm;
+    return this.tools.ltm;
   }
 
   get wiki(): WikiConfig {
-    return this.features.wiki;
+    return this.tools.wiki;
   }
 
   private readJson(): unknown {

package/src/core/index.ts

@@ -18,13 +18,19 @@ import {
   mcpJsonPath,
 } from "./utils/paths.ts";
 
+export type BootstrapMeta = {
+  userId?: string;
+  sessionId?: string;
+  acp?: AcpMeta;
+};
+
+export type AcpMeta = {
+  systemPrompt?: string;
+  mcpServers?: NamedMcpTransport[];
+};
+
 export async function bootstrap(
-  meta: {
-    userId?: string;
-    sessionId?: string;
-    systemPrompt?: string;
-    mcpServers?: NamedMcpTransport[];
-  },
+  meta: BootstrapMeta,
   print: boolean = false,
 ): Promise<{
   config: Config;
@@ -34,14 +40,18 @@ export async function bootstrap(
 }> {
   const config = new Config(configJsonPath());
   const mcpConfig = createMcpConfig(mcpJsonPath());
-  const mcpManager = createMcpManager(mcpConfig, meta.mcpServers ?? []);
+  const mcpManager = createMcpManager(
+    mcpConfig,
+    meta.acp !== undefined,
+    meta.acp?.mcpServers ?? [],
+  );
   const mcp = { config: mcpConfig, manager: mcpManager };
   const registry = createSkillsRegistry(basePath());
   const system = await createSystemPrompt(instructionsMdPath(), config);
   const agent = await createAgent(config, system, registry, mcp, print, {
     userId: meta?.userId ?? meta?.sessionId,
     sessionId: meta?.sessionId,
-    systemPrompt: meta?.systemPrompt,
+    systemPrompt: meta?.acp?.systemPrompt,
   });
   return { config, agent, mcp, registry };
 }

package/src/core/mcp/index.ts

@@ -5,11 +5,19 @@ import {
   HOOMAN_CHANNEL_PERMISSION,
   type ChannelMessage,
   type ChannelPermissionBehavior,
+  type ChannelSubscription,
+  type ChannelSubscriptionHandle,
 } from "./manager.ts";
 
 export { Config, Manager };
 export { HOOMAN_CHANNEL, HOOMAN_CHANNEL_PERMISSION };
-export type { ChannelMessage, ChannelPermissionBehavior, NamedMcpTransport };
+export type {
+  ChannelMessage,
+  ChannelPermissionBehavior,
+  ChannelSubscription,
+  ChannelSubscriptionHandle,
+  NamedMcpTransport,
+};
 export { createMcpTools } from "./tools.ts";
 
 export function createMcpConfig(path: string): Config {
@@ -18,7 +26,8 @@ export function createMcpConfig(path: string): Config {
 
 export function createMcpManager(
   config: Config,
+  acp = false,
   mcpServers: readonly NamedMcpTransport[] = [],
 ): Manager {
-  return new Manager(config, mcpServers);
+  return new Manager(config, acp, mcpServers);
 }

package/src/core/mcp/manager.ts

@@ -33,6 +33,16 @@ export type ChannelMessage = {
 
 export type ChannelPermissionBehavior = "allow_once" | "allow_always" | "deny";
 
+export type ChannelSubscription = {
+  server: string;
+  channel: string;
+};
+
+export type ChannelSubscriptionHandle = {
+  unsubscribe: () => void;
+  subscriptions: ChannelSubscription[];
+};
+
 type ChannelPermissionRequest = {
   requestId: string;
   tool: string;
@@ -111,7 +121,7 @@ function readSourceValue(value: unknown): string | undefined {
  */
 export class Manager {
   private instances: Map<string, McpClient> | null = null;
-  private readonly pendingPermissions = new Map<
+  private readonly permissions = new Map<
     string,
     {
       resolve: (behavior: ChannelPermissionBehavior) => void;
@@ -122,7 +132,8 @@ export class Manager {
 
   public constructor(
     private readonly config: Config,
-    private readonly mcpServers: readonly NamedMcpTransport[] = [],
+    private readonly acp = false,
+    private readonly servers: readonly NamedMcpTransport[] = [],
   ) {}
 
   /** Lazily builds clients from the current in-memory config (reloads file first). */
@@ -138,13 +149,15 @@ export class Manager {
    * previous clients (stdio subprocesses, HTTP sessions).
    */
   public reload(): void {
-    this.config.reload();
+    if (!this.acp) {
+      this.config.reload();
+    }
     const previous = this.instances;
     const next = new Map<string, McpClient>();
     const transports = [
-      ...this.config.list(),
-      // Session-scoped ACP servers intentionally override local config names.
-      ...this.mcpServers,
+      ...(this.acp ? [] : this.config.list()),
+      // Session-scoped servers override local config entries on name conflicts.
+      ...this.servers,
     ];
     for (const { name, transport } of transports) {
       next.set(
@@ -163,11 +176,11 @@ export class Manager {
   }
 
   public async disconnect(): Promise<void> {
-    for (const [key, pending] of this.pendingPermissions.entries()) {
+    for (const [key, pending] of this.permissions.entries()) {
       clearTimeout(pending.timer);
       pending.reject(new Error(`Pending permission "${key}" cancelled.`));
     }
-    this.pendingPermissions.clear();
+    this.permissions.clear();
     const toClose = this.instances;
     this.instances = null;
     if (!toClose?.size) {
@@ -224,7 +237,7 @@ export class Manager {
   public async subscribeToChannels(
     channels: readonly string[],
     onMessage: (message: ChannelMessage) => void,
-  ): Promise<() => void> {
+  ): Promise<ChannelSubscriptionHandle> {
     if (this.instances === null) {
       this.reload();
     }
@@ -234,10 +247,11 @@ export class Manager {
       ...new Set(channels.map((c) => c.trim()).filter(Boolean)),
     ];
     if (requested.length === 0) {
-      return () => {};
+      return { unsubscribe: () => {}, subscriptions: [] };
     }
 
     const unsubs: Array<() => void> = [];
+    const subscriptions: ChannelSubscription[] = [];
     for (const [server, client] of map.entries()) {
       await client.connect();
       const experimental =
@@ -270,11 +284,11 @@ export class Manager {
             return;
           }
           const key = `${server}:${requestId}`;
-          const pending = this.pendingPermissions.get(key);
+          const pending = this.permissions.get(key);
           if (!pending) {
             return;
           }
-          this.pendingPermissions.delete(key);
+          this.permissions.delete(key);
           clearTimeout(pending.timer);
           pending.resolve(behavior);
         };
@@ -289,6 +303,8 @@ export class Manager {
           continue;
         }
 
+        subscriptions.push({ server, channel });
+
         const method = `notifications/${channel}`;
         const schema = z.object({
           method: z.literal(method),
@@ -327,10 +343,13 @@ export class Manager {
       }
     }
 
-    return () => {
-      for (const off of unsubs) {
-        off();
-      }
+    return {
+      subscriptions,
+      unsubscribe: () => {
+        for (const off of unsubs) {
+          off();
+        }
+      },
     };
   }
 
@@ -374,21 +393,21 @@ export class Manager {
       throw new Error("requestId is required.");
     }
     const key = `${server}:${requestId}`;
-    if (this.pendingPermissions.has(key)) {
+    if (this.permissions.has(key)) {
       throw new Error(`Permission request "${requestId}" is already pending.`);
     }
 
     const response = new Promise<ChannelPermissionBehavior>(
       (resolve, reject) => {
         const timer = setTimeout(() => {
-          this.pendingPermissions.delete(key);
+          this.permissions.delete(key);
           reject(
             new Error(
               `Permission request "${requestId}" timed out after ${timeoutMs}ms.`,
             ),
           );
         }, timeoutMs);
-        this.pendingPermissions.set(key, { resolve, reject, timer });
+        this.permissions.set(key, { resolve, reject, timer });
       },
     );
 
@@ -423,10 +442,10 @@ export class Manager {
       });
       return await response;
     } catch (error) {
-      const pending = this.pendingPermissions.get(key);
+      const pending = this.permissions.get(key);
       if (pending) {
         clearTimeout(pending.timer);
-        this.pendingPermissions.delete(key);
+        this.permissions.delete(key);
       }
       throw error;
     }

package/src/core/prompts/system.ts

@@ -36,15 +36,17 @@ export class System {
     return STATIC_PROMPT_FILES.filter((file) => {
       switch (file) {
         case "ltm.md":
-          return this.config.features.ltm.enabled;
+          return this.config.tools.ltm.enabled;
         case "fetch.md":
-          return this.config.features.fetch.enabled;
+          return this.config.tools.fetch.enabled;
         case "filesystem.md":
-          return this.config.features.filesystem.enabled;
+          return this.config.tools.filesystem.enabled;
         case "shell.md":
-          return this.config.features.shell.enabled;
+          return this.config.tools.shell.enabled;
         case "wiki.md":
-          return this.config.features.wiki.enabled;
+          return this.config.tools.wiki.enabled;
+        case "skills.md":
+          return this.config.tools.skills.enabled;
         case "thinking.md":
         default:
           return true;
@@ -96,8 +98,8 @@ export class System {
     return {
       name: this.config.name,
       llm: this.config.llm,
-      ltm: this.config.features.ltm,
-      wiki: this.config.features.wiki,
+      ltm: this.config.tools.ltm,
+      wiki: this.config.tools.wiki,
       compaction: this.config.compaction,
     };
   }

package/src/core/tools/wiki.ts

@@ -353,14 +353,14 @@ function searchMetadata(page: PageRecord): Record<string, string | number> {
 export function createWikiTools(config: Config) {
   const root = wikiRoot();
   const client = new ChromaClient({
-    ...chromaClientArgsFromUrl(config.features.wiki.chroma.url),
+    ...chromaClientArgsFromUrl(config.tools.wiki.chroma.url),
   });
   let collectionPromise: Promise<Collection> | null = null;
 
   const collection = async (): Promise<Collection> => {
     if (!collectionPromise) {
       collectionPromise = client.getOrCreateCollection({
-        name: config.features.wiki.chroma.collection.wiki,
+        name: config.tools.wiki.chroma.collection.wiki,
         embeddingFunction: new HFEmbedding(),
       });
     }

package/src/daemon/index.ts

@@ -3,6 +3,7 @@ import type { Agent } from "@strands-agents/sdk";
 import { HOOMAN_CHANNEL } from "../core/mcp/index.ts";
 import type {
   ChannelMessage,
+  ChannelSubscription,
   Manager as McpManager,
 } from "../core/mcp/index.ts";
 import { createQueue } from "./queue.ts";
@@ -42,6 +43,18 @@ function resolveUserId(
   return `${message.meta.server}:${raw}`;
 }
 
+function formatSubscriptions(
+  subscriptions: readonly ChannelSubscription[],
+): string {
+  if (subscriptions.length === 0) {
+    return "none";
+  }
+  const servers = [
+    ...new Set(subscriptions.map((subscription) => subscription.server)),
+  ].sort((left, right) => left.localeCompare(right));
+  return `${servers.length} MCP server(s): ${servers.join(", ")}`;
+}
+
 export async function main(options: RunDaemonOptions): Promise<void> {
   if (!options.channels) {
     throw new Error("No daemon inputs enabled. Pass --channels.");
@@ -94,7 +107,7 @@ export async function main(options: RunDaemonOptions): Promise<void> {
     () => unsubscribe(),
   );
 
-  unsubscribe = await options.manager.subscribeToChannels(
+  const handle = await options.manager.subscribeToChannels(
     channels,
     (message) => {
       debug(
@@ -103,7 +116,8 @@ export async function main(options: RunDaemonOptions): Promise<void> {
       void queue.push(message);
     },
   );
-  debug(`subscribed to ${channels.length} channel(s)`);
+  unsubscribe = handle.unsubscribe;
+  debug(`subscribed → ${formatSubscriptions(handle.subscriptions)}`);
 
   try {
     await stop();