@phuetz/code-buddy 2.0.0 → 2.2.0

package/dist/codebuddy/tool-definitions/cron-tools.js

@@ -67,6 +67,12 @@ export const CRONJOB_TOOL = {
                     type: 'string',
                     description: 'Chain target: job id (or unique id prefix) to run on successful completion of this job.',
                 },
+                continuity: {
+                    type: 'object',
+                    description: 'Opt-in per-job memory: {enabled: true, notes: {key: value}}. Bounded notes and the last successful output persist across runs. Default off.',
+                    properties: { enabled: { type: 'boolean' }, notes: { type: 'object', additionalProperties: { type: 'string' } } },
+                    additionalProperties: false,
+                },
                 preCheck: {
                     type: 'object',
                     description: 'Optional file_changed or command pre-check gate for create.',

package/dist/codebuddy/tool-definitions/self-describe-tools.js

@@ -4,10 +4,15 @@ export const SELF_DESCRIBE_TOOL = {
     function: {
         name: 'self_describe',
         description: "Inspect this robot/agent's implementation and evidenced turn metadata: package/revision, relevant code areas, model/provider/surface, registered versus currently exposed tools, configuration-only faculties, and explicit limits. It performs no live hardware, process, service, or network probes; unavailable attestations remain unknown. " +
-            'Use it for technical introspection and questions about current capabilities. Its output is a verifiable operational self-model, never evidence of subjective consciousness.',
+            'Optional operation=list/read/search explores attested implementation files under src/ or dist/ with paths and line numbers; no arbitrary workspace access. Use it for technical introspection and questions about current settings (theme, model, provider, permissions, turn limits) and capabilities. Its output is a verifiable operational self-model, never evidence of subjective consciousness.',
         parameters: {
             type: 'object',
             properties: {
+                operation: { type: 'string', enum: ['list', 'read', 'search'], description: 'Omit for runtime settings and overview. Use list/read/search for deeper code research.' },
+                path: { type: 'string', maxLength: 160, description: 'Relative core implementation path. Default src/ in a checkout, dist/ in an installed package.' },
+                query: { type: 'string', maxLength: 160, description: 'Literal text for search, never a shell command or regex.' },
+                offset: { type: 'integer', description: 'Zero-based list offset. Use returned nextOffset to continue a truncated directory listing.' },
+                line: { type: 'integer', description: 'First line to read; returns at most 120 lines.' },
                 focus: {
                     type: 'string',
                     maxLength: 320,

package/dist/codebuddy/tools.d.ts

@@ -1,9 +1,3 @@
-/**
- * Grok Tools
- *
- * Main entry point for tool definitions and management.
- * Tools are now organized in modular files under tool-definitions/.
- */
 import type { CodeBuddyTool, JsonSchemaProperty } from "./client.js";
 import { MCPManager, MCPTool } from "../mcp/client.js";
 import { getToolSelector, ToolSelectionResult, QueryClassification, ToolCategory } from "../tools/tool-selector.js";

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;