@tyvm/knowhow 0.0.107 → 0.0.108-dev.bd8f104-dev.bd8f104-dev.bd8f104

package/README.md

@@ -362,3 +362,48 @@ For command usage and behavior details, see:
 - Website: https://knowhow.tyvm.ai
 - Twitter/X: https://x.com/micahriggan
 - npm: https://www.npmjs.com/package/@tyvm/knowhow
+
+---
+
+## 🚧 Dev & Nightly Releases
+
+Knowhow publishes unstable/preview builds under separate npm dist-tags so that regular users on `latest` are never affected.
+
+### Installing a pre-release build
+
+```bash
+# Latest nightly (date-stamped)
+npm install -g @tyvm/knowhow@nightly
+
+# Latest dev snapshot (git-hash-stamped)
+npm install -g @tyvm/knowhow@dev
+
+# Pin a specific pre-release version
+npm install -g @tyvm/knowhow@0.0.108-nightly.20250428
+```
+
+### How dist-tags work
+
+| Tag | Installed by default? | Audience |
+|-----|-----------------------|---------|
+| `latest` | ✅ Yes (`npm install @tyvm/knowhow`) | All stable users |
+| `nightly` | ❌ No (must opt-in) | Testers / early adopters |
+| `dev` | ❌ No (must opt-in) | Developers / contributors |
+
+Publishing a `nightly` or `dev` release **never moves the `latest` tag**, so existing users won't receive unstable code through normal updates.
+
+### Publishing scripts (for maintainers)
+
+```bash
+# Publish a date-stamped nightly (e.g. 0.0.108-nightly.20250428)
+npm run publish:nightly
+
+# Publish a git-hash-stamped dev snapshot (e.g. 0.0.108-dev.abc1234)
+npm run publish:dev
+
+# Publish a stable release to `latest`
+npm version patch   # or minor / major
+npm run publish:stable
+```
+
+> **Note:** `publish:nightly` and `publish:dev` automatically version-bump the `package.json` with a pre-release suffix before publishing and do **not** create a git tag, keeping your git history clean.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tyvm/knowhow",
-  "version": "0.0.107",
+  "version": "0.0.108-dev.bd8f104-dev.bd8f104-dev.bd8f104",
   "description": "ai cli with plugins and agents",
   "main": "ts_build/src/index.js",
   "bin": {
@@ -21,7 +21,13 @@
     "lint": "tslint ./src/**/*.ts",
     "lint:deps": "depcheck --config=.depcheckrc",
     "lint:all": "npm run lint && npm run lint:deps",
-    "check:model-pricing": "ts-node scripts/check-model-pricing.ts"
+    "check:model-pricing": "ts-node scripts/check-model-pricing.ts",
+    "version:nightly": "bash scripts/publish.sh version:nightly",
+    "version:dev": "bash scripts/publish.sh version:dev",
+    "publish:nightly": "bash scripts/publish.sh nightly",
+    "publish:dev": "bash scripts/publish.sh dev",
+    "publish:latest": "bash scripts/publish.sh stable",
+    "publish:stable": "bash scripts/publish.sh stable"
   },
   "keywords": [],
   "author": "Micah Riggan",

package/scripts/publish.sh

@@ -0,0 +1,70 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+COMMAND="${1:-}"
+
+get_current_version() {
+  node -e "process.stdout.write(require('./package.json').version)"
+}
+
+version_nightly() {
+  local version
+  version=$(get_current_version)
+  local stamp
+  stamp=$(date -u +%Y%m%d)
+  local pre="${version}-nightly.${stamp}"
+  echo "Bumping version to: $pre"
+  npm version "$pre" --no-git-tag-version
+}
+
+version_dev() {
+  local version
+  version=$(get_current_version)
+  local hash
+  hash=$(git rev-parse --short HEAD)
+  local pre="${version}-dev.${hash}"
+  echo "Bumping version to: $pre"
+  npm version "$pre" --no-git-tag-version
+}
+
+case "$COMMAND" in
+  nightly)
+    echo "🌙 Publishing nightly release..."
+    npm run compile
+    bash scripts/check-isolated-deps.sh
+    version_nightly
+    npm publish --tag nightly
+    echo "✅ Nightly published!"
+    ;;
+  dev)
+    echo "🔧 Publishing dev release..."
+    npm run compile
+    bash scripts/check-isolated-deps.sh
+    version_dev
+    npm publish --tag dev
+    echo "✅ Dev release published!"
+    ;;
+  stable|latest)
+    echo "🚀 Publishing stable release..."
+    npm run compile
+    bash scripts/check-isolated-deps.sh
+    npm publish --tag latest
+    echo "✅ Stable release published!"
+    ;;
+  version:nightly)
+    version_nightly
+    ;;
+  version:dev)
+    version_dev
+    ;;
+  *)
+    echo "Usage: $0 <nightly|dev|stable|version:nightly|version:dev>"
+    echo ""
+    echo "  nightly        - Compile, check deps, bump version with nightly stamp, publish to 'nightly' tag"
+    echo "  dev            - Compile, check deps, bump version with git hash, publish to 'dev' tag"
+    echo "  stable         - Compile, check deps, publish to 'latest' tag"
+    echo "  version:nightly - Only bump version with nightly stamp (no publish)"
+    echo "  version:dev     - Only bump version with git hash (no publish)"
+    exit 1
+    ;;
+esac

