@phuetz/code-buddy 2.0.0 → 2.1.0

package/dist/tools/create-skill-tool.js

@@ -10,90 +10,31 @@
  * commands it uses repeatedly and codify them as reusable skills.
  *
  * Skill file location:
- *   .codebuddy/skills/workspace/<slug>/SKILL.md
+ *   .codebuddy/skills/<authored-slug>/SKILL.md
  *
  * The tool generates valid SKILL.md frontmatter and validates that
  * the slug does not already exist before writing.
  */
-import * as fs from 'fs/promises';
 import * as path from 'path';
-import { existsSync } from 'fs';
-import { validateGeneratedCode, formatValidationReport } from '../security/code-validator.js';
+import * as yaml from 'yaml';
+import { LiveSkillMutator, toAuthoredSkillName } from '../agent/self-improvement/skill-mutator.js';
 export class CreateSkillTool {
-    get workspaceDir() {
-        return path.join(process.cwd(), '.codebuddy', 'skills', 'workspace');
-    }
-    async execute(input) {
-        const { name, description, body, tags = [], env = {}, requires = [], overwrite = false, } = input;
-        if (!name?.trim()) {
-            return { success: false, error: 'name is required' };
-        }
-        if (!description?.trim()) {
-            return { success: false, error: 'description is required' };
-        }
-        if (!body?.trim()) {
-            return { success: false, error: 'body is required' };
-        }
-        // Derive a filesystem-safe slug
-        const slug = name
-            .toLowerCase()
-            .replace(/[^a-z0-9]+/g, '-')
-            .replace(/^-+|-+$/g, '');
-        const skillDir = path.join(this.workspaceDir, slug);
-        const skillFile = path.join(skillDir, 'SKILL.md');
-        // Check for existing skill
-        if (existsSync(skillFile) && !overwrite) {
-            return {
-                success: false,
-                error: `Skill "${slug}" already exists. Set overwrite: true to replace it.`,
-            };
-        }
-        // Build YAML frontmatter
-        const fm = ['---', `name: ${name}`, `version: 1.0.0`, `description: ${description}`];
-        if (tags.length > 0) {
-            fm.push(`tags: [${tags.join(', ')}]`);
-        }
-        if (Object.keys(env).length > 0) {
-            fm.push('env:');
-            for (const [k, v] of Object.entries(env)) {
-                fm.push(`  ${k}: ${v}`);
-            }
-        }
-        if (requires.length > 0) {
-            fm.push(`requires: [${requires.join(', ')}]`);
-        }
-        fm.push('---');
-        const skillContent = `${fm.join('\n')}\n\n${body.trim()}\n`;
-        // Validate skill body for security (prevent malicious code in LLM-generated skills)
-        const validation = validateGeneratedCode(body);
-        if (!validation.safe) {
-            return {
-                success: false,
-                error: `Code validation failed:\n${formatValidationReport(validation)}\nSkill creation blocked for security reasons.`,
-            };
-        }
-        // Write to disk
+    async execute(input, cwd = process.cwd()) {
         try {
-            await fs.mkdir(skillDir, { recursive: true });
-            await fs.writeFile(skillFile, skillContent, 'utf-8');
+            for (const field of ['name', 'description', 'body']) {
+                if (typeof input[field] !== 'string' || !input[field].trim())
+                    return { success: false, error: `${field} is required` };
+            }
+            const name = toAuthoredSkillName(input.name);
+            const root = path.join(cwd, '.codebuddy', 'skills');
+            // Serialize metadata, including names containing ':' or YAML control characters.
+            const content = `---\n${yaml.stringify({ name, description: input.description, tags: input.tags ?? [], env: input.env ?? {}, requires: input.requires ?? [] })}---\n\n${input.body.trim()}\n`;
+            new LiveSkillMutator(root).create({ name, description: input.description, content }, { overwrite: input.overwrite === true });
+            return { success: true, output: `Skill created and loaded: ${name}\nPath: ${path.join(root, name, 'SKILL.md')}`, data: { name, loaded: true } };
         }
-        catch (err) {
-            return {
-                success: false,
-                error: `Failed to write skill: ${err instanceof Error ? err.message : String(err)}`,
-            };
+        catch (error) {
+            return { success: false, error: error instanceof Error ? error.message : String(error) };
         }
-        return {
-            success: true,
-            output: [
-                `✅ Skill created: ${name}`,
-                `   Path: ${skillFile}`,
-                `   Tags: ${tags.join(', ') || 'none'}`,
-                '',
-                'The skill is now available in the workspace registry.',
-                'Run `buddy hub search ${name}` or `/skills` to verify.',
-            ].join('\n'),
-        };
     }
     getSchema() {
         return {

package/dist/tools/cronjob-tool.d.ts

@@ -14,6 +14,7 @@ export interface CronjobToolInput extends Record<string, unknown> {
     skillRequest?: unknown;
     then?: unknown;
     preCheck?: unknown;
+    continuity?: unknown;
     deliver?: unknown;
     format?: unknown;
 }

package/dist/tools/cronjob-tool.js

@@ -50,6 +50,7 @@ function buildCreateOptions(input) {
         skillRequest: normalizeString(input.skillRequest),
         then: normalizeString(input.then),
         preCheck: normalizeJsonOption(input.preCheck),
+        continuity: normalizeJsonOption(input.continuity),
         deliver: normalizeDeliver(input.deliver),
         format: normalizeString(input.format),
     };

package/dist/tools/env-doctor-tool.d.ts

@@ -1,3 +1,4 @@
+import { diagnoseLmResizer } from '../context/lm-resizer-diagnostics.js';
 import type { ToolResult } from '../types/index.js';
 export interface EnvDoctorData {
     root: string;
@@ -6,6 +7,7 @@ export interface EnvDoctorData {
     npmScripts: string[];
     tools: Record<string, boolean>;
     configFiles: string[];
+    lmResizer?: Awaited<ReturnType<typeof diagnoseLmResizer>>;
 }
 export declare class EnvDoctorTool {
     readonly name = "env_doctor";

package/dist/tools/env-doctor-tool.js

@@ -1,3 +1,4 @@
+import { diagnoseLmResizer } from '../context/lm-resizer-diagnostics.js';
 import { execFile } from 'child_process';
 import * as fs from 'fs/promises';
 import * as path from 'path';
@@ -17,7 +18,7 @@ catch {
     return false;
 } }
 async function hasTool(name) { try {
-    await execFileAsync('which', [name], { timeout: 3000 });
+    await execFileAsync(process.platform === 'win32' ? 'where.exe' : 'which', [name], { timeout: 3000 });
     return true;
 }
 catch {
@@ -43,8 +44,8 @@ export class EnvDoctorTool {
         for (const file of CONFIG_FILES)
             if (await exists(path.join(root, file)))
                 configFiles.push(file);
-        const data = { root, nodeVersion: process.version, nodeModulesPresent: await exists(path.join(root, 'node_modules')), npmScripts, tools: { git: await hasTool('git'), docker: await hasTool('docker') }, configFiles };
-        return { success: true, output: `Node ${process.version}; ${npmScripts.length} npm scripts; node_modules ${data.nodeModulesPresent ? 'present' : 'missing'}`, data };
+        const data = { root, nodeVersion: process.version, nodeModulesPresent: await exists(path.join(root, 'node_modules')), npmScripts, tools: { git: await hasTool('git'), docker: await hasTool('docker') }, configFiles, lmResizer: await diagnoseLmResizer() };
+        return { success: true, output: `Node ${process.version}; ${npmScripts.length} npm scripts; node_modules ${data.nodeModulesPresent ? 'present' : 'missing'}\nLM Resizer (host): ${data.lmResizer?.binary}; tool-output=${data.lmResizer?.toolOutputSupported}; enabled=${data.lmResizer?.enabled}. ${data.lmResizer?.warning}\nHost binaries may not be available in the Bash sandbox; use configured MCP integrations or the host observation optimizer.`, data };
     }
     catch (error) {
         return { success: false, error: error instanceof Error ? error.message : String(error) };

package/dist/tools/execute-code-rpc-invoker.d.ts

@@ -39,7 +39,7 @@ export interface ExecuteCodeRpcInvokeResult {
     error?: string;
     truncated?: boolean;
 }
-export type ExecuteCodeRpcInvoker = (request: ExecuteCodeRpcInvokeRequest) => Promise<ExecuteCodeRpcInvokeResult>;
+export type ExecuteCodeRpcInvoker = (request: ExecuteCodeRpcInvokeRequest, signal?: AbortSignal) => Promise<ExecuteCodeRpcInvokeResult>;
 /** Truthy-flag parse — the single master gate. Read once, in the parent. */
 export declare function isExecuteCodeToolRpcEnabled(raw?: string | undefined): boolean;
 export declare function getExecuteCodeToolRpcAllowlist(raw?: string | undefined): Set<string>;

package/dist/tools/execute-code-rpc-invoker.js

@@ -30,6 +30,7 @@
  * `peer-tool-bridge.ts` pattern.
  */
 import { spawn } from 'child_process';
+import { constants } from 'node:fs';
 import { getRipgrepPath } from '../utils/ripgrep-path.js';
 import * as fs from 'fs/promises';
 import * as path from 'path';
@@ -93,9 +94,10 @@ export function createExecuteCodeRpcInvoker(options) {
     const combinedAllowlist = new Set([...baseAllowlist, ...extraTools]);
     const isFleetSafe = options.isFleetSafe ?? ((name) => getToolRegistry().isFleetSafe(name));
     const workspaceRoot = path.resolve(options.workspaceRoot);
-    return async (request) => {
+    return async (request, signal) => {
         const tool = request.tool;
         try {
+            signal?.throwIfAborted();
             if (!combinedAllowlist.has(tool)) {
                 return {
                     ok: false,
@@ -114,7 +116,7 @@ export function createExecuteCodeRpcInvoker(options) {
             if (!executor) {
                 return { ok: false, error: `UNKNOWN_EXECUTE_CODE_RPC_TOOL: no executor for "${tool}"` };
             }
-            const { output, truncated } = await executor(request.args, workspaceRoot);
+            const { output, truncated } = await executor(request.args, workspaceRoot, signal);
             logger.debug('[execute-code-rpc] tool executed', { tool, truncated });
             return { ok: true, output, truncated };
         }
@@ -133,22 +135,34 @@ function assertInsideWorkspace(target, workspaceRoot) {
     }
     return absolute;
 }
-const execViewFile = async (args, workspaceRoot) => {
+/** Resolve both sides physically; lexical containment alone follows escaping links. */
+async function resolveWorkspacePath(target, workspaceRoot) {
+    const lexical = assertInsideWorkspace(target, workspaceRoot);
+    const root = await fs.realpath(workspaceRoot);
+    const resolved = await fs.realpath(lexical);
+    return assertInsideWorkspace(resolved, root);
+}
+const execViewFile = async (args, workspaceRoot, signal) => {
     const filePath = args.file_path ?? args.path;
     if (typeof filePath !== 'string' || filePath.length === 0) {
         throw new Error('view_file: missing string file_path');
     }
-    const resolved = assertInsideWorkspace(filePath, workspaceRoot);
-    const stat = await fs.stat(resolved);
-    if (!stat.isFile()) {
-        throw new Error(`view_file: ${filePath} is not a regular file`);
-    }
-    const truncated = stat.size > READ_TRUNCATE_BYTES;
-    const limit = Math.min(stat.size, READ_TRUNCATE_BYTES);
-    if (limit <= 0)
-        return { output: '', truncated };
-    const handle = await fs.open(resolved, 'r');
+    const resolved = await resolveWorkspacePath(filePath, workspaceRoot);
+    signal?.throwIfAborted();
+    const handle = await fs.open(resolved, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
     try {
+        // On Linux verify the opened descriptor too, before reading, against path swaps.
+        if (process.platform === 'linux') {
+            assertInsideWorkspace(await fs.realpath(`/proc/self/fd/${handle.fd}`), await fs.realpath(workspaceRoot));
+        }
+        const stat = await handle.stat();
+        if (!stat.isFile())
+            throw new Error(`view_file: ${filePath} is not a regular file`);
+        const truncated = stat.size > READ_TRUNCATE_BYTES;
+        const limit = Math.min(stat.size, READ_TRUNCATE_BYTES);
+        signal?.throwIfAborted();
+        if (limit <= 0)
+            return { output: '', truncated };
         const buffer = Buffer.allocUnsafe(limit);
         const { bytesRead } = await handle.read(buffer, 0, limit, 0);
         return { output: buffer.subarray(0, bytesRead).toString('utf-8'), truncated };
@@ -157,12 +171,13 @@ const execViewFile = async (args, workspaceRoot) => {
         await handle.close();
     }
 };
-const execListDirectory = async (args, workspaceRoot) => {
+const execListDirectory = async (args, workspaceRoot, signal) => {
     const dirPath = args.path ?? args.directory ?? '.';
     if (typeof dirPath !== 'string') {
         throw new Error('list_directory: path must be a string');
     }
-    const resolved = assertInsideWorkspace(dirPath, workspaceRoot);
+    const resolved = await resolveWorkspacePath(dirPath, workspaceRoot);
+    signal?.throwIfAborted();
     const entries = await fs.readdir(resolved, { withFileTypes: true });
     const lines = entries
         .map((entry) => {
@@ -174,7 +189,7 @@ const execListDirectory = async (args, workspaceRoot) => {
     const visible = truncated ? lines.slice(0, LIST_DIRECTORY_MAX_ENTRIES) : lines;
     return { output: visible.join('\n'), truncated };
 };
-const execSearch = async (args, workspaceRoot) => {
+const execSearch = async (args, workspaceRoot, signal) => {
     const query = args.query ?? args.pattern;
     const dirPath = args.path ?? '.';
     if (typeof query !== 'string' || query.length === 0) {
@@ -183,10 +198,11 @@ const execSearch = async (args, workspaceRoot) => {
     if (typeof dirPath !== 'string') {
         throw new Error('search: path must be a string');
     }
-    const resolved = assertInsideWorkspace(dirPath, workspaceRoot);
+    const resolved = await resolveWorkspacePath(dirPath, workspaceRoot);
+    signal?.throwIfAborted();
     return await new Promise((resolve, reject) => {
-        const rgArgs = ['--no-heading', '--line-number', '--color', 'never', '--max-count', '50', '--', query, resolved];
-        const proc = spawn(getRipgrepPath(), rgArgs, { stdio: ['ignore', 'pipe', 'pipe'] });
+        const rgArgs = ['--no-config', '--no-follow', '--no-heading', '--line-number', '--color', 'never', '--max-count', '50', '--', query, resolved];
+        const proc = spawn(getRipgrepPath(), rgArgs, { stdio: ['ignore', 'pipe', 'pipe'], signal });
         let stdout = '';
         let stderr = '';
         let lineCount = 0;

package/dist/tools/execute-code-runner.d.ts

@@ -38,6 +38,8 @@ export interface ExecuteCodeRunnerOptions {
      *    cannot exfiltrate secrets — even during pre-accept scoring.
      */
     envMode?: 'inherit' | 'isolate';
+    /** Required OS confinement for authored computation; never falls back to unrestricted execution. */
+    confinement?: 'compute';
 }
 export interface ExecuteCodeResult {
     kind: 'execute_code_result';

package/dist/tools/execute-code-runner.js

@@ -2,6 +2,7 @@ import { spawn } from 'child_process';
 import { randomUUID } from 'crypto';
 import fs from 'fs/promises';
 import path from 'path';
+import { confineComputeInvocation } from '../security/compute-confinement.js';
 import { logger } from '../utils/logger.js';
 import { isExecuteCodeToolRpcEnabled, } from './execute-code-rpc-invoker.js';
 /**
@@ -58,10 +59,11 @@ export async function executeCode(input, options = {}) {
     // the responder is ALWAYS active so every request gets a structured
     // reply (denial when off / tool refused) — never a hang.
     const rpcEnabled = (options.rpcEnabled ?? isExecuteCodeToolRpcEnabled()) && !!options.rpcInvoke;
-    const rpcSupported = language === 'javascript' || language === 'typescript' || language === 'python';
+    const rpcSupported = options.confinement !== 'compute' && (language === 'javascript' || language === 'typescript' || language === 'python');
     const rpcDir = path.join(runDir, RPC_DIR_NAME);
     const rpcMaxCalls = Math.max(1, options.rpcMaxCalls ?? RPC_DEFAULT_MAX_CALLS);
     const rpcCallTimeoutMs = Math.max(1_000, options.rpcCallTimeoutMs ?? RPC_DEFAULT_CALL_TIMEOUT_MS);
+    await fs.mkdir(runDir, { recursive: true });
     let scriptCode = code;
     if (rpcSupported) {
         await fs.mkdir(rpcDir, { recursive: true });
@@ -90,7 +92,11 @@ export async function executeCode(input, options = {}) {
         const childEnv = options.envMode === 'isolate'
             ? buildIsolatedEnv(runDir, { ...env, ...runnerEnv })
             : { ...process.env, ...env, ...runnerEnv };
-        const child = spawn(invocation.command, [...invocation.args, scriptPath, ...scriptArgs], {
+        const commandArgs = [...invocation.args, scriptPath, ...scriptArgs];
+        const launch = options.confinement === 'compute'
+            ? confineComputeInvocation(invocation.command, commandArgs, runDir)
+            : { command: invocation.command, args: commandArgs };
+        const child = spawn(launch.command, launch.args, {
             cwd: runDir,
             env: childEnv,
             windowsHide: true,
@@ -125,8 +131,7 @@ export async function executeCode(input, options = {}) {
             clearTimeout(timer);
             if (forceKillTimer)
                 clearTimeout(forceKillTimer);
-            rpcPoller?.stop();
-            resolve({ exitCode, signal });
+            void Promise.resolve(rpcPoller?.stop()).then(() => resolve({ exitCode, signal }));
         });
     });
     const completedAt = (options.now ?? (() => new Date()))().toISOString();
@@ -292,11 +297,19 @@ function startRpcResponder(options) {
     const seen = new Set();
     let callCount = 0;
     let stopped = false;
+    const controller = new AbortController();
     let scanning = false;
+    let activeScan = Promise.resolve();
     const writeResponse = async (id, payload) => {
+        if (stopped)
+            return;
         const finalPath = path.join(options.rpcDir, `${id}.res.json`);
         const tmpPath = path.join(options.rpcDir, `${id}.res.json.tmp`);
         await fs.writeFile(tmpPath, JSON.stringify(payload), 'utf8');
+        if (stopped) {
+            await fs.rm(tmpPath, { force: true });
+            return;
+        }
         await fs.rename(tmpPath, finalPath);
     };
     const handleRequest = async (id, reqPath) => {
@@ -308,6 +321,8 @@ function startRpcResponder(options) {
             await writeResponse(id, { ok: false, error: 'RPC_BAD_REQUEST: could not parse request JSON' });
             return;
         }
+        if (stopped)
+            return;
         if (!options.enabled || !options.invoke) {
             await writeResponse(id, {
                 ok: false,
@@ -331,14 +346,22 @@ function startRpcResponder(options) {
             await writeResponse(id, { ok: false, error: 'RPC_BAD_REQUEST: missing string "tool"' });
             return;
         }
+        const callController = new AbortController();
+        const abort = () => callController.abort();
+        controller.signal.addEventListener('abort', abort, { once: true });
         try {
-            const result = await withTimeout(options.invoke({ tool, args }), options.callTimeoutMs, `RPC_TOOL_TIMEOUT: tool "${tool}" exceeded ${options.callTimeoutMs}ms`);
+            if (stopped)
+                return;
+            const result = await withTimeout(options.invoke({ tool, args }, callController.signal), options.callTimeoutMs, `RPC_TOOL_TIMEOUT: tool "${tool}" exceeded ${options.callTimeoutMs}ms`, callController);
             await writeResponse(id, result);
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
             await writeResponse(id, { ok: false, error: message });
         }
+        finally {
+            controller.signal.removeEventListener('abort', abort);
+        }
     };
     const scan = async () => {
         if (scanning || stopped)
@@ -347,6 +370,8 @@ function startRpcResponder(options) {
         try {
             const entries = await fs.readdir(options.rpcDir).catch(() => []);
             for (const entry of entries) {
+                if (stopped)
+                    break;
                 if (!entry.endsWith('.req.json'))
                     continue;
                 const id = entry.slice(0, -'.req.json'.length);
@@ -366,26 +391,33 @@ function startRpcResponder(options) {
         }
     };
     const interval = setInterval(() => {
-        void scan();
+        if (!scanning && !stopped)
+            activeScan = scan();
     }, RPC_POLL_INTERVAL_MS);
     interval.unref?.();
     return {
-        stop() {
+        async stop() {
             stopped = true;
+            controller.abort();
             clearInterval(interval);
+            await activeScan;
         },
     };
 }
-function withTimeout(promise, ms, message) {
+function withTimeout(promise, ms, message, controller) {
     return new Promise((resolve, reject) => {
-        const timer = setTimeout(() => reject(new Error(message)), ms);
+        const abort = () => { clearTimeout(timer); reject(new Error('RPC_CANCELLED')); };
+        const timer = setTimeout(() => {
+            reject(new Error(message));
+            controller.abort();
+        }, ms);
         timer.unref?.();
-        promise.then((value) => {
-            clearTimeout(timer);
-            resolve(value);
-        }, (error) => {
+        controller.signal.addEventListener('abort', abort, { once: true });
+        if (controller.signal.aborted)
+            abort();
+        promise.then(resolve, reject).finally(() => {
             clearTimeout(timer);
-            reject(error instanceof Error ? error : new Error(String(error)));
+            controller.signal.removeEventListener('abort', abort);
         });
     });
 }
@@ -501,10 +533,12 @@ function buildRpcHelper(language) {
         ].join('\n');
     }
     // javascript / typescript
+    // Block-scoped dynamic imports avoid collisions with names in the user's module.
     return [
-        "import { writeFileSync, renameSync, existsSync, readFileSync } from 'node:fs';",
-        "import { join } from 'node:path';",
-        "import { randomUUID } from 'node:crypto';",
+        '{',
+        "const { writeFileSync, renameSync, existsSync, readFileSync } = await import('node:fs');",
+        "const { join } = await import('node:path');",
+        "const { randomUUID } = await import('node:crypto');",
         'globalThis.codebuddyToolCall = function codebuddyToolCall(tool, args) {',
         '  const dir = process.env.CODEBUDDY_EXECUTE_CODE_RPC_DIR;',
         "  if (!dir) return { ok: false, error: 'EXECUTE_CODE_TOOL_RPC_UNAVAILABLE' };",
@@ -524,6 +558,7 @@ function buildRpcHelper(language) {
         '  }',
         "  return { ok: false, error: 'RPC_RESPONSE_TIMEOUT' };",
         '};',
+        '}',
         '',
     ].join('\n');
 }

package/dist/tools/fleet-room-tool.d.ts

@@ -0,0 +1,104 @@
+import { z } from 'zod';
+import type { ToolResult } from '../types/index.js';
+export declare const fleetRoomInputSchema: z.ZodDiscriminatedUnion<"action", [z.ZodObject<{
+    action: z.ZodLiteral<"send">;
+    content: z.ZodEffects<z.ZodString, string, string>;
+}, "strict", z.ZodTypeAny, {
+    content: string;
+    action: "send";
+}, {
+    content: string;
+    action: "send";
+}>, z.ZodObject<{
+    action: z.ZodLiteral<"history">;
+    limit: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodObject<{
+        storeId: z.ZodString;
+        throughSeq: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        storeId: string;
+        throughSeq: number;
+    }, {
+        storeId: string;
+        throughSeq: number;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    action: "history";
+    limit?: number | undefined;
+    cursor?: {
+        storeId: string;
+        throughSeq: number;
+    } | undefined;
+}, {
+    action: "history";
+    limit?: number | undefined;
+    cursor?: {
+        storeId: string;
+        throughSeq: number;
+    } | undefined;
+}>, z.ZodObject<{
+    action: z.ZodLiteral<"status">;
+}, "strict", z.ZodTypeAny, {
+    action: "status";
+}, {
+    action: "status";
+}>]>;
+interface Cursor {
+    storeId: string;
+    throughSeq: number;
+}
+interface Message {
+    seq: number;
+    room: string;
+    author: string;
+    text: string;
+    event: {
+        id: string;
+        created_at: number;
+    };
+}
+export interface FleetRoomToolClient {
+    connect(): Promise<{
+        pubkey: string;
+        name: string;
+        rooms: unknown[];
+    }>;
+    publish(input: {
+        room: string;
+        content: string;
+    }): Promise<{
+        id: string;
+        seq: number;
+        duplicate: boolean;
+        storeId: string;
+    }>;
+    fetch(filters: Array<{
+        '#h': string[];
+        limit: number;
+    }>, cursor?: Cursor, options?: {
+        maxMessages?: number;
+    }): Promise<{
+        messages: Message[];
+        cursor: Cursor;
+        gap: boolean;
+        epochChanged: boolean;
+        truncated?: boolean;
+    }>;
+    close(): Promise<void>;
+}
+export interface FleetRoomToolConfig {
+    url: string;
+    room: string;
+    identityPath: string;
+    apiKey?: string;
+    jwt?: string;
+}
+export interface FleetRoomToolDependencies {
+    env?: NodeJS.ProcessEnv;
+    createClient?: (config: FleetRoomToolConfig) => Promise<FleetRoomToolClient>;
+    /** Test seam; runtime budget is 15 seconds plus at most 1 second cleanup. */
+    timeoutMs?: number;
+}
+/** One bounded client lifecycle per invocation; never subscribes a background worker. */
+export declare function executeFleetRoom(input: unknown, deps?: FleetRoomToolDependencies): Promise<ToolResult>;
+export {};