hoomanjs 1.9.0 → 1.10.0

package/README.md

@@ -103,12 +103,6 @@ Use a specific session id:
 hooman exec "What changed?" --session my-session
 ```
 
-Choose a toolkit size:
-
-```bash
-hooman exec "Summarize this repo" --toolkit lite
-```
-
 Skip interactive tool approval (allows every tool call; use only when you trust the prompt and environment):
 
 ```bash
@@ -135,12 +129,6 @@ Resume or pin a session id:
 hooman chat --session my-session
 ```
 
-Choose a toolkit size:
-
-```bash
-hooman chat --toolkit max
-```
-
 Skip the in-chat tool approval UI (same semantics as `exec --yolo`):
 
 ```bash
@@ -161,27 +149,20 @@ Resume or pin a session id:
 hooman daemon --session my-daemon --channels
 ```
 
-Choose a toolkit size:
-
-```bash
-hooman daemon --toolkit full --channels
-```
-
 Skip remote channel permission relay and allow every tool call from daemon turns (same risk profile as `exec` / `chat` with `--yolo`):
 
 ```bash
 hooman daemon --channels --yolo
 ```
 
-### Toolkit Levels
+### Feature Flags
 
-`exec`, `chat`, `daemon`, and `acp` support `-t, --toolkit <lite|full|max>`.
+Runtime tools and prompt sections are controlled from `config.json` under `features`:
 
-- `lite` - time, fetch, long-term-memory, installed skills, and configured MCP server tools
-- `full` - `lite` plus filesystem, shell, and thinking tools
-- `max` - `full` plus skills management tools and MCP config management tools
-
-Prompt loading follows the same split: filesystem / shell / thinking instructions are only included from `full` upward, while skills guidance is always included.
+- `features.fetch.enabled`
+- `features.filesystem.enabled`
+- `features.shell.enabled`
+- `features.ltm.enabled`
 
 ### `hooman configure`
 
@@ -206,12 +187,6 @@ Run Hooman as an Agent Client Protocol (ACP) agent over stdio.
 hooman acp
 ```
 
-Choose a toolkit size for ACP-created sessions:
-
-```bash
-hooman acp --toolkit max
-```
-
 ACP notes:
 
 - ACP sessions are stored under the active Hooman data directory in `acp-sessions/`
@@ -252,12 +227,23 @@ This is the shape managed by `hooman configure`:
   "tools": {
     "allowed": []
   },
-  "ltm": {
-    "enabled": false,
-    "chroma": {
-      "url": "http://127.0.0.1:8000",
-      "collection": {
-        "memory": "memory"
+  "features": {
+    "fetch": {
+      "enabled": true
+    },
+    "filesystem": {
+      "enabled": true
+    },
+    "shell": {
+      "enabled": true
+    },
+    "ltm": {
+      "enabled": false,
+      "chroma": {
+        "url": "http://127.0.0.1:8000",
+        "collection": {
+          "memory": "memory"
+        }
       }
     }
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hoomanjs",
-  "version": "1.9.0",
+  "version": "1.10.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

@@ -16,8 +16,6 @@ import {
 } from "@agentclientprotocol/sdk";
 import type { Agent as StrandsAgent } from "@strands-agents/sdk";
 import {
-  AfterToolCallEvent,
-  AgentResultEvent,
   BeforeToolCallEvent,
   isModelStreamEvent,
   Message,
@@ -27,7 +25,6 @@ import {
 import type { StopReason as StrandsStopReason } from "@strands-agents/sdk";
 import { bootstrap } from "../core/index.ts";
 import { runWithCwd } from "../core/utils/cwd-context.ts";
-import type { Toolkit } from "../core/toolkit.ts";
 import { acpSessionsRootPath } from "./utils/paths.ts";
 import { inferToolKind } from "./utils/tool-kind.ts";
 import { toolResultToAcpContent } from "./utils/tool-result-content.ts";
@@ -172,13 +169,11 @@ export class AcpAgent implements AgentContract {
   readonly #connection: AgentSideConnection;
   readonly #sessions = new Map<string, SessionRecord>();
   readonly #acpRoot: string;
-  readonly #toolkit: Toolkit;
   #version: string | null = null;
 
-  constructor(connection: AgentSideConnection, toolkit: Toolkit) {
+  constructor(connection: AgentSideConnection) {
     this.#connection = connection;
     this.#acpRoot = acpSessionsRootPath();
-    this.#toolkit = toolkit;
     queueMicrotask(() => {
       if (connection.signal.aborted) {
         void this.#disposeAllSessions();
@@ -342,7 +337,6 @@ export class AcpAgent implements AgentContract {
       {
         userId: bootstrapUserId,
         sessionId,
-        toolkit: this.#toolkit,
         mcpServers,
         ...(clientSystemPrompt ? { systemPrompt: clientSystemPrompt } : {}),
       },
@@ -440,7 +434,6 @@ export class AcpAgent implements AgentContract {
       {
         userId: bootstrapUserId,
         sessionId: params.sessionId,
-        toolkit: this.#toolkit,
         mcpServers,
         ...(clientSystemPrompt ? { systemPrompt: clientSystemPrompt } : {}),
       },
@@ -804,13 +797,13 @@ export class AcpAgent implements AgentContract {
   }
 }
 
-export async function runAcpStdio(toolkit: Toolkit = "full"): Promise<void> {
+export async function runAcpStdio(): Promise<void> {
   const stream = ndJsonStream(
     Writable.toWeb(stdout) as unknown as WritableStream<Uint8Array>,
     Readable.toWeb(stdin) as unknown as ReadableStream<Uint8Array>,
   );
   const connection = new AgentSideConnection(
-    (conn) => new AcpAgent(conn, toolkit),
+    (conn) => new AcpAgent(conn),
     stream,
   );
   await connection.closed;

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

@@ -45,11 +45,14 @@ export function applySessionConfigOption(
   }
   const chroma = config.ltm.chroma;
   config.update({
-    ltm: {
-      enabled: value === "on",
-      chroma: {
-        url: chroma.url,
-        collection: { memory: chroma.collection.memory },
+    features: {
+      ...config.features,
+      ltm: {
+        enabled: value === "on",
+        chroma: {
+          url: chroma.url,
+          collection: { memory: chroma.collection.memory },
+        },
       },
     },
   });

package/src/cli.ts

@@ -1,10 +1,8 @@
 #!/usr/bin/env bun
 
-import { Command, Option } from "commander";
+import { Command } from "commander";
 import { BeforeToolCallEvent } from "@strands-agents/sdk";
 import { bootstrap } from "./core/index.ts";
-import { TOOLKITS } from "./core/toolkit.ts";
-import type { Toolkit } from "./core/toolkit.ts";
 import { createToolApprovalHandler } from "./exec/approvals.ts";
 import { chat } from "./chat/index.tsx";
 import { configure } from "./configure/index.tsx";
@@ -37,15 +35,6 @@ async function readPackageMeta(): Promise<{
   };
 }
 
-function createToolkitOption(): Option {
-  return new Option(
-    "-t, --toolkit <toolkit>",
-    "Toolkit size to enable: lite, full, or max.",
-  )
-    .choices([...TOOLKITS])
-    .default("full");
-}
-
 const packageMeta = await readPackageMeta();
 
 const program = new Command()
@@ -60,21 +49,14 @@ program
   .argument("<prompt>", "Prompt to run once.")
   .option("-s, --session <id>", "Session ID to use.")
   .option("--yolo", "Allow all tools without prompting for approval.")
-  .addOption(createToolkitOption())
   .action(
-    async (
-      prompt: string,
-      options: { session?: string; toolkit?: Toolkit; yolo?: boolean },
-    ) => {
+    async (prompt: string, options: { session?: string; yolo?: boolean }) => {
       const sessionId = options.session?.trim() || crypto.randomUUID();
       const {
         config,
         agent,
         mcp: { manager },
-      } = await bootstrap(
-        { sessionId, toolkit: options.toolkit ?? "full" },
-        true,
-      );
+      } = await bootstrap({ sessionId }, true);
       agent.addHook(
         BeforeToolCallEvent,
         createToolApprovalHandler(config, { yolo: Boolean(options.yolo) }),
@@ -95,11 +77,10 @@ program
   .argument("[prompt]", "Optional initial prompt to run after startup.")
   .option("-s, --session <id>", "Session ID to use.")
   .option("--yolo", "Allow all tools without prompting for approval.")
-  .addOption(createToolkitOption())
   .action(
     async (
       prompt: string | undefined,
-      options: { session?: string; toolkit?: Toolkit; yolo?: boolean },
+      options: { session?: string; yolo?: boolean },
     ) => {
       const sessionId = options.session?.trim() || crypto.randomUUID();
       const {
@@ -107,10 +88,7 @@ program
         agent,
         mcp: { manager },
         registry,
-      } = await bootstrap(
-        { sessionId, toolkit: options.toolkit ?? "full" },
-        false,
-      );
+      } = await bootstrap({ sessionId }, false);
 
       try {
         await chat({
@@ -142,11 +120,9 @@ program
     "Log each MCP channel notification payload to the console.",
   )
   .option("--yolo", "Allow all tools without remote approval or prompts.")
-  .addOption(createToolkitOption())
   .action(
     async (options: {
       session?: string;
-      toolkit?: Toolkit;
       channels?: boolean;
       debug?: boolean;
       yolo?: boolean;
@@ -160,7 +136,6 @@ program
         {
           sessionId: session,
           userId: session,
-          toolkit: options.toolkit ?? "full",
         },
         true,
       );
@@ -198,9 +173,8 @@ program
   .description(
     "Run as an Agent Client Protocol (ACP) agent on stdio for ACP-compatible clients.",
   )
-  .addOption(createToolkitOption())
-  .action(async (options: { toolkit?: Toolkit }) => {
-    await runAcpStdio(options.toolkit ?? "full");
+  .action(async () => {
+    await runAcpStdio();
   });
 
 if (process.argv.slice(2).length === 0) {

package/src/configure/app.tsx

@@ -131,7 +131,7 @@ export function ConfigureApp({
         name: config.name,
         llm: config.llm,
         tools: config.tools,
-        ltm: config.ltm,
+        features: config.features,
         compaction: config.compaction,
       }) satisfies ConfigData,
     [config, revision],
@@ -445,27 +445,81 @@ export function ConfigureApp({
           }),
       },
       {
-        label: `Long-term memory • ${configData.ltm.enabled ? "Enabled" : "Disabled"}`,
+        label: `Fetch feature • ${configData.features.fetch.enabled ? "Enabled" : "Disabled"}`,
         value: () => {
           updateConfig(
             {
-              ltm: {
-                ...config.ltm,
-                enabled: !configData.ltm.enabled,
+              features: {
+                ...config.features,
+                fetch: {
+                  enabled: !configData.features.fetch.enabled,
+                },
+              },
+            },
+            `Fetch feature ${configData.features.fetch.enabled ? "disabled" : "enabled"}.`,
+          );
+          setScreen({ kind: "config" });
+        },
+      },
+      {
+        label: `Filesystem feature • ${configData.features.filesystem.enabled ? "Enabled" : "Disabled"}`,
+        value: () => {
+          updateConfig(
+            {
+              features: {
+                ...config.features,
+                filesystem: {
+                  enabled: !configData.features.filesystem.enabled,
+                },
+              },
+            },
+            `Filesystem feature ${configData.features.filesystem.enabled ? "disabled" : "enabled"}.`,
+          );
+          setScreen({ kind: "config" });
+        },
+      },
+      {
+        label: `Shell feature • ${configData.features.shell.enabled ? "Enabled" : "Disabled"}`,
+        value: () => {
+          updateConfig(
+            {
+              features: {
+                ...config.features,
+                shell: {
+                  enabled: !configData.features.shell.enabled,
+                },
+              },
+            },
+            `Shell feature ${configData.features.shell.enabled ? "disabled" : "enabled"}.`,
+          );
+          setScreen({ kind: "config" });
+        },
+      },
+      {
+        label: `Long-term memory • ${configData.features.ltm.enabled ? "Enabled" : "Disabled"}`,
+        value: () => {
+          updateConfig(
+            {
+              features: {
+                ...config.features,
+                ltm: {
+                  ...config.features.ltm,
+                  enabled: !configData.features.ltm.enabled,
+                },
               },
             },
-            `Long-term memory ${configData.ltm.enabled ? "disabled" : "enabled"}.`,
+            `Long-term memory ${configData.features.ltm.enabled ? "disabled" : "enabled"}.`,
           );
           setScreen({ kind: "config" });
         },
       },
       {
-        label: `Chroma URL • ${configData.ltm.chroma.url}`,
+        label: `Chroma URL • ${configData.features.ltm.chroma.url}`,
         value: () =>
           promptValue({
             title: "Update Chroma URL",
             label: "URL",
-            initialValue: configData.ltm.chroma.url,
+            initialValue: configData.features.ltm.chroma.url,
             onSubmit: async (value) => {
               const url = value.trim();
               if (!url) {
@@ -473,11 +527,14 @@ export function ConfigureApp({
               }
               updateConfig(
                 {
-                  ltm: {
-                    ...config.ltm,
-                    chroma: {
-                      ...config.ltm.chroma,
-                      url,
+                  features: {
+                    ...config.features,
+                    ltm: {
+                      ...config.features.ltm,
+                      chroma: {
+                        ...config.features.ltm.chroma,
+                        url,
+                      },
                     },
                   },
                 },
@@ -488,12 +545,12 @@ export function ConfigureApp({
           }),
       },
       {
-        label: `Chroma memory collection • ${configData.ltm.chroma.collection.memory}`,
+        label: `Chroma memory collection • ${configData.features.ltm.chroma.collection.memory}`,
         value: () =>
           promptValue({
             title: "Update Chroma memory collection",
             label: "Collection name",
-            initialValue: configData.ltm.chroma.collection.memory,
+            initialValue: configData.features.ltm.chroma.collection.memory,
             onSubmit: async (value) => {
               const memory = value.trim();
               if (!memory) {
@@ -501,11 +558,14 @@ export function ConfigureApp({
               }
               updateConfig(
                 {
-                  ltm: {
-                    ...config.ltm,
-                    chroma: {
-                      ...config.ltm.chroma,
-                      collection: { memory },
+                  features: {
+                    ...config.features,
+                    ltm: {
+                      ...config.features.ltm,
+                      chroma: {
+                        ...config.features.ltm.chroma,
+                        collection: { memory },
+                      },
                     },
                   },
                 },

package/src/core/agent/index.ts

@@ -1,11 +1,7 @@
 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,
-  createMcpTools,
-} from "../mcp";
+import { type Config as McpConfig, type Manager as McpManager } from "../mcp";
 import type { System as SystemPrompt } from "../prompts";
 import { skills as createSkillsPrompt } from "../prompts";
 import {
@@ -14,7 +10,6 @@ import {
   createLongTermMemoryTools,
 } from "../memory";
 import type { Registry } from "../skills";
-import { createSkillsTools } from "../skills";
 import {
   createFetchTools,
   createFilesystemTools,
@@ -22,8 +17,6 @@ import {
   createThinkingTools,
   createTimeTools,
 } from "../tools";
-import { toolkitAtLeast } from "../toolkit.ts";
-import type { Toolkit } from "../toolkit.ts";
 
 const SECTION_BREAK = "\n\n---\n\n";
 
@@ -37,15 +30,15 @@ export async function create(
     userId?: string;
     sessionId?: string;
     systemPrompt?: string;
-    toolkit?: Toolkit;
   },
 ): Promise<Agent> {
   const sessionId = meta.sessionId;
   const userId = meta.userId ?? sessionId;
-  const toolkit = meta.toolkit ?? "full";
   const llm = await modelProviders[config.llm.provider]!();
   const stm = createShortTermMemory(sessionId);
-  const ltm = config.ltm.enabled ? createLongTermMemoryStore(config) : null;
+  const ltm = config.features.ltm.enabled
+    ? createLongTermMemoryStore(config)
+    : null;
   const skills = await createSkillsPrompt(registry);
   const tools = await mcp.manager.listPrefixedTools();
   const append = await mcp.manager.listServerInstructions();
@@ -62,13 +55,11 @@ export async function create(
     },
     tools: [
       ...createTimeTools(),
-      ...createFetchTools(),
+      ...(config.features.fetch.enabled ? createFetchTools() : []),
       ...(ltm ? createLongTermMemoryTools(ltm) : []),
-      ...(toolkitAtLeast(toolkit, "full") ? createFilesystemTools() : []), // > lite
-      ...(toolkitAtLeast(toolkit, "full") ? createShellTools() : []),
-      ...(toolkitAtLeast(toolkit, "full") ? createThinkingTools() : []),
-      ...(toolkit === "max" ? createSkillsTools(registry) : []),
-      ...(toolkit === "max" ? createMcpTools(mcp.config) : []),
+      ...(config.features.filesystem.enabled ? createFilesystemTools() : []),
+      ...(config.features.shell.enabled ? createShellTools() : []),
+      ...createThinkingTools(),
       ...tools,
     ],
     printer: print,

package/src/core/config.ts

@@ -48,35 +48,70 @@ const LtmPartialSchema = z.object({
   chroma: ChromaPartialSchema.optional(),
 });
 
+const FeatureTogglePartialSchema = z.object({
+  enabled: z.boolean().optional(),
+});
+
+const FeaturesPartialSchema = z.object({
+  fetch: FeatureTogglePartialSchema.optional(),
+  filesystem: FeatureTogglePartialSchema.optional(),
+  shell: FeatureTogglePartialSchema.optional(),
+  ltm: LtmPartialSchema.optional(),
+});
+
 const ToolsPartialSchema = z.object({
   allowed: z.array(z.string().min(1)).default([]),
 });
 
-const ConfigSchema = z.object({
-  name: z.string().min(1),
-  llm: LlmSchema,
-  tools: ToolsPartialSchema.default({ allowed: [] }),
-  ltm: LtmPartialSchema.nullish().transform((ltm) => ({
-    enabled: ltm?.enabled ?? false,
-    chroma: {
-      url: ltm?.chroma?.url ?? DEFAULT_CHROMA.url,
-      collection: {
-        memory:
-          ltm?.chroma?.collection?.memory ?? DEFAULT_CHROMA.collection.memory,
+const ConfigSchema = z
+  .object({
+    name: z.string().min(1),
+    llm: LlmSchema,
+    tools: ToolsPartialSchema.default({ allowed: [] }),
+    features: FeaturesPartialSchema.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;
+    return {
+      name: input.name,
+      llm: input.llm,
+      tools: input.tools,
+      features: {
+        fetch: {
+          enabled: input.features?.fetch?.enabled ?? true,
+        },
+        filesystem: {
+          enabled: input.features?.filesystem?.enabled ?? true,
+        },
+        shell: {
+          enabled: input.features?.shell?.enabled ?? true,
+        },
+        ltm: {
+          enabled: ltm?.enabled ?? false,
+          chroma: {
+            url: ltm?.chroma?.url ?? DEFAULT_CHROMA.url,
+            collection: {
+              memory:
+                ltm?.chroma?.collection?.memory ??
+                DEFAULT_CHROMA.collection.memory,
+            },
+          },
+        },
       },
-    },
-  })),
-  compaction: CompactionPartialSchema.nullish().transform((c) => ({
-    ratio: c?.ratio ?? DEFAULT_COMPACTION.ratio,
-    keep: c?.keep ?? DEFAULT_COMPACTION.keep,
-  })),
-});
+      compaction: input.compaction,
+    };
+  });
 
 export type ConfigData = z.infer<typeof ConfigSchema>;
 export type LlmConfig = z.infer<typeof LlmSchema>;
 export type CompactionConfig = ConfigData["compaction"];
-export type LtmConfig = ConfigData["ltm"];
+export type LtmConfig = ConfigData["features"]["ltm"];
 export type ToolsConfig = ConfigData["tools"];
+export type FeaturesConfig = ConfigData["features"];
 
 const defaultConfigData = (): ConfigData => ({
   name: "Hooman",
@@ -88,11 +123,22 @@ const defaultConfigData = (): ConfigData => ({
   tools: {
     allowed: [],
   },
-  ltm: {
-    enabled: false,
-    chroma: {
-      url: "http://127.0.0.1:8000",
-      collection: { memory: "memory" },
+  features: {
+    fetch: {
+      enabled: true,
+    },
+    filesystem: {
+      enabled: true,
+    },
+    shell: {
+      enabled: true,
+    },
+    ltm: {
+      enabled: false,
+      chroma: {
+        url: "http://127.0.0.1:8000",
+        collection: { memory: "memory" },
+      },
     },
   },
   compaction: {
@@ -129,8 +175,24 @@ export class Config {
     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 },
+      ltm: {
+        ...this.data.features.ltm,
+        chroma: {
+          ...this.data.features.ltm.chroma,
+          collection: { ...this.data.features.ltm.chroma.collection },
+        },
+      },
+    };
+  }
+
   get ltm(): LtmConfig {
-    return this.data.ltm;
+    return this.features.ltm;
   }
 
   private readJson(): unknown {

package/src/core/index.ts

@@ -11,7 +11,6 @@ import {
 import { createSkillsRegistry } from "./skills/index.ts";
 import type { Registry } from "./skills/index.ts";
 import { system as createSystemPrompt } from "./prompts/index.ts";
-import type { Toolkit } from "./toolkit.ts";
 import {
   basePath,
   configJsonPath,
@@ -25,7 +24,6 @@ export async function bootstrap(
     sessionId?: string;
     systemPrompt?: string;
     mcpServers?: NamedMcpTransport[];
-    toolkit?: Toolkit;
   },
   print: boolean = false,
 ): Promise<{
@@ -39,17 +37,11 @@ export async function bootstrap(
   const mcpManager = createMcpManager(mcpConfig, meta.mcpServers ?? []);
   const mcp = { config: mcpConfig, manager: mcpManager };
   const registry = createSkillsRegistry(basePath());
-  const toolkit = meta.toolkit ?? "max";
-  const system = await createSystemPrompt(
-    instructionsMdPath(),
-    config,
-    toolkit,
-  );
+  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,
-    toolkit,
   });
   return { config, agent, mcp, registry };
 }

package/src/core/prompts/index.ts

@@ -1,17 +1,12 @@
 import type { Config } from "../config.ts";
 import type { Registry } from "../skills/registry.ts";
-import type { Toolkit } from "../toolkit.ts";
 import { Skills } from "./skills.ts";
 import { System } from "./system.ts";
 
 export { Skills, System };
 
-export async function system(
-  path: string,
-  config: Config,
-  toolkit: Toolkit,
-): Promise<System> {
-  const prompt = new System(path, config, toolkit);
+export async function system(path: string, config: Config): Promise<System> {
+  const prompt = new System(path, config);
   await prompt.reload();
   return prompt;
 }

package/src/core/prompts/system.ts

@@ -3,8 +3,6 @@ import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { compile } from "handlebars";
 import type { Config } from "../config.ts";
-import type { Toolkit } from "../toolkit.ts";
-import { toolkitAtLeast } from "../toolkit.ts";
 
 /** Bundled markdown next to this module (`prompts/static/`). */
 const STATIC_PROMPT_FILES = [
@@ -26,26 +24,25 @@ const SECTION_BREAK = "\n\n---\n\n";
 export class System {
   private readonly path: string;
   private readonly config: Config;
-  private readonly toolkit: Toolkit;
   private data = "";
 
-  public constructor(path: string, config: Config, toolkit: Toolkit) {
+  public constructor(path: string, config: Config) {
     this.path = path;
     this.config = config;
-    this.toolkit = toolkit;
   }
 
   private staticPromptFiles(): readonly (typeof STATIC_PROMPT_FILES)[number][] {
     return STATIC_PROMPT_FILES.filter((file) => {
       switch (file) {
         case "ltm.md":
-          return this.config.ltm.enabled;
+          return this.config.features.ltm.enabled;
+        case "fetch.md":
+          return this.config.features.fetch.enabled;
         case "filesystem.md":
-        case "thinking.md":
+          return this.config.features.filesystem.enabled;
         case "shell.md":
-          return toolkitAtLeast(this.toolkit, "full");
-        case "skills.md":
-          return this.toolkit === "max";
+          return this.config.features.shell.enabled;
+        case "thinking.md":
         default:
           return true;
       }
@@ -96,7 +93,7 @@ export class System {
     return {
       name: this.config.name,
       llm: this.config.llm,
-      ltm: this.config.ltm,
+      ltm: this.config.features.ltm,
       compaction: this.config.compaction,
     };
   }

package/src/core/toolkit.ts

@@ -1,13 +0,0 @@
-export const TOOLKITS = ["lite", "full", "max"] as const;
-
-export type Toolkit = (typeof TOOLKITS)[number];
-
-const TOOLKIT_RANK: Record<Toolkit, number> = {
-  lite: 0,
-  full: 1,
-  max: 2,
-};
-
-export function toolkitAtLeast(actual: Toolkit, minimum: Toolkit): boolean {
-  return TOOLKIT_RANK[actual] >= TOOLKIT_RANK[minimum];
-}