package/src/agents/base/base.ts

@@ -713,6 +713,7 @@ export abstract class BaseAgent implements IAgent {
         messages,
         tools: this.getEnabledTools(),
         tool_choice: "auto",
+        long_ttl_cache: this.runTime() > 300_000,
       });
 
       // If the agent was paused while the completion was in-flight, wait here

package/src/agents/tools/execCommand.ts

@@ -3,6 +3,7 @@ import { promisify } from "util";
 import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
+import { services, ToolsService } from "../../services";
 
 export const execAsync = promisify(exec);
 
@@ -256,16 +257,32 @@ const execWithTimeout = async (
 };
 
 // Public tool
-export const execCommand = async (
+export async function execCommand(
   command: string,
   timeout?: number,
   continueInBackground?: boolean,
   logFileName?: string
-): Promise<string> => {
-  if(!command || typeof command !== "string") {
+): Promise<string> {
+  if (!command || typeof command !== "string") {
     throw new Error("Invalid command. We received a non-string value. Please ensure you are sending strings of 4k tokens or less.");
   }
 
+  // Get context from bound ToolsService (same pattern as writeFile)
+  const toolService = (
+    this instanceof ToolsService ? this : services().Tools
+  ) as ToolsService;
+  const context = toolService.getContext();
+
+  // Emit pre-run blocking event — handlers can throw to block the command
+  if (context.Events) {
+    await context.Events.emitBlocking("exec:pre-run", {
+      command,
+      timeout,
+      continueInBackground,
+      logFileName,
+    });
+  }
+
   const { stdout, stderr, timedOut, killed, pid, logPath } =
     await execWithTimeout(command, {
       timeout,
@@ -298,6 +315,32 @@ export const execCommand = async (
    *    : "";
    */
 
-  // return `$ ${command}${statusMsg}\n${trimmed}${trimmedMsg}`;
-  return `$ ${command}${statusMsg}\n${output}`;
-};
+  const result = `$ ${command}${statusMsg}\n${output}`;
+
+  // Emit post-run blocking event — handlers can append extra context
+  let eventResults: any[] = [];
+  if (context.Events) {
+    eventResults = await context.Events.emitBlocking("exec:post-run", {
+      command,
+      timeout,
+      continueInBackground,
+      logFileName,
+      stdout,
+      stderr,
+      timedOut,
+      killed,
+      pid,
+      logPath,
+      output,
+    });
+  }
+
+  // Append any additional context returned by post-run handlers
+  let eventResultsText = "";
+  if (eventResults && eventResults.length > 0) {
+    eventResultsText =
+      "\n\nAdditional Information:\n" + JSON.stringify(eventResults, null, 2);
+  }
+
+  return result + eventResultsText;
+};

package/src/chat/modules/AgentModule.ts

@@ -30,11 +30,7 @@ import {
   Base64ImageProcessor,
 } from "../../processors/index";
 import { TaskInfo } from "../types";
-import {
-  createAgent,
-  agentConstructors,
-  AgentName,
-} from "../../agents";
+import { createAgent, agentConstructors, AgentName } from "../../agents";
 import { ToolCallEvent } from "../../agents/base/base";
 import { KnowhowSimpleClient } from "../../services/KnowhowClient";
 
@@ -80,7 +76,6 @@ export class AgentModule extends BaseChatModule {
     this.remoteSyncModule = module;
   }
 
-
   getCommands(): ChatCommand[] {
     return [
       {
@@ -260,7 +255,10 @@ export class AgentModule extends BaseChatModule {
         if (context) {
           // Create a temporary agent instance to read its default model/provider
           const agentContext = services().Agents.getAgentContext();
-          const tempAgent = createAgent(agentName as AgentName, agentContext) as BaseAgent;
+          const tempAgent = createAgent(
+            agentName as AgentName,
+            agentContext
+          ) as BaseAgent;
           context.selectedAgent = tempAgent;
           context.agentMode = true;
           context.currentAgent = agentName;
@@ -455,7 +453,6 @@ export class AgentModule extends BaseChatModule {
       const agentNames = Object.keys(agentConstructors);
 
       if (agentNames.length > 0) {
-
         console.log("\nAvailable agents:");
         agentNames.forEach((name) => {
           console.log(`  - ${name}`);
@@ -503,39 +500,52 @@ export class AgentModule extends BaseChatModule {
         console.error(`Session ${sessionId} not found.`);
         return;
       }
-      const lastThread = session.threads[session.threads.length - 1];
       console.log(`\n🔄 Resuming session: ${sessionId}`);
       console.log(`Agent: ${session.agentName}`);
       console.log(`Original task: ${session.initialInput}`);
       console.log(`Status: ${session.status}`);
 
-      const reason = resumeReason
-        ? `Reason for resuming:  ${resumeReason}`
-        : "";
-
-      // Create resume prompt
-      const resumePrompt = `You are resuming a previously started task. Here's the context:
-ORIGINAL REQUEST:
-      ${session.initialInput}
-
-LAST Progress State:
-      ${JSON.stringify(lastThread)}
-
-Please continue from where you left off and complete the original request.
-        ${reason}
-
-`;
+      // Build resume prompt (same pattern as resumeFromMessages)
+      const resumePrompt = [
+        "You are resuming a previously started task.",
+        session.initialInput ? `ORIGINAL REQUEST: ${session.initialInput}` : "",
+        "Please continue from where you left off and complete the original request.",
+        resumeReason ? `Reason for resuming: ${resumeReason}` : "",
+      ]
+        .filter(Boolean)
+        .join("\n");
+
+      // Restore the full message history from the last thread
+      const threads = session.threads || [];
+      const lastThread = threads.length > 0 ? threads[threads.length - 1] : [];
+      const resumeMessages = [...lastThread];
+
+      // Append the resume prompt to the last user message (or add a new one)
+      const reversedIndex = [...lastThread]
+        .reverse()
+        .findIndex((e) => e.role === "user" && typeof e.content === "string");
+
+      if (reversedIndex === -1) {
+        resumeMessages.push({ role: "user", content: resumePrompt });
+      } else {
+        const actualIndex = lastThread.length - 1 - reversedIndex;
+        resumeMessages[actualIndex] = {
+          ...resumeMessages[actualIndex],
+          content: resumeMessages[actualIndex].content + `\n\n<Workflow>[RESUME CONTEXT]: ${resumePrompt}</Workflow>`,
+        };
+      }
 
       console.log("🚀 Session resuming...");
       const context = this.chatService?.getContext();
       const agentName = session.agentName || context.currentAgent;
+      const previousAgentMode = context?.agentMode;
 
       if (!agentName || !agentConstructors[agentName as AgentName]) {
         console.error(`Agent ${agentName} not found.`);
         return;
       }
 
-      // Start agent with Knowhow task context if available
+      // Start agent with Knowhow task context and restored message history
       const { agent, taskId } = await this.setupAgent({
         agentName,
         input: resumePrompt,
@@ -544,7 +554,20 @@ Please continue from where you left off and complete the original request.
         chatHistory: [],
         run: false, // Don't run yet, we need to set up event listeners first
       });
-      await this.attachedAgentChatLoop(taskId, agent, resumePrompt);
+
+      // After resume finishes, revert to normal chat (non-agent mode) so the
+      // user can start a fresh conversation instead of staying locked in agent mode.
+      agent.agentEvents.once(agent.eventTypes.done, () => {
+        const ctx = this.chatService?.getContext();
+        if (ctx && !previousAgentMode) {
+          ctx.agentMode = false;
+          ctx.selectedAgent = undefined;
+          ctx.currentAgent = undefined;
+          this.chatService?.disableMode("agent");
+        }
+      });
+
+      await this.attachedAgentChatLoop(taskId, agent, resumePrompt, resumeMessages);
     } catch (error) {
       console.error(
         `Failed to resume session ${sessionId}:`,
@@ -1033,7 +1056,8 @@ Please continue from where you left off and complete the original request.
   async attachedAgentChatLoop(
     taskId: string,
     agent: AttachableAgent,
-    initialInput?: string
+    initialInput?: string,
+    initialMessages?: any[]
   ): Promise<void> {
     try {
       let agentFinalOutput: string | undefined;
@@ -1075,7 +1099,7 @@ Please continue from where you left off and complete the original request.
 
           if (context.chatHistory) {
             const found = context.chatHistory.find((h) => h.taskId === taskId);
-            found.output = agentFinalOutput;
+            if (found) found.output = agentFinalOutput;
           }
 
           resolve("done");
@@ -1088,7 +1112,8 @@ Please continue from where you left off and complete the original request.
       if (initialInput) {
         const taskInfo = this.taskRegistry.get(taskId);
         (agent as BaseAgent).call(
-          taskInfo?.formattedPrompt || taskInfo?.initialInput || initialInput
+          taskInfo?.formattedPrompt || taskInfo?.initialInput || initialInput,
+          initialMessages
         );
       }
     } catch (error) {

package/src/chat/modules/SessionsModule.ts

@@ -304,15 +304,20 @@ export class SessionsModule extends BaseChatModule {
   async handleResumeCommand(args: string[]): Promise<void> {
     const sessionManager = this.agentModule.getSessionManager();
 
-    if (args.length === 0) {
+    if (args.length === 0 || args[0] === "--all") {
       // Interactive: show saved sessions for selection
-      const savedSessions = sessionManager.listAvailableSessions();
+      const showAll = args[0] === "--all";
+      const allSessions = sessionManager.listAvailableSessions();
+      const savedSessions = showAll ? allSessions : allSessions.slice(0, 10);
       if (savedSessions.length === 0) {
         console.log("No saved sessions found to resume.");
         return;
       }
 
       this.printSavedSessionsTable(savedSessions);
+      if (!showAll && allSessions.length > 10) {
+        console.log(`   ... and ${allSessions.length - 10} more. Use /resume --all to see all sessions.`);
+      }
 
       const allIds = savedSessions.map((s) => s.sessionId);
       const selectedId = await this.selectByNumber(

package/src/cli.ts

@@ -530,12 +530,17 @@ async function main() {
     .description("Create or sync a cloud worker with your local knowhow config")
     .option("--create", "Create a new cloud worker with synced config and files")
     .option("--push <uid>", "Push/sync local config and files to an existing cloud worker")
+    .option("--pull <id>", "Pull the latest workerConfigJson from a cloud worker and update local config")
     .option("--name <name>", "Name for the cloud worker (used with --create)")
     .option("--dry-run", "Print what would be synced without doing it")
     .action(async (options) => {
       try {
-        const { cloudWorker } = await import("./cloudWorker");
-        await cloudWorker(options);
+        const { cloudWorker, pullCloudWorkerConfig } = await import("./cloudWorker");
+        if (options.pull) {
+          await pullCloudWorkerConfig({ id: options.pull });
+        } else {
+          await cloudWorker(options);
+        }
       } catch (error) {
         console.error("Error running cloudworker:", error);
         process.exit(1);

package/src/clients/anthropic.ts

@@ -40,11 +40,11 @@ export class GenericAnthropicClient implements GenericClient {
     });
   }
 
-  handleToolCaching(tools: Anthropic.Tool[]) {
+  handleToolCaching(tools: Anthropic.Tool[], longTtl = false) {
     const lastTool = tools[tools.length - 1];
 
     if (lastTool) {
-      lastTool.cache_control = { type: "ephemeral" };
+      lastTool.cache_control = longTtl ? { type: "ephemeral", ttl: "1h" } as any : { type: "ephemeral" };
     }
   }
 
@@ -94,7 +94,7 @@ export class GenericAnthropicClient implements GenericClient {
     return cleaned;
   }
 
-  transformTools(tools?: Tool[]): Anthropic.Tool[] {
+  transformTools(tools?: Tool[], longTtl = false): Anthropic.Tool[] {
     if (!tools) {
       return [];
     }
@@ -104,7 +104,7 @@ export class GenericAnthropicClient implements GenericClient {
       input_schema: this.cleanSchemaForAnthropic(tool.function.parameters) as any,
     }));
 
-    this.handleToolCaching(transformed);
+    this.handleToolCaching(transformed, longTtl);
 
     return transformed;
   }
@@ -153,16 +153,16 @@ export class GenericAnthropicClient implements GenericClient {
     return messages;
   }
 
-  cacheLastContent(message: MessageParam) {
+  cacheLastContent(message: MessageParam, longTtl = false) {
     if (Array.isArray(message.content)) {
       const lastMessage = message.content[message.content.length - 1];
       if (
         lastMessage.type !== "thinking" &&
         lastMessage.type !== "redacted_thinking"
       ) {
-        lastMessage.cache_control = {
-          type: "ephemeral",
-        };
+        lastMessage.cache_control = longTtl
+          ? ({ type: "ephemeral", ttl: "1h" } as any)
+          : { type: "ephemeral" };
       }
     }
   }
@@ -179,7 +179,7 @@ export class GenericAnthropicClient implements GenericClient {
     }
   }
 
-  handleMessageCaching(groupedMessages: MessageParam[]) {
+  handleMessageCaching(groupedMessages: MessageParam[], longTtl = false) {
     this.handleClearingCache(groupedMessages);
 
     // find the last two messages and mark them as ephemeral
@@ -189,7 +189,7 @@ export class GenericAnthropicClient implements GenericClient {
 
     for (const m of lastTwoUserMessages) {
       if (Array.isArray(m.content)) {
-        this.cacheLastContent(m);
+        this.cacheLastContent(m, longTtl);
       }
     }
   }
@@ -203,7 +203,7 @@ export class GenericAnthropicClient implements GenericClient {
     }
   }
 
-  transformMessages(messages: Message[]): MessageParam[] {
+  transformMessages(messages: Message[], longTtl = false): MessageParam[] {
     const toolCalls = messages.flatMap((msg) => msg.tool_calls || []);
     const claudeMessages: MessageParam[] = messages
       .filter((msg) => msg.role !== "system")
@@ -302,7 +302,7 @@ export class GenericAnthropicClient implements GenericClient {
 
     const groupedMessages = this.combineMessages(claudeMessages);
 
-    this.handleMessageCaching(groupedMessages);
+    this.handleMessageCaching(groupedMessages, longTtl);
 
     return groupedMessages;
   }
@@ -349,14 +349,15 @@ export class GenericAnthropicClient implements GenericClient {
   async createChatCompletion(
     options: CompletionOptions
   ): Promise<CompletionResponse> {
+    const longTtl = !!options.long_ttl_cache;
     const systemMessage = options.messages
       .filter((msg) => msg.role === "system")
       .map((msg) => msg.content || "")
       .join("\n");
 
-    const claudeMessages = this.transformMessages(options.messages);
+    const claudeMessages = this.transformMessages(options.messages, longTtl);
 
-    const tools = this.transformTools(options.tools);
+    const tools = this.transformTools(options.tools, longTtl);
     try {
       const response = await this.client.messages.create({
         model: options.model,
@@ -365,7 +366,7 @@ export class GenericAnthropicClient implements GenericClient {
           ? [
               {
                 text: systemMessage,
-                cache_control: { type: "ephemeral" },
+                cache_control: longTtl ? ({ type: "ephemeral", ttl: "1h" } as any) : { type: "ephemeral" },
                 type: "text",
               },
             ]
@@ -413,6 +414,8 @@ export class GenericAnthropicClient implements GenericClient {
 
         model: options.model,
         usage: response.usage ? {
+          input_tokens: response.usage.input_tokens ?? 0,
+          output_tokens: response.usage.output_tokens ?? 0,
           prompt_tokens: response.usage.input_tokens ?? 0,
           completion_tokens: response.usage.output_tokens ?? 0,
           total_tokens: (response.usage.input_tokens ?? 0) + (response.usage.output_tokens ?? 0),
@@ -422,7 +425,7 @@ export class GenericAnthropicClient implements GenericClient {
         usd_cost: this.calculateCost(options.model, response.usage),
       };
     } catch (err) {
-      if ("headers" in err && err.headers["x-should-retry"] === "true") {
+      if ("headers" in err && err.headers?.["x-should-retry"] === "true") {
         console.warn("Retrying failed request", err);
         await wait(2500);
         return this.createChatCompletion(options);

package/src/clients/types.ts

@@ -61,6 +61,13 @@ export interface CompletionOptions {
    *  Maps to: OpenAI reasoning_effort, xAI reasoning.effort, Gemini thinkingLevel/thinkingBudget, Anthropic thinking budget.
    *  "low" = minimal thinking, "medium" = balanced, "high" = maximum reasoning */
   reasoning_effort?: "low" | "medium" | "high";
+  /**
+   * When true, hints to the client that this task is long-running and it should
+   * use a long-TTL cache where available.
+   * - Anthropic: enables the `extended-cache-ttl-2025-02-19` beta and sets
+   *   `cache_control.ttl` to 3600 (1 hour) instead of the default 5-minute ephemeral cache.
+   */
+  long_ttl_cache?: boolean;
 }
 
 /**
@@ -73,6 +80,10 @@ export interface TokenUsage {
   prompt_tokens: number;
   /** Total output/completion tokens generated */
   completion_tokens: number;
+  /** Alternative field name for input tokens (some providers use this) */
+  input_tokens?: number;
+  /** Alternative field name for output tokens (some providers use this) */
+  output_tokens?: number;
   /** Convenience total (prompt + completion) */
   total_tokens?: number;
   /** Cache details */

package/src/cloudWorker.ts

@@ -4,9 +4,14 @@ import { KnowhowSimpleClient, KNOWHOW_API_URL } from "./services/KnowhowClient";
 import { loadJwt } from "./login";
 import { getConfig, updateConfig, getLanguageConfig } from "./config";
 import { services } from "./services";
-import { Language, Config } from "./types";
+import { Language, Config, McpConfig } from "./types";
 import { S3Service } from "./services/S3";
 
+export interface CloudWorkerPullOptions {
+  id: string;
+  apiUrl?: string;
+}
+
 export interface CloudWorkerOptions {
   create?: boolean;
   push?: string; // uid of existing cloud worker
@@ -330,3 +335,72 @@ export async function cloudWorker(options: CloudWorkerOptions) {
     console.log(`\n✅ Cloud worker sync complete!`);
   }
 }
+
+/**
+ * Pull the latest workerConfigJson from the cloud worker API and update the
+ * local knowhow.json config to match.
+ *
+ * This is the "pull" half of the config sync cycle.  After running this,
+ * you can reload the worker's MCPs (in-process) via the reloadConfig
+ * WebSocket message or by calling `knowhow worker` again.
+ *
+ * Merged fields from workerConfigJson:
+ *   - mcps        → overwrites config.mcps
+ *   - modules     → overwrites config.modules  (optional, only if present)
+ *   - plugins     → overwrites config.plugins  (optional, only if present)
+ *   - agents      → overwrites config.agents   (optional, only if present)
+ */
+export async function pullCloudWorkerConfig(options: CloudWorkerPullOptions) {
+  const { id, apiUrl = KNOWHOW_API_URL } = options;
+
+  // Load JWT
+  const jwt = await loadJwt();
+  if (!jwt) {
+    console.error("❌ No JWT token found. Please run 'knowhow login' first.");
+    process.exit(1);
+  }
+
+  const client = new KnowhowSimpleClient(apiUrl, jwt);
+
+  console.log(`🔄 Pulling config for cloud worker ${id}...`);
+
+  const resp = await client.getCloudWorker(id);
+  const remoteWorker = resp.data;
+
+  if (!remoteWorker) {
+    console.error(`❌ Cloud worker ${id} not found.`);
+    process.exit(1);
+  }
+
+  const remoteConfig = (remoteWorker.workerConfigJson ?? {}) as {
+    mcps?: McpConfig[];
+    modules?: string[];
+    plugins?: Config["plugins"];
+    agents?: Config["agents"];
+  };
+
+  // Load current local config
+  const localConfig = await getConfig();
+
+  // Merge remote fields into local config
+  if (remoteConfig.mcps !== undefined) {
+    localConfig.mcps = remoteConfig.mcps;
+  }
+  if (remoteConfig.modules !== undefined) {
+    localConfig.modules = remoteConfig.modules;
+  }
+  if (remoteConfig.plugins !== undefined) {
+    localConfig.plugins = remoteConfig.plugins;
+  }
+  if (remoteConfig.agents !== undefined) {
+    localConfig.agents = remoteConfig.agents;
+  }
+
+  await updateConfig(localConfig);
+
+  const mcpCount = remoteConfig.mcps?.length ?? 0;
+  console.log(`✅ Config pulled! ${mcpCount} MCP(s) now configured locally.`);
+  console.log(`   Run 'knowhow worker' or trigger reloadConfig to apply changes.`);
+
+  return { mcps: remoteConfig.mcps, modules: remoteConfig.modules };
+}