@phuetz/code-buddy 2.0.0 → 2.1.0

package/dist/codebuddy/tools.js

@@ -1,10 +1,15 @@
+import { A2A_CALL_TOOL_DEF } from './a2a-call-tool-defs.js';
+import { RESOURCE_CATALOG_TOOL_DEF } from './resource-catalog-tool-defs.js';
+import { RAGCHAT_TOOL_DEF } from './ragchat-tool-defs.js';
+import { integrationToolHints } from '../tools/integration-tool-hints.js';
 /**
  * Grok Tools
  *
  * Main entry point for tool definitions and management.
  * Tools are now organized in modular files under tool-definitions/.
  */
-import { setDeferredMCPSchemas } from "../tools/deferred-schema-state.js";
+import { TOOL_METADATA as SEARCH_TOOL_METADATA } from '../tools/metadata.js';
+import { setDeferredMCPSchemas, resolveDeferredSchemas as resolveSelectedSchemas } from "../tools/deferred-schema-state.js";
 import { MCPManager } from "../mcp/client.js";
 import { loadMCPConfig } from "../mcp/config.js";
 import { getToolSelector, selectRelevantTools } from "../tools/tool-selector.js";
@@ -137,6 +142,7 @@ export function getBuiltinToolNames() {
         MERGE_CONFLICT_TOOLS,
         VULN_SCANNER_TOOLS,
         SESSION_TOOLS,
+        [RAGCHAT_TOOL_DEF, RESOURCE_CATALOG_TOOL_DEF, A2A_CALL_TOOL_DEF],
         FLEET_TOOLS,
         CODE_EXPLORER_TOOLS,
         WINDOWS_TOOLS,
@@ -269,6 +275,7 @@ export function initializeToolRegistry() {
     registerGroup(SESSION_TOOLS);
     // Fleet tools — peer_delegate, list_peers (Phase (d).17). Always available;
     // peer_delegate returns a clear error when no peers are connected.
+    registerGroup([RAGCHAT_TOOL_DEF, RESOURCE_CATALOG_TOOL_DEF, A2A_CALL_TOOL_DEF]);
     registerGroup(FLEET_TOOLS);
     // CodeExplorer tools
     registerGroup(CODE_EXPLORER_TOOLS);
@@ -593,6 +600,8 @@ export async function getAllCodeBuddyTools() {
         initToolSearchIndex(allTools.map((t) => ({
             name: t.function.name,
             description: t.function.description ?? '',
+            parameters: t.function.parameters,
+            keywords: SEARCH_TOOL_METADATA.find(meta => meta.name === t.function.name)?.keywords,
         })));
     }
     catch {
@@ -603,6 +612,12 @@ export async function getAllCodeBuddyTools() {
 // ============================================================================
 // Tool Selection (RAG-based)
 // ============================================================================
+/** Hydrate only names already exposed by assembly/selection; never add permissions. */
+function hydrateExposedToolSchemas(tools) {
+    const resolved = new Map(resolveSelectedSchemas(tools.map(tool => tool.function.name))
+        .map(tool => [tool.function.name, tool]));
+    return tools.map(tool => resolved.get(tool.function.name) ?? tool);
+}
 /**
  * Get relevant tools for a specific query using RAG-based selection
  *
@@ -621,7 +636,7 @@ export async function getRelevantTools(query, options = {}) {
     // If RAG is disabled, return all tools
     if (!useRAG) {
         return {
-            selectedTools: allTools,
+            selectedTools: hydrateExposedToolSchemas(allTools),
             scores: new Map(allTools.map(t => [t.function.name, 1])),
             classification: {
                 categories: ['file_read', 'file_write', 'system'],
@@ -633,7 +648,14 @@ export async function getRelevantTools(query, options = {}) {
             originalTokens: 0
         };
     }
-    return selectRelevantTools(query, allTools, maxTools, options.alwaysInclude);
+    const preferred = integrationToolHints(query, allTools.map(tool => tool.function.name));
+    const selection = selectRelevantTools(query, allTools, maxTools, [
+        ...(options.alwaysInclude ?? ['view_file', 'bash']), ...preferred,
+    ]);
+    // Once selected, a deferred MCP tool must expose its argument schema.
+    // Empty stubs otherwise force valid models to emit {} for required inputs.
+    selection.selectedTools = hydrateExposedToolSchemas(selection.selectedTools);
+    return selection;
 }
 /**
  * Classify a query to understand what types of tools are needed

package/dist/commands/cli/daemon-commands.js

@@ -144,16 +144,17 @@ export function registerDaemonCommands(program) {
                 const { getCronAgentBridge } = await import('../../daemon/cron-agent-bridge.js');
                 const { getCronScheduler } = await import('../../scheduler/cron-scheduler.js');
                 const { RunStore } = await import('../../observability/run-store.js');
+                const scheduler = getCronScheduler();
                 const bridge = getCronAgentBridge({
                     apiKey,
                     baseURL: process.env.GROK_BASE_URL,
                     model: process.env.GROK_MODEL || 'grok-3-latest',
                     maxToolRounds: 20,
                     jobTimeoutMs: 300000,
+                    notepadDir: scheduler.notepadDir,
                     // Scheduled executions become first-class run records + artifacts.
                     runStore: RunStore.getInstance(),
                 });
-                const scheduler = getCronScheduler();
                 scheduler.setTaskExecutor(bridge.createTaskExecutor());
             }
         }
@@ -175,6 +176,7 @@ export function registerDaemonCommands(program) {
                         model: process.env.GROK_MODEL || 'grok-3-latest',
                         maxToolRounds: 20,
                         jobTimeoutMs: 600000,
+                        notepadDir: scheduler.notepadDir,
                         runStore: RunStore.getInstance(),
                     });
                     scheduler.setTaskExecutor(bridge.createTaskExecutor());

package/dist/commands/cli/evolve-command.js

@@ -129,6 +129,20 @@ export function registerEvolveCommands(program) {
             process.exitCode = 1;
             return;
         }
+        if (!v.passedAll || v.regressions.length || !/^[a-f0-9]{40,64}$/.test(v.sha)) {
+            logger.error('Variant is not eligible: missing verified commit, failed checks, or regressions.');
+            process.exitCode = 1;
+            return;
+        }
+        try {
+            if (git(['rev-parse', '--verify', `${v.branch}^{commit}`]).trim() !== v.sha)
+                throw new Error('Variant branch changed since evaluation');
+        }
+        catch (error) {
+            logger.error(error instanceof Error ? error.message : String(error));
+            process.exitCode = 1;
+            return;
+        }
         if (!options.confirm) {
             logger.info(`Preview: keep ${v.id} (${v.branch}) → merge into '${current}'.`);
             logger.info(`  fitness=${v.score.toFixed(3)}  passedAll=${v.passedAll}  regressions=[${v.regressions.join(', ')}]`);
@@ -136,7 +150,7 @@ export function registerEvolveCommands(program) {
             return;
         }
         try {
-            execFileSync('git', ['merge', '--no-ff', '-m', `evolve: keep ${v.id} (${v.detail ?? ''})`, v.branch], {
+            execFileSync('git', ['merge', '--no-ff', '-m', `evolve: keep ${v.id} (${v.detail ?? ''})`, v.sha], {
                 stdio: 'inherit',
             });
             logger.info(`Merged ${v.branch} into '${current}'. Review the result and run your full validation.`);
@@ -155,6 +169,7 @@ export function registerEvolveCommands(program) {
         .option('--rounds <n>', 'Candidates per goal (fan-out), or max auto-weaknesses', '1')
         .option('--concurrency <n>', 'How many candidates to evaluate at once', '2')
         .option('--baseline <ref>', 'Baseline ref to branch from + rank against', 'main')
+        .option('--eval-task <ids...>', 'Opt in to whole-agent LLM eval tasks; default objective is the offline harness benchmark')
         .option('--model <model>', 'Model for the mutator agent + planner')
         .option('--model-bandit', 'Pick the mutator model per-cycle with the cost-aware UCB bandit (opt-in; overrides --model per cycle)')
         .option('--no-plan', 'Skip deliberate planning (use the ad-hoc mutator prompt)')
@@ -173,11 +188,12 @@ export function registerEvolveCommands(program) {
         }
         const { runEvolutionRound, agentMutator, formatEvolveRoundSummary } = await import('../../agent/self-improvement/evolution/evolution-engine.js');
         const { makeLlmVariantPlanner } = await import('../../agent/self-improvement/evolution/variant-planner.js');
-        const { computeFitness, defaultDeterministicComponents } = await import('../../agent/self-improvement/evolution/variant-fitness.js');
-        const baselineRef = options.baseline ?? 'main';
+        const { defaultDeterministicComponents, evalTasksComponent, harnessTasksComponent } = await import('../../agent/self-improvement/evolution/variant-fitness.js');
+        const { scoreReferenceInWorktree } = await import('../../agent/self-improvement/evolution/worktree-scorer.js');
+        const baselineRef = git(['rev-parse', '--verify', `${options.baseline ?? 'main'}^{commit}`]).trim();
         const rounds = Math.max(1, Number(options.rounds ?? '1') || 1);
         const concurrency = Math.max(1, Number(options.concurrency ?? '2') || 2);
-        const components = defaultDeterministicComponents();
+        const components = [...defaultDeterministicComponents(true), options.evalTask ? evalTasksComponent(options.evalTask) : harnessTasksComponent()];
         const mutate = agentMutator(options.model ? { model: options.model } : {});
         // Deliberate planner (default on). --no-plan → a planner that returns null → mutator's ad-hoc prompt.
         const planner = options.plan === false
@@ -219,7 +235,7 @@ export function registerEvolveCommands(program) {
             logger.info(`Selected ${weaknesses.length} weakness(es): ${weaknesses.map((w) => w.goal.slice(0, 60)).join(' | ')}`);
         }
         logger.info(`Scoring baseline (${baselineRef})…`);
-        const baseline = await computeFitness({ checkoutDir: process.cwd() }, components);
+        const baseline = (await scoreReferenceInWorktree(baselineRef, { components })).report;
         logger.info(`  baseline fitness=${baseline.score.toFixed(3)}`);
         // Compounding: build each candidate on top of the current best elite (guarded by reachability
         // in the engine → falls back to baseline if that elite branch was pruned). Fitness stays vs baseline.

package/dist/commands/cli/fleet-collaboration-commands.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerFleetCollaborationCommands(fleet: Command): void;

package/dist/commands/cli/fleet-collaboration-commands.js

@@ -0,0 +1,57 @@
+import { readFile } from 'node:fs/promises';
+export function registerFleetCollaborationCommands(fleet) {
+    const run = async (options, goal) => {
+        const controller = new AbortController();
+        const stop = () => controller.abort();
+        process.once('SIGINT', stop);
+        process.once('SIGTERM', stop);
+        try {
+            const { parseCollaborationConfig, runCollaboration } = await import('../../fleet/collaboration.js');
+            const config = parseCollaborationConfig(JSON.parse(await readFile(options.config, 'utf8')));
+            const report = await runCollaboration(config, {
+                goal, timeoutMs: Number(options.timeout), signal: controller.signal,
+                onProgress: options.json ? undefined : message => { process.stderr.write(`${message}\n`); },
+            });
+            if (options.json)
+                process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+            else {
+                process.stdout.write(`Fleet: ${report.status}\n`);
+                for (const peer of report.peers) {
+                    process.stdout.write(`\n${peer.id} — ${peer.status}${peer.model ? ` (${peer.model})` : ''}\n${peer.error ?? peer.text ?? 'Authenticated and ready for peer.chat'}\n`);
+                }
+                if (report.synthesis)
+                    process.stdout.write(`\nSynthesis (${report.synthesis.peer})\n${report.synthesis.text}\n`);
+                if (report.synthesisError)
+                    process.stdout.write(`\nSynthesis: ${report.synthesisError}\n`);
+            }
+            if (report.status !== 'complete')
+                process.exitCode = 1;
+        }
+        catch (error) {
+            // Syntax errors can quote raw configuration, which may contain misplaced secrets.
+            const message = error instanceof SyntaxError ? 'Invalid fleet JSON configuration' : error instanceof Error ? error.message : 'Fleet operation failed';
+            if (options.json)
+                process.stdout.write(`${JSON.stringify({ status: 'failed', error: message })}\n`);
+            else
+                process.stderr.write(`${message}\n`);
+            process.exitCode = 1;
+        }
+        finally {
+            process.removeListener('SIGINT', stop);
+            process.removeListener('SIGTERM', stop);
+        }
+    };
+    fleet.command('check')
+        .description('Verify authenticated peers and chat readiness without calling an LLM')
+        .requiredOption('--config <file>', 'Fleet JSON configuration (token environment variable names only)')
+        .option('--timeout <ms>', 'Per-request timeout, 1000–300000 ms', '10000')
+        .option('--json', 'Structured report')
+        .action((options) => run(options));
+    fleet.command('collaborate <goal>')
+        .description('Collect parallel peer reviews, then synthesize them (no remote file edits)')
+        .requiredOption('--config <file>', 'Fleet JSON configuration (2–8 peers)')
+        .option('--timeout <ms>', 'Per-request timeout, 1000–300000 ms', '120000')
+        .option('--json', 'Structured report')
+        .action((goal, options) => run(options, goal));
+}
+//# sourceMappingURL=fleet-collaboration-commands.js.map

package/dist/commands/cli/fleet-commands.js

@@ -4,6 +4,9 @@
  * These commands expose the same dispatch profile policy decisions used by
  * Cowork/Fleet so an operator can inspect a route before running it.
  */
+import { registerFleetMissionCommands } from './fleet-mission-commands.js';
+import { registerFleetCollaborationCommands } from './fleet-collaboration-commands.js';
+import { registerFleetRoomsCommands } from './fleet-rooms-commands.js';
 import { createTokenCommand, registerFleetTokenCommand } from '../token.js';
 import { DEFAULT_DISPATCH_POLICY_PREVIEW_TOOLS, FLEET_DISPATCH_PROFILES, FLEET_DISPATCH_PROFILE_GUIDANCE, buildHermesToolsetDescriptor, getDispatchToolPolicy, normalizeDispatchProfile, previewDispatchToolDecisions, } from '../../fleet/dispatch-profile.js';
 function resolveFleetServerUrl(serverUrl) {
@@ -68,6 +71,32 @@ export function registerFleetCommands(program) {
     const fleet = program
         .command('fleet')
         .description('Inspect Fleet routing, toolsets, and dispatch policy decisions');
+    registerFleetMissionCommands(fleet);
+    registerFleetRoomsCommands(fleet);
+    registerFleetCollaborationCommands(fleet);
+    fleet.command('supervise <manifest> <operation>')
+        .description('Run a fixed local fleet operation through the Code Buddy harness')
+        .option('--json', 'Output the structured harness result')
+        .action(async (manifest, operation, options) => {
+        const controller = new AbortController();
+        const stop = () => controller.abort();
+        process.once('SIGINT', stop);
+        process.once('SIGTERM', stop);
+        try {
+            const { runSupervisor } = await import('../../harness/fleet-supervisor.js');
+            const result = await runSupervisor(manifest, operation, { signal: controller.signal });
+            console.log(options.json ? JSON.stringify({ kind: 'fleet_supervisor_result', operation, ...result }) : result.output ?? result.error ?? '');
+            if (!result.success)
+                process.exitCode = 1;
+        }
+        catch (error) {
+            printFleetServerError(error);
+        }
+        finally {
+            process.removeListener('SIGINT', stop);
+            process.removeListener('SIGTERM', stop);
+        }
+    });
     fleet
         .command('status')
         .description('Show Fleet status from the configured Code Buddy server')

package/dist/commands/cli/fleet-mission-commands.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from 'commander';
+/** All paths/manifests are operator input. No provider or server is booted. */
+export declare function registerFleetMissionCommands(fleet: Command): void;

package/dist/commands/cli/fleet-mission-commands.js

@@ -0,0 +1,72 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { MissionStore } from '../../harness/mission-store.js';
+import { runMission } from '../../harness/mission-runner.js';
+import { parseSupervisorManifest } from '../../harness/fleet-supervisor.js';
+/** All paths/manifests are operator input. No provider or server is booted. */
+export function registerFleetMissionCommands(fleet) {
+    const group = fleet.command('mission').description('Durable local mission ownership, handoff and results');
+    const output = (action) => async (...args) => {
+        try {
+            console.log(JSON.stringify(await action(...args.filter(a => typeof a === 'string'))));
+        }
+        catch (error) {
+            console.error(error instanceof Error ? error.message : String(error));
+            process.exitCode = 1;
+        }
+    };
+    group.command('list <store>')
+        .description('List mission metadata, with bounded pages and unreadable-record notices')
+        .option('--limit <count>', 'Maximum records examined in this page (1..100)', '25')
+        .option('--cursor <hash>', 'Continue after the previous page nextCursor')
+        .action((directory, options) => {
+        try {
+            console.log(JSON.stringify(new MissionStore(directory).list({ limit: Number(options.limit), cursor: options.cursor })));
+        }
+        catch (error) {
+            console.error(error instanceof Error ? error.message : String(error));
+            process.exitCode = 1;
+        }
+    });
+    group.command('create <store> <id> <manifest> <operation>').action(output(async (directory, id, manifestPath, name) => {
+        const file = path.resolve(manifestPath);
+        const manifest = parseSupervisorManifest(JSON.parse(await fs.readFile(file, 'utf8')), path.dirname(file), 43200000);
+        const op = manifest.operations.get(name);
+        if (!op)
+            throw new Error('Unknown manifest operation');
+        return new MissionStore(directory).create(id, { command: op.command, args: op.args, timeoutMs: op.timeoutMs, workspace: manifest.workspace });
+    }));
+    group.command('show <store> <id>').action(output((directory, id) => new MissionStore(directory).get(id)));
+    group.command('claim <store> <id> <owner>').action(output((directory, id, owner) => new MissionStore(directory).claim(id, owner)));
+    group.command('renew <store> <id> <owner> <generation>').action(output((directory, id, owner, generation) => new MissionStore(directory).renew(id, { owner: owner, generation: generation })));
+    group.command('run <store> <id> <owner> <generation>').action(output(async (directory, id, owner, generation) => {
+        const controller = new AbortController();
+        const stop = () => controller.abort();
+        process.once('SIGINT', stop);
+        process.once('SIGTERM', stop);
+        try {
+            const mission = await runMission(new MissionStore(directory), id, { owner: owner, generation: generation }, controller.signal);
+            if (!mission.result?.success)
+                process.exitCode = 1;
+            return mission;
+        }
+        finally {
+            process.removeListener('SIGINT', stop);
+            process.removeListener('SIGTERM', stop);
+        }
+    }));
+    group.command('handoff <store> <id> <owner> <generation> <capsule>').action(output(async (directory, id, owner, generation, capsule) => new MissionStore(directory).handoff(id, { owner: owner, generation: generation }, JSON.parse(await fs.readFile(capsule, 'utf8')))));
+    group.command('reconcile <store> <id> <generation> <resolution> <evidence>').action(output((directory, id, generation, resolution, evidence) => new MissionStore(directory).reconcile(id, generation, resolution, evidence)));
+    group.command('ack <store> <id> <consumer>').action(output((directory, id, consumer) => new MissionStore(directory).acknowledge(id, consumer)));
+    const head = (workspace) => execFileSync('git', ['rev-parse', '--verify', 'HEAD'], { cwd: workspace, encoding: 'utf8', timeout: 5000 }).trim();
+    group.command('submit <store> <id> <owner> <generation>').action(output((directory, id, owner, generation) => {
+        const store = new MissionStore(directory);
+        return store.submit(id, { owner: owner, generation: generation }, head(store.get(id).operation.workspace));
+    }));
+    group.command('approve <store> <id> <reviewer> <commit>').action(output((directory, id, reviewer, commit) => {
+        const store = new MissionStore(directory);
+        return store.approve(id, reviewer, commit);
+    }));
+}
+//# sourceMappingURL=fleet-mission-commands.js.map

package/dist/commands/cli/fleet-rooms-commands.d.ts

@@ -0,0 +1,10 @@
+/**
+ * `buddy fleet rooms` — persistent signed messages between fleet members.
+ *
+ * Messages are data: `read` and `tail` print sanitized text and never run
+ * anything. Credentials come from the environment by default
+ * (`CODEBUDDY_FLEET_ROOMS_URL`, `CODEBUDDY_FLEET_API_KEY` / `CODEBUDDY_FLEET_TOKEN`);
+ * the member secret stays in its 0600 identity file and is never printed.
+ */
+import type { Command } from 'commander';
+export declare function registerFleetRoomsCommands(fleet: Command): void;

package/dist/commands/cli/fleet-rooms-commands.js

@@ -0,0 +1,289 @@
+/**
+ * `buddy fleet rooms` — persistent signed messages between fleet members.
+ *
+ * Messages are data: `read` and `tail` print sanitized text and never run
+ * anything. Credentials come from the environment by default
+ * (`CODEBUDDY_FLEET_ROOMS_URL`, `CODEBUDDY_FLEET_API_KEY` / `CODEBUDDY_FLEET_TOKEN`);
+ * the member secret stays in its 0600 identity file and is never printed.
+ */
+const collect = (value, previous) => [...previous, value];
+function addConnectionOptions(command) {
+    return command
+        .option('--url <url>', 'hub WebSocket URL (default $CODEBUDDY_FLEET_ROOMS_URL)')
+        .option('--api-key <key>', 'hub API key with fleet:listen (prefer $CODEBUDDY_FLEET_API_KEY)')
+        .option('--jwt <token>', 'hub JWT with fleet:listen (prefer $CODEBUDDY_FLEET_TOKEN)')
+        .option('--audience <url>', 'hub URL to sign for when reached through a proxy')
+        .option('--identity <file>', 'member identity file (default $CODEBUDDY_FLEET_ROOMS_IDENTITY)')
+        .option('--json', 'machine-readable output');
+}
+function fail(error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+}
+async function connect(options) {
+    const url = options.url ?? process.env.CODEBUDDY_FLEET_ROOMS_URL;
+    if (!url)
+        throw new Error('hub URL required: --url or CODEBUDDY_FLEET_ROOMS_URL');
+    const apiKey = options.apiKey ?? process.env.CODEBUDDY_FLEET_API_KEY;
+    const jwt = options.jwt ?? process.env.CODEBUDDY_FLEET_TOKEN;
+    const [{ FleetRoomClient }, { loadRoomIdentity }] = await Promise.all([
+        import('../../fleet/rooms/room-client.js'),
+        import('../../fleet/rooms/room-identity.js'),
+    ]);
+    const identity = loadRoomIdentity(options.identity);
+    const client = new FleetRoomClient({
+        url,
+        secretKey: identity.secretKey,
+        ...(apiKey ? { apiKey } : jwt ? { jwt } : {}),
+        ...(options.audience ? { audience: options.audience } : {}),
+    });
+    try {
+        const session = await client.connect();
+        return { client, session };
+    }
+    catch (error) {
+        await client.close();
+        throw error;
+    }
+}
+function toJson(message) {
+    return {
+        seq: message.seq,
+        id: message.event.id,
+        room: message.room,
+        author: message.author,
+        createdAt: message.event.created_at,
+        mentions: message.mentions,
+        ...(message.thread ? { thread: message.thread } : {}),
+        text: message.text,
+    };
+}
+function printMessage(message) {
+    const when = new Date(message.event.created_at * 1000).toISOString();
+    const reply = message.thread ? ` ↳${message.thread.parent.slice(0, 8)}` : '';
+    console.log(`#${message.seq} ${when} ${message.author.slice(0, 12)}${reply} [${message.event.id.slice(0, 8)}]\n  ${message.text.replace(/\n/g, '\n  ')}`);
+}
+async function readCursor(file, room) {
+    const fs = await import('node:fs/promises');
+    let raw;
+    try {
+        raw = await fs.readFile(file, 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw error;
+    }
+    const parsed = JSON.parse(raw);
+    if (parsed.version !== 1 || parsed.room !== room || typeof parsed.storeId !== 'string' ||
+        !Number.isSafeInteger(parsed.throughSeq) || parsed.throughSeq < 0) {
+        throw new Error(`cursor file ${file} does not belong to room ${room}`);
+    }
+    return { storeId: parsed.storeId, throughSeq: parsed.throughSeq };
+}
+async function writeCursor(file, room, cursor) {
+    const { writeJsonAtomic } = await import('../../utils/atomic-write.js');
+    await writeJsonAtomic(file, { version: 1, room, storeId: cursor.storeId, throughSeq: cursor.throughSeq });
+}
+function filterFor(room, options, pubkey) {
+    const filter = { '#h': [room], kinds: [9] };
+    if (options.mentionsMe)
+        filter['#p'] = [pubkey];
+    if (options.limit !== undefined) {
+        const limit = Number(options.limit);
+        if (!Number.isSafeInteger(limit) || limit < 0 || limit > 500)
+            throw new Error('--limit must be an integer between 0 and 500');
+        filter.limit = limit;
+    }
+    return filter;
+}
+export function registerFleetRoomsCommands(fleet) {
+    const rooms = fleet
+        .command('rooms')
+        .description('Persistent signed messages between fleet members (read as data, never executed)');
+    const identity = rooms.command('identity').description('Member key used to sign room messages');
+    identity.command('init')
+        .description('Create this member key (0600 file); prints only the public key')
+        .option('--identity <file>', 'identity file (default $CODEBUDDY_FLEET_ROOMS_IDENTITY)')
+        .option('--force', 'rotate: keep the old file aside and create a new key')
+        .option('--json', 'machine-readable output')
+        .action(async (options) => {
+        try {
+            const { createRoomIdentity } = await import('../../fleet/rooms/room-identity.js');
+            const created = createRoomIdentity(options.identity, { force: options.force === true });
+            console.log(options.json
+                ? JSON.stringify({ publicKey: created.publicKey, path: created.path })
+                : `Room key created: ${created.publicKey}\nAsk the hub operator to add it to rooms.json.`);
+        }
+        catch (error) {
+            fail(error);
+        }
+    });
+    identity.command('show')
+        .description('Print this member public key')
+        .option('--identity <file>', 'identity file (default $CODEBUDDY_FLEET_ROOMS_IDENTITY)')
+        .option('--json', 'machine-readable output')
+        .action(async (options) => {
+        try {
+            const { loadRoomIdentity } = await import('../../fleet/rooms/room-identity.js');
+            const loaded = loadRoomIdentity(options.identity);
+            console.log(options.json ? JSON.stringify({ publicKey: loaded.publicKey, path: loaded.path }) : loaded.publicKey);
+        }
+        catch (error) {
+            fail(error);
+        }
+    });
+    addConnectionOptions(rooms.command('post <room> <text...>'))
+        .description('Sign and publish a message; returns once the hub stored it durably')
+        .option('--mention <pubkey>', 'notify a member (repeatable)', collect, [])
+        .option('--reply-to <id>', 'answer this message')
+        .option('--reply-root <id>', 'thread root when answering a nested reply')
+        .action(async (room, words, options) => {
+        let client;
+        try {
+            const connected = await connect(options);
+            client = connected.client;
+            const replyTo = options.replyTo
+                ? { root: options.replyRoot ?? options.replyTo, parent: options.replyTo }
+                : undefined;
+            const ack = await connected.client.publish({
+                room,
+                content: words.join(' '),
+                mentions: options.mention,
+                ...(replyTo ? { replyTo } : {}),
+            });
+            console.log(options.json ? JSON.stringify(ack) : `${ack.duplicate ? 'Already stored' : 'Stored'} #${ack.seq} ${ack.id}`);
+        }
+        catch (error) {
+            fail(error);
+        }
+        finally {
+            await client?.close();
+        }
+    });
+    addConnectionOptions(rooms.command('read <room>'))
+        .description('Print stored messages; with --cursor, only those after the saved cursor')
+        .option('--limit <n>', 'newest messages to show without a cursor (0..500, default 100)')
+        .option('--mentions-me', 'only messages mentioning this member')
+        .option('--cursor <file>', 'resume after, then update, the cursor saved in this file')
+        .action(async (room, options) => {
+        let client;
+        try {
+            const connected = await connect(options);
+            client = connected.client;
+            const previous = options.cursor ? await readCursor(options.cursor, room) : undefined;
+            const result = await connected.client.fetch([filterFor(room, options, connected.client.pubkey)], previous);
+            if (options.cursor)
+                await writeCursor(options.cursor, room, result.cursor);
+            if (options.json) {
+                console.log(JSON.stringify({
+                    messages: result.messages.map(toJson),
+                    cursor: result.cursor,
+                    gap: result.gap,
+                    epochChanged: result.epochChanged,
+                    truncated: result.truncated,
+                }));
+            }
+            else {
+                if (result.gap)
+                    console.log('! some messages after your cursor were evicted by retention');
+                if (result.epochChanged)
+                    console.log('! the hub ledger changed generation; showing current history');
+                if (result.truncated)
+                    console.log('! more messages remain; read again with --cursor to continue');
+                for (const message of result.messages)
+                    printMessage(message);
+                if (result.messages.length === 0)
+                    console.log('(no messages)');
+            }
+        }
+        catch (error) {
+            fail(error);
+        }
+        finally {
+            await client?.close();
+        }
+    });
+    addConnectionOptions(rooms.command('tail <room>'))
+        .description('Follow a room live (reconnects and catches up automatically) until Ctrl+C')
+        .option('--mentions-me', 'only messages mentioning this member')
+        .option('--cursor <file>', 'resume after, and keep updating, the cursor saved in this file')
+        .action(async (room, options) => {
+        let client;
+        let finish = () => { };
+        const done = new Promise(resolve => { finish = resolve; });
+        let pendingWrite;
+        let latestCursor;
+        let caughtUp = false;
+        const persist = (cursor) => {
+            if (!options.cursor)
+                return;
+            latestCursor = cursor;
+            if (pendingWrite)
+                return;
+            const file = options.cursor;
+            pendingWrite = (async () => {
+                while (latestCursor) {
+                    const next = latestCursor;
+                    latestCursor = undefined;
+                    await writeCursor(file, room, next);
+                }
+            })().catch(error => { fail(error); finish(); }).finally(() => {
+                pendingWrite = undefined;
+                if (latestCursor)
+                    persist(latestCursor);
+            });
+        };
+        const disconnected = () => { caughtUp = false; };
+        const exhausted = () => { fail(new Error('Room reconnection attempts exhausted')); finish(); };
+        const reconnectError = (error) => {
+            if (error.code === 'ROOM_AUTH_REFUSED') {
+                fail(error);
+                finish();
+            }
+        };
+        try {
+            client = (await connect(options)).client;
+            const previous = options.cursor ? await readCursor(options.cursor, room) : undefined;
+            process.once('SIGINT', finish);
+            process.once('SIGTERM', finish);
+            client.on('disconnected', disconnected);
+            client.on('reconnect-exhausted', exhausted);
+            client.on('reconnect-error', reconnectError);
+            const handle = client.subscribe('tail', [filterFor(room, { ...options, limit: '20' }, client.pubkey)], {
+                onMessage: (message) => {
+                    if (options.json)
+                        console.log(JSON.stringify(toJson(message)));
+                    else
+                        printMessage(message);
+                    const cursor = handle.cursor();
+                    if (caughtUp && cursor)
+                        persist(cursor);
+                },
+                onEose: (info) => {
+                    caughtUp = true;
+                    persist({ storeId: info.storeId, throughSeq: info.throughSeq });
+                },
+                onClosed: (message) => {
+                    fail(new Error(message));
+                    finish();
+                },
+            }, previous);
+            await done;
+        }
+        catch (error) {
+            fail(error);
+        }
+        finally {
+            process.removeListener('SIGINT', finish);
+            process.removeListener('SIGTERM', finish);
+            client?.off('disconnected', disconnected);
+            client?.off('reconnect-exhausted', exhausted);
+            client?.off('reconnect-error', reconnectError);
+            await client?.close();
+            while (pendingWrite)
+                await pendingWrite;
+        }
+    });
+}
+//# sourceMappingURL=fleet-rooms-commands.js.map