@cjhyy/code-shell-core 0.5.0-rc.1 → 0.6.0-rc.1

package/dist/utils/exec.js

@@ -0,0 +1,144 @@
+/**
+ * Cross-platform executable resolution.
+ *
+ * Node's `child_process.spawn`/`execFile` on Windows do NOT walk PATHEXT for a
+ * bare command name unless `shell:true` — so `execFile("git", …)` finds
+ * `git.exe` but NOT a `git.cmd`/`gh.cmd` shim (common for tools installed via
+ * scoop/npm/chocolatey). On POSIX a bare name in PATH works fine.
+ *
+ * `resolveExecutable` does an explicit PATH × PATHEXT lookup on Windows and
+ * returns the first existing match's absolute path; on POSIX (or when nothing
+ * is found) it returns the command unchanged, so callers can always pass the
+ * result straight to execFile/spawn.
+ */
+import { accessSync, constants, statSync } from "node:fs";
+import { delimiter, extname, isAbsolute, join } from "node:path";
+/**
+ * The names to probe for `command` on the current platform: the bare name on
+ * POSIX (or when it already has an extension), plus each PATHEXT variant
+ * (command.exe / .cmd / .bat …) on Windows.
+ */
+export function commandCandidateNames(command, env = process.env) {
+    if (process.platform !== "win32" || extname(command))
+        return [command];
+    const pathext = (env.PATHEXT || ".COM;.EXE;.BAT;.CMD")
+        .split(";")
+        .map((ext) => ext.trim())
+        .filter(Boolean);
+    return [command, ...pathext.map((ext) => `${command}${ext}`)];
+}
+function isExecutableFile(filePath) {
+    try {
+        const st = statSync(filePath);
+        if (!st.isFile())
+            return false;
+        if (process.platform !== "win32")
+            accessSync(filePath, constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Resolve `command` to an absolute executable path on Windows (walking
+ * PATH × PATHEXT so .cmd/.bat shims are found). Returns `command` unchanged on
+ * POSIX, when it already has a path separator/extension, or when no match is
+ * found (let spawn surface the ENOENT then).
+ */
+const resolveCache = new Map();
+export function resolveExecutable(command, env = process.env) {
+    if (process.platform !== "win32")
+        return command;
+    const trimmed = command.trim();
+    if (!trimmed)
+        return command;
+    const cached = resolveCache.get(trimmed);
+    if (cached !== undefined)
+        return cached;
+    const result = resolveExecutableUncached(trimmed, env);
+    resolveCache.set(trimmed, result);
+    return result;
+}
+/** Test seam: drop the resolution cache. */
+export function _clearExecutableCache() {
+    resolveCache.clear();
+}
+/**
+ * Find `command` as a real, runnable executable. Unlike {@link resolveExecutable}
+ * (which returns the bare name unchanged when nothing is found, so spawn can
+ * surface its own ENOENT), this returns the absolute path if a binary exists or
+ * `null` if it genuinely cannot be found — works on POSIX too (probes PATH).
+ * Use it to *detect* a missing tool up front (e.g. is git installed?).
+ */
+export function findExecutable(command, env = process.env) {
+    const trimmed = command.trim();
+    if (!trimmed)
+        return null;
+    const hasSep = trimmed.includes("/") || trimmed.includes("\\") || isAbsolute(trimmed);
+    if (hasSep) {
+        for (const name of commandCandidateNames(trimmed, env)) {
+            if (isExecutableFile(name))
+                return name;
+        }
+        return null;
+    }
+    for (const dir of (env.PATH ?? "").split(delimiter)) {
+        if (!dir)
+            continue;
+        for (const name of commandCandidateNames(trimmed, env)) {
+            const full = join(dir, name);
+            if (isExecutableFile(full))
+                return full;
+        }
+    }
+    return null;
+}
+// ─── git executable: optional user override + availability probe ───────────
+//
+// codeshell shells out to `git` for marketplace clones, worktrees, and diffs.
+// A GUI launch may not inherit the user's PATH (classic Windows/macOS issue),
+// so we let the user point us at a git binary explicitly via the `git.path`
+// setting — mirrors VS Code's `git.path`. The desktop host reads that setting
+// and calls setGitPathOverride() at startup / on settings change.
+let gitPathOverride = null;
+/** Set (or clear, with null/"") the user-configured git binary path. */
+export function setGitPathOverride(path) {
+    gitPathOverride = path && path.trim() ? path.trim() : null;
+}
+/**
+ * The git command to spawn: the user override if set, else `git` resolved
+ * through PATH×PATHEXT. Always returns something spawnable (callers still get
+ * a structured spawn-failure if it's wrong).
+ */
+export function resolveGit(env = process.env) {
+    if (gitPathOverride)
+        return resolveExecutable(gitPathOverride, env);
+    return resolveExecutable("git", env);
+}
+/** Is a usable git binary available (override path, or git on PATH)? */
+export function isGitAvailable(env = process.env) {
+    return findExecutable(gitPathOverride ?? "git", env) !== null;
+}
+function resolveExecutableUncached(trimmed, env) {
+    const command = trimmed;
+    // Already a path (absolute or relative with a separator): resolve extension.
+    const hasSep = trimmed.includes("/") || trimmed.includes("\\");
+    if (hasSep || isAbsolute(trimmed)) {
+        for (const name of commandCandidateNames(trimmed, env)) {
+            if (isExecutableFile(name))
+                return name;
+        }
+        return command;
+    }
+    for (const dir of (env.PATH ?? "").split(delimiter)) {
+        if (!dir)
+            continue;
+        for (const name of commandCandidateNames(trimmed, env)) {
+            const full = join(dir, name);
+            if (isExecutableFile(full))
+                return full;
+        }
+    }
+    return command;
+}

package/dist/utils/format.js

@@ -33,8 +33,10 @@ export function formatDuration(ms, options) {
         if (ms === 0) {
             return '0s';
         }
-        // For durations < 1s, show 1 decimal place (e.g., 0.5s)
-        if (ms < 1) {
+        // For durations < 1s, show 1 decimal place (e.g., 0.5s). This must cover
+        // the whole (0, 1000)ms range — the old `< 1` guard let [1, 1000)ms fall
+        // through to Math.floor(ms/1000) = 0 → a wrong "0s".
+        if (ms < 1000) {
             const s = (ms / 1000).toFixed(1);
             return `${s}s`;
         }

package/dist/utils/json.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Generic JSON extraction from LLM text output — strip markdown fences and
+ * pull out the first balanced object/array. These are provider-agnostic and
+ * have no Arena dependency; they live here (not in arena/strategies/utils.ts)
+ * so non-Arena consumers (e.g. services/memory-orchestrator) can use them
+ * without dragging in the Arena subsystem. Arena re-exports them for
+ * back-compat.
+ */
+/** Extract JSON from text that might have markdown fences or surrounding text. */
+export declare function extractJSON(text: string): string;
+/** Extract a JSON array from text. */
+export declare function extractJSONArray(text: string): string;

package/dist/utils/json.js

@@ -0,0 +1,92 @@
+/**
+ * Generic JSON extraction from LLM text output — strip markdown fences and
+ * pull out the first balanced object/array. These are provider-agnostic and
+ * have no Arena dependency; they live here (not in arena/strategies/utils.ts)
+ * so non-Arena consumers (e.g. services/memory-orchestrator) can use them
+ * without dragging in the Arena subsystem. Arena re-exports them for
+ * back-compat.
+ */
+/** Extract JSON from text that might have markdown fences or surrounding text. */
+export function extractJSON(text) {
+    // Try fenced code blocks — use GREEDY match to handle nested backticks
+    const fenced = text.match(/```(?:json)?\s*\n([\s\S]*)\n\s*```/);
+    if (fenced)
+        return fenced[1].trim();
+    // Try to find the outermost { ... } pair with balanced braces
+    const start = text.indexOf("{");
+    if (start !== -1) {
+        let depth = 0;
+        let inString = false;
+        let escape = false;
+        for (let i = start; i < text.length; i++) {
+            const ch = text[i];
+            if (escape) {
+                escape = false;
+                continue;
+            }
+            if (ch === "\\") {
+                escape = true;
+                continue;
+            }
+            if (ch === '"') {
+                inString = !inString;
+                continue;
+            }
+            if (inString)
+                continue;
+            if (ch === "{")
+                depth++;
+            else if (ch === "}") {
+                depth--;
+                if (depth === 0)
+                    return text.slice(start, i + 1);
+            }
+        }
+        // Unbalanced — return from start to end as best effort
+        return text.slice(start);
+    }
+    return text;
+}
+/** Extract a JSON array from text. */
+export function extractJSONArray(text) {
+    const fenced = text.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+    if (fenced)
+        return fenced[1].trim();
+    // Return the FIRST balanced top-level array. A greedy /\[[\s\S]*\]/ spanned
+    // to the last ']', merging two arrays (or trailing prose) into one invalid
+    // blob. Scan for bracket balance, ignoring brackets inside strings.
+    const balanced = firstBalancedArray(text);
+    if (balanced)
+        return balanced;
+    return text;
+}
+function firstBalancedArray(text) {
+    const start = text.indexOf("[");
+    if (start === -1)
+        return undefined;
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let i = start; i < text.length; i++) {
+        const ch = text[i];
+        if (inString) {
+            if (escaped)
+                escaped = false;
+            else if (ch === "\\")
+                escaped = true;
+            else if (ch === '"')
+                inString = false;
+            continue;
+        }
+        if (ch === '"')
+            inString = true;
+        else if (ch === "[")
+            depth++;
+        else if (ch === "]") {
+            depth--;
+            if (depth === 0)
+                return text.slice(start, i + 1);
+        }
+    }
+    return undefined; // unbalanced
+}

package/dist/utils/lockfile.js

@@ -8,11 +8,18 @@
  * Import this module instead of `proper-lockfile` directly. The underlying
  * package is only loaded the first time a lock function is actually called.
  */
+import { createRequire } from 'node:module';
+// proper-lockfile is CommonJS. This module compiles to ESM (tsc module: ESNext,
+// package "type":"module"), and `require` is NOT a global in ESM — under the
+// Electron main process (an ESM bundle that loads core as an external ESM dep)
+// a bare `require('proper-lockfile')` throws "require is not defined", which
+// surfaced as run locks silently failing ("Run now does nothing"). createRequire
+// gives us a CJS-capable require that works in both ESM and CJS/Bun hosts.
+const nodeRequire = createRequire(import.meta.url);
 let _lockfile;
 function getLockfile() {
     if (!_lockfile) {
-        // eslint-disable-next-line @typescript-eslint/no-require-imports
-        _lockfile = require('proper-lockfile');
+        _lockfile = nodeRequire('proper-lockfile');
     }
     return _lockfile;
 }

package/dist/utils/theme.d.ts

@@ -85,9 +85,15 @@ export declare const THEME_SETTINGS: readonly ["auto", "dark", "light", "light-d
 export type ThemeSetting = (typeof THEME_SETTINGS)[number];
 export declare function getTheme(themeName: ThemeName): Theme;
 /**
- * Converts a theme color to an ANSI escape sequence for use with asciichart.
+ * Converts a theme color to an ANSI escape sequence for use in chart rendering.
  *
  * Apple Terminal doesn't handle 24-bit (true-color) escape sequences well, so
  * on that terminal we downgrade to the nearest xterm-256 color index instead.
  */
 export declare function themeColorToAnsi(themeColor: string): string;
+/**
+ * Nearest xterm-256 color index for an RGB triple.
+ * Uses the 6×6×6 color cube (indices 16-231) plus the 24-step grayscale ramp
+ * (indices 232-255).
+ */
+export declare function rgbToXterm256(r: number, g: number, b: number): number;

package/dist/utils/theme.js

@@ -500,7 +500,7 @@ export function getTheme(themeName) {
     }
 }
 /**
- * Converts a theme color to an ANSI escape sequence for use with asciichart.
+ * Converts a theme color to an ANSI escape sequence for use in chart rendering.
  *
  * Apple Terminal doesn't handle 24-bit (true-color) escape sequences well, so
  * on that terminal we downgrade to the nearest xterm-256 color index instead.
@@ -527,14 +527,16 @@ export function themeColorToAnsi(themeColor) {
  * Uses the 6×6×6 color cube (indices 16-231) plus the 24-step grayscale ramp
  * (indices 232-255).
  */
-function rgbToXterm256(r, g, b) {
+export function rgbToXterm256(r, g, b) {
     // Grayscale ramp: pick it when all channels are equal-ish
     if (Math.abs(r - g) < 8 && Math.abs(g - b) < 8) {
         if (r < 8)
             return 16;
         if (r > 248)
             return 231;
-        return Math.round((r - 8) / 247 * 24) + 232;
+        // 24 ramp steps (idx 232-255) span RGB [8,248] = 240 units → /240*23.
+        // The old /247*24 produced off-by-one indices.
+        return Math.round((r - 8) / 240 * 23) + 232;
     }
     // 6×6×6 cube
     const ri = Math.round(r / 255 * 5);

package/dist/utils/toolDisplay.js

@@ -58,7 +58,6 @@ const TOOL_ARG_KEYS = {
     TodoWrite: ["todos"],
     Sleep: ["seconds"],
     EnterWorktree: ["slug"],
-    SendMessage: ["to"],
     CronCreate: ["name", "schedule"],
     LSP: ["action", "file_path"],
     NotebookEdit: ["action", "file_path"],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cjhyy/code-shell-core",
-  "version": "0.5.0-rc.1",
+  "version": "0.6.0-rc.1",
   "description": "Core engine for code-shell — agent orchestration, tool execution, hooks, protocol. UI-agnostic.",
   "type": "module",
   "main": "./dist/index.js",
@@ -16,14 +16,15 @@
     "./dist/data/*.json",
     "./dist/prompt/sections/*.md"
   ],
+  "//files": "LICENSE/README intentionally omitted: npm/bun always include them in a publish regardless of this list, so the published tarball is unchanged — but listing them makes electron-builder (which follows the workspace symlink when packaging the desktop app) try to copy them from packages/core, tripping its 'file must be under <app>' guard (electron-builder#3238). dist is all the desktop bundle needs.",
   "files": [
-    "dist",
-    "README.md",
-    "LICENSE"
+    "dist"
   ],
   "scripts": {
-    "build": "tsc -p tsconfig.json && mkdir -p dist/prompt/sections dist/data && cp src/prompt/sections/*.md dist/prompt/sections/ && cp src/data/*.json dist/data/",
-    "clean": "rm -rf dist"
+    "build": "tsc -p tsconfig.json && bun run copy-assets",
+    "copy-assets": "node ../../scripts/copy-assets.mjs dist/prompt/sections src/prompt/sections/*.md && node ../../scripts/copy-assets.mjs dist/data src/data/*.json",
+    "dev": "bun run copy-assets && tsc -p tsconfig.json --watch --preserveWatchOutput",
+    "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\""
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.39.0",
@@ -34,9 +35,12 @@
     "openai": "^4.82.0",
     "proper-lockfile": "^4.1.2",
     "semver": "^7.7.4",
+    "smol-toml": "^1.6.1",
     "strip-ansi": "^7.2.0",
     "yaml": "^2.7.0",
-    "zod": "^3.24.2"
+    "yauzl": "^3.4.0",
+    "zod": "^3.24.2",
+    "zod-to-json-schema": "^3.25.2"
   },
   "engines": {
     "node": ">=20.10"
@@ -68,5 +72,8 @@
   ],
   "publishConfig": {
     "access": "public"
+  },
+  "devDependencies": {
+    "@types/yauzl": "^3.4.0"
   }
 }

package/dist/agent/coordinator.d.ts

@@ -1,49 +0,0 @@
-/**
- * Agent coordinator — agent registry + message bus for multi-agent communication.
- */
-/** A registered named agent. */
-export interface AgentInfo {
-    id: string;
-    name: string;
-    status: "running" | "completed" | "failed";
-    description: string;
-    startedAt: number;
-    completedAt?: number;
-    result?: string;
-}
-/** A message between agents. */
-export interface AgentMessage {
-    from: string;
-    to: string;
-    content: string;
-    timestamp: number;
-}
-/**
- * Singleton agent registry and message bus.
- */
-declare class AgentCoordinator {
-    private agents;
-    private inbox;
-    /** Register a named agent. */
-    register(id: string, name: string, description: string): void;
-    /** Mark an agent as completed. */
-    complete(name: string, result?: string): void;
-    /** Mark an agent as failed. */
-    fail(name: string): void;
-    /** Get agent info by name. */
-    get(name: string): AgentInfo | undefined;
-    /** List all agents. */
-    list(): AgentInfo[];
-    /** List active (running) agents. */
-    listActive(): AgentInfo[];
-    /** Send a message to a named agent. */
-    send(from: string, to: string, content: string): boolean;
-    /** Read messages for a named agent (drains the inbox). */
-    receive(name: string): AgentMessage[];
-    /** Peek at messages without draining. */
-    peek(name: string): AgentMessage[];
-    /** Reset all state. */
-    reset(): void;
-}
-export declare const agentCoordinator: AgentCoordinator;
-export {};

package/dist/agent/coordinator.js

@@ -1,77 +0,0 @@
-/**
- * Agent coordinator — agent registry + message bus for multi-agent communication.
- */
-/**
- * Singleton agent registry and message bus.
- */
-class AgentCoordinator {
-    agents = new Map();
-    inbox = new Map();
-    /** Register a named agent. */
-    register(id, name, description) {
-        this.agents.set(name, {
-            id,
-            name,
-            status: "running",
-            description,
-            startedAt: Date.now(),
-        });
-        if (!this.inbox.has(name)) {
-            this.inbox.set(name, []);
-        }
-    }
-    /** Mark an agent as completed. */
-    complete(name, result) {
-        const agent = this.agents.get(name);
-        if (agent) {
-            agent.status = "completed";
-            agent.completedAt = Date.now();
-            agent.result = result;
-        }
-    }
-    /** Mark an agent as failed. */
-    fail(name) {
-        const agent = this.agents.get(name);
-        if (agent) {
-            agent.status = "failed";
-            agent.completedAt = Date.now();
-        }
-    }
-    /** Get agent info by name. */
-    get(name) {
-        return this.agents.get(name);
-    }
-    /** List all agents. */
-    list() {
-        return [...this.agents.values()];
-    }
-    /** List active (running) agents. */
-    listActive() {
-        return [...this.agents.values()].filter((a) => a.status === "running");
-    }
-    /** Send a message to a named agent. */
-    send(from, to, content) {
-        if (!this.agents.has(to))
-            return false;
-        const messages = this.inbox.get(to) ?? [];
-        messages.push({ from, to, content, timestamp: Date.now() });
-        this.inbox.set(to, messages);
-        return true;
-    }
-    /** Read messages for a named agent (drains the inbox). */
-    receive(name) {
-        const messages = this.inbox.get(name) ?? [];
-        this.inbox.set(name, []);
-        return messages;
-    }
-    /** Peek at messages without draining. */
-    peek(name) {
-        return this.inbox.get(name) ?? [];
-    }
-    /** Reset all state. */
-    reset() {
-        this.agents.clear();
-        this.inbox.clear();
-    }
-}
-export const agentCoordinator = new AgentCoordinator();

package/dist/settings/manager.test.js

@@ -1,73 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach } from "bun:test";
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { SettingsManager } from "./manager.js";
-/**
- * Scope isolation tests. We point HOME at a temp dir (userHome() reads
- * process.env.HOME first) and use a separate temp cwd, then seed each of the
- * four disk layers with a uniquely-named mcpServers entry. mcpServers is a
- * record merged key-by-key, so every layer that was actually read leaves its
- * own key in the merged result — letting us detect which layers were read
- * (unlike arrays, which deep-merge replaces wholesale).
- */
-describe("SettingsManager scope", () => {
-    let home;
-    let cwd;
-    let prevHome;
-    function serverFor(tag) {
-        return { [tag]: { name: tag, command: "echo", transport: "stdio" } };
-    }
-    function writeSettings(dir, file, tag) {
-        mkdirSync(join(dir, ".code-shell"), { recursive: true });
-        writeFileSync(join(dir, ".code-shell", file), JSON.stringify({ mcpServers: serverFor(tag) }), "utf-8");
-    }
-    function layersIn(sm) {
-        return Object.keys(sm.get().mcpServers ?? {}).sort();
-    }
-    beforeEach(() => {
-        prevHome = process.env.HOME;
-        home = mkdtempSync(join(tmpdir(), "cs-home-"));
-        cwd = mkdtempSync(join(tmpdir(), "cs-cwd-"));
-        process.env.HOME = home;
-        writeSettings(home, "settings.managed.json", "MANAGED");
-        writeSettings(home, "settings.json", "USER");
-        writeSettings(cwd, "settings.json", "PROJECT");
-        writeSettings(cwd, "settings.local.json", "LOCAL");
-    });
-    afterEach(() => {
-        process.env.HOME = prevHome;
-        rmSync(home, { recursive: true, force: true });
-        rmSync(cwd, { recursive: true, force: true });
-    });
-    test("full reads all four disk layers", () => {
-        expect(layersIn(new SettingsManager(cwd, "full"))).toEqual([
-            "LOCAL",
-            "MANAGED",
-            "PROJECT",
-            "USER",
-        ]);
-    });
-    test("project (default) reads project+local, never user/managed", () => {
-        expect(layersIn(new SettingsManager(cwd, "project"))).toEqual(["LOCAL", "PROJECT"]);
-    });
-    test("default scope is project", () => {
-        expect(layersIn(new SettingsManager(cwd))).toEqual(["LOCAL", "PROJECT"]);
-    });
-    test("isolated reads no disk layers", () => {
-        expect(layersIn(new SettingsManager(cwd, "isolated"))).toEqual([]);
-    });
-    test("flag overrides apply even under isolated", () => {
-        const sm = new SettingsManager(cwd, "isolated");
-        sm.load({ mcpServers: serverFor("FLAG") });
-        expect(layersIn(sm)).toEqual(["FLAG"]);
-    });
-    test("non-full scope never triggers user-file model migration write-back", () => {
-        // Legacy models[] in the user file would normally be migrated (and the
-        // file rewritten with a .bak). Under project/isolated we must not touch
-        // the user file at all.
-        writeFileSync(join(home, ".code-shell", "settings.json"), JSON.stringify({ models: [{ id: "legacy", provider: "x" }] }), "utf-8");
-        new SettingsManager(cwd, "project").get();
-        expect(existsSync(join(home, ".code-shell", "settings.json.bak"))).toBe(false);
-    });
-});

package/dist/tool-system/builtin/remote-trigger.d.ts

@@ -1,6 +0,0 @@
-/**
- * RemoteTriggerTool — trigger remote agents/workflows.
- */
-import type { ToolDefinition } from "../../types.js";
-export declare const remoteTriggerToolDef: ToolDefinition;
-export declare function remoteTriggerTool(args: Record<string, unknown>): Promise<string>;

package/dist/tool-system/builtin/remote-trigger.js

@@ -1,54 +0,0 @@
-/**
- * RemoteTriggerTool — trigger remote agents/workflows.
- */
-export const remoteTriggerToolDef = {
-    name: "RemoteTrigger",
-    description: "Trigger a remote agent or workflow to execute a task. " +
-        "The agent runs asynchronously and results can be checked later.",
-    inputSchema: {
-        type: "object",
-        properties: {
-            name: {
-                type: "string",
-                description: "The name/identifier of the remote trigger to execute",
-            },
-            prompt: {
-                type: "string",
-                description: "The task prompt to send to the remote agent",
-            },
-            config: {
-                type: "object",
-                description: "Optional configuration for the remote execution",
-            },
-        },
-        required: ["name", "prompt"],
-    },
-};
-export async function remoteTriggerTool(args) {
-    const name = args.name;
-    const prompt = args.prompt;
-    const config = args.config;
-    // Remote triggers are dispatched via the cron scheduler or external API
-    try {
-        const { existsSync, readFileSync, writeFileSync, mkdirSync } = await import("node:fs");
-        const { join } = await import("node:path");
-        const { homedir } = await import("node:os");
-        // Store trigger request for pickup by external scheduler
-        const triggerDir = join(homedir(), ".code-shell", "triggers");
-        mkdirSync(triggerDir, { recursive: true });
-        const trigger = {
-            id: `trigger_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
-            name,
-            prompt,
-            config,
-            createdAt: new Date().toISOString(),
-            status: "pending",
-        };
-        const triggerFile = join(triggerDir, `${trigger.id}.json`);
-        writeFileSync(triggerFile, JSON.stringify(trigger, null, 2), "utf-8");
-        return `Remote trigger "${name}" dispatched (ID: ${trigger.id}).\nStored at: ${triggerFile}`;
-    }
-    catch (err) {
-        return `Remote trigger error: ${err.message}`;
-    }
-}

package/dist/tool-system/builtin/send-message.d.ts

@@ -1,6 +0,0 @@
-/**
- * SendMessage tool — send messages between named agents.
- */
-import type { ToolDefinition } from "../../types.js";
-export declare const sendMessageToolDef: ToolDefinition;
-export declare function sendMessageTool(args: Record<string, unknown>): Promise<string>;