@phuetz/code-buddy 1.1.0 → 1.3.0

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

@@ -22,6 +22,7 @@ import { buildHermesToolsetCatalog, } from '../../agent/hermes-toolset-catalog.j
 import { buildHermesHookLifecycleManifest, renderHermesHookLifecycleManifest, } from '../../hooks/hermes-lifecycle-hooks.js';
 import { buildHermesPortalStatus, renderHermesPortalStatus, } from '../../agent/hermes-portal-status.js';
 import { buildHermesRuntimeBackendsReadiness, renderHermesRuntimeBackendsReadiness, runHermesRuntimeBackendSmoke, } from '../../agent/hermes-runtime-backends.js';
+import { buildBackendLifecycleStatusReport, executeBackendLifecycleAction, renderBackendLifecycleAction, renderBackendLifecycleStatusReport, } from '../../agent/hermes-runtime-lifecycle.js';
 import { buildHermesBrowserBackendsReadiness, renderHermesBrowserBackendsReadiness, renderHermesBrowserSmoke, runHermesBrowserBackendSmoke, } from '../../agent/hermes-browser-backends.js';
 import { buildHermesMemoryProvidersReadiness, renderHermesMemoryProvidersReadiness, probeMemoryProvider, renderHermesMemoryProbe, } from '../../agent/hermes-memory-providers.js';
 import { buildHermesLearningLoopStatus, renderHermesLearningLoopStatus, } from '../../agent/hermes-learning-loop-status.js';
@@ -2455,6 +2456,47 @@ export function registerHermesCommands(program) {
         console.log(`Command: ${command}`);
         console.log(renderHermesMessagingGatewayStatus(status));
     });
+    messaging
+        .command('gateway-status')
+        .description('Print gateway lifecycle status and per-platform slash-command parity')
+        .option('--json', 'output JSON')
+        .action(async (options) => {
+        const { getGatewayLifecycle, buildSlashParityManifest, renderSlashParityManifest } = await import('../../channels/index.js');
+        const lifecycle = getGatewayLifecycle();
+        const gatewayStatus = lifecycle.status();
+        const slashParity = buildSlashParityManifest(lifecycle.getManager());
+        const command = 'buddy hermes messaging gateway-status --json';
+        const payload = {
+            command,
+            kind: 'hermes_messaging_gateway_lifecycle_status',
+            schemaVersion: 1,
+            gateway: gatewayStatus,
+            slashParity,
+        };
+        if (options.json) {
+            console.log(stableJson(payload));
+            return;
+        }
+        const lines = [
+            `Command: ${command}`,
+            '',
+            'Gateway lifecycle status:',
+            `  Status: ${gatewayStatus.ok ? 'ok' : 'needs attention'}`,
+            `  Channels: ${gatewayStatus.totalChannels} total, ${gatewayStatus.connectedCount} connected, ${gatewayStatus.disconnectedCount} disconnected, ${gatewayStatus.errorCount} errors`,
+        ];
+        if (gatewayStatus.channels.length > 0) {
+            lines.push('');
+            lines.push('Per-channel readiness:');
+            for (const ch of gatewayStatus.channels) {
+                lines.push(`  - ${ch.channelId}: ${ch.readiness}` +
+                    `${ch.authenticated ? ', authenticated' : ''}` +
+                    `${ch.error ? `, error: ${ch.error}` : ''}`);
+            }
+        }
+        lines.push('');
+        lines.push(renderSlashParityManifest(slashParity));
+        console.log(lines.join('\n'));
+    });
     const mobile = hermes
         .command('mobile')
         .description('Inspect Hermes mobile supervision gateway readiness');
@@ -2863,6 +2905,72 @@ export function registerHermesCommands(program) {
         console.log(`Command: ${command}`);
         console.log(renderHermesRuntimeBackendsReadiness(readiness));
     });
+    runtime
+        .command('hibernate')
+        .description('Hibernate (suspend) a managed runtime backend')
+        .argument('<backendId>', 'backend id to hibernate (e.g. docker, ssh, modal, daytona)')
+        .option('--container-id <id>', 'Docker container id or name')
+        .option('--ssh-host <host>', 'SSH host for ssh backend')
+        .option('--modal-app <app>', 'Modal app name')
+        .option('--daytona-workspace <ws>', 'Daytona workspace id')
+        .option('--json', 'output JSON')
+        .action((backendId, options) => {
+        const result = executeBackendLifecycleAction(backendId, 'hibernate', {
+            containerId: options.containerId,
+            sshHost: options.sshHost,
+            modalApp: options.modalApp,
+            daytonaWorkspace: options.daytonaWorkspace,
+        });
+        const payload = {
+            kind: 'hermes_runtime_lifecycle_action',
+            schemaVersion: 1,
+            result,
+        };
+        if (options.json) {
+            console.log(stableJson(payload));
+            return;
+        }
+        console.log(renderBackendLifecycleAction(result));
+    });
+    runtime
+        .command('wake')
+        .description('Wake (resume) a managed runtime backend')
+        .argument('<backendId>', 'backend id to wake (e.g. docker, ssh, modal, daytona)')
+        .option('--container-id <id>', 'Docker container id or name')
+        .option('--ssh-host <host>', 'SSH host for ssh backend')
+        .option('--modal-app <app>', 'Modal app name')
+        .option('--daytona-workspace <ws>', 'Daytona workspace id')
+        .option('--json', 'output JSON')
+        .action((backendId, options) => {
+        const result = executeBackendLifecycleAction(backendId, 'wake', {
+            containerId: options.containerId,
+            sshHost: options.sshHost,
+            modalApp: options.modalApp,
+            daytonaWorkspace: options.daytonaWorkspace,
+        });
+        const payload = {
+            kind: 'hermes_runtime_lifecycle_action',
+            schemaVersion: 1,
+            result,
+        };
+        if (options.json) {
+            console.log(stableJson(payload));
+            return;
+        }
+        console.log(renderBackendLifecycleAction(result));
+    });
+    runtime
+        .command('lifecycle-status')
+        .description('Show lifecycle state for all runtime backends')
+        .option('--json', 'output JSON')
+        .action((options) => {
+        const report = buildBackendLifecycleStatusReport();
+        if (options.json) {
+            console.log(stableJson(report));
+            return;
+        }
+        console.log(renderBackendLifecycleStatusReport(report));
+    });
     hermes
         .command('runtime-smoke')
         .description('Run an opt-in live smoke for one Hermes runtime backend')

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

@@ -101,6 +101,129 @@ export function registerImproveCommands(program) {
             .join('\n');
         print({ ...result, committed }, options, text);
     });
+    improve
+        .command('tools')
+        .description('Author + behaviorally validate NEW tools for the agent (held-out gated, anti-gaming)')
+        .option('--json', 'output JSON')
+        .option('--apply', 'keep validated tools for this session (overrides propose-only)')
+        .action(async (options) => {
+        const { ToolImprovementEngine } = await import('../../agent/self-improvement/tool-engine.js');
+        const { LlmToolProposer } = await import('../../agent/self-improvement/llm-tool-proposer.js');
+        const { SEED_TOOL_SCENARIOS } = await import('../../agent/self-improvement/tool-benchmark.js');
+        const engine = new ToolImprovementEngine({
+            scenarios: SEED_TOOL_SCENARIOS,
+            proposer: new LlmToolProposer(),
+            ...(options.apply ? { autonomy: 'auto-apply' } : {}),
+        });
+        const results = await engine.runLoop();
+        const kept = results.map((r) => (r.applied ? r.gate?.appliedRef : null)).filter(Boolean);
+        const text = [
+            `Autonomy: ${results[0]?.autonomy ?? 'propose-only'}`,
+            `Cycles: ${results.length}`,
+            ...results.map((r) => `  ${r.selectedScenarioId ?? '—'}: ${r.applied
+                ? `AUTHORED + KEPT (${r.gate?.appliedRef})`
+                : r.gate?.accepted
+                    ? 'accepted (propose-only) — re-run with --apply to keep'
+                    : r.gate?.rejectionReason
+                        ? `rejected (${r.gate.rejectionReason})`
+                        : r.notes.join('; ')}`),
+            kept.length
+                ? `Kept: ${kept.join(', ')} (archived + persisted to .codebuddy/self-improvement; reloaded at next start when CODEBUDDY_SELF_IMPROVE=true)`
+                : 'No tool kept this run',
+        ].join('\n');
+        print({ kind: 'self_improvement_tools', cycles: results }, options, text);
+    });
+    improve
+        .command('skills')
+        .description('Author + safety-gate NEW skills for the agent (firewall + coverage)')
+        .option('--json', 'output JSON')
+        .option('--apply', 'install validated skills (overrides propose-only)')
+        .action(async (options) => {
+        const { SkillImprovementEngine } = await import('../../agent/self-improvement/skill-engine.js');
+        const { LlmSkillProposer } = await import('../../agent/self-improvement/skill-proposer.js');
+        const { SEED_SKILL_SCENARIOS } = await import('../../agent/self-improvement/skill-benchmark.js');
+        const engine = new SkillImprovementEngine({
+            scenarios: SEED_SKILL_SCENARIOS,
+            proposer: new LlmSkillProposer(),
+            ...(options.apply ? { autonomy: 'auto-apply' } : {}),
+        });
+        const results = await engine.runLoop();
+        const kept = results.map((r) => (r.applied ? r.gate?.appliedRef : null)).filter(Boolean);
+        const text = [
+            `Autonomy: ${results[0]?.autonomy ?? 'propose-only'}`,
+            `Cycles: ${results.length}`,
+            ...results.map((r) => `  ${r.selectedScenarioId ?? '—'}: ${r.applied
+                ? `AUTHORED + INSTALLED (${r.gate?.appliedRef})`
+                : r.gate?.accepted
+                    ? 'accepted (propose-only) — re-run with --apply to install'
+                    : r.gate?.rejectionReason
+                        ? `rejected (${r.gate.rejectionReason})`
+                        : r.notes.join('; ')}`),
+            kept.length ? `Installed: ${kept.join(', ')} (under .codebuddy/skills/authored)` : 'No skill installed this run',
+        ].join('\n');
+        print({ kind: 'self_improvement_skills', cycles: results }, options, text);
+    });
+    improve
+        .command('skills-list')
+        .description('List installed authored skills (with pinned status)')
+        .option('--json', 'output JSON')
+        .action(async (options) => {
+        const { LiveSkillMutator } = await import('../../agent/self-improvement/skill-mutator.js');
+        const m = new LiveSkillMutator();
+        const skills = m.listAuthored().map((name) => ({ name, pinned: m.isPinned(name) }));
+        const text = skills.length
+            ? skills.map((s) => `  ${s.pinned ? '📌' : '  '} ${s.name}`).join('\n')
+            : 'No authored skills installed';
+        print({ kind: 'authored_skills', skills }, options, text);
+    });
+    improve
+        .command('skills-pin <name>')
+        .description('Pin an authored skill (protect it from curation overwrite/remove/consolidation)')
+        .option('--json', 'output JSON')
+        .action(async (name, options) => {
+        const { LiveSkillMutator } = await import('../../agent/self-improvement/skill-mutator.js');
+        const ok = new LiveSkillMutator().pin(name);
+        print({ kind: 'skill_pin', name, ok }, options, ok ? `Pinned ${name}` : `Skill not found: ${name}`);
+    });
+    improve
+        .command('skills-unpin <name>')
+        .description('Unpin an authored skill')
+        .option('--json', 'output JSON')
+        .action(async (name, options) => {
+        const { LiveSkillMutator } = await import('../../agent/self-improvement/skill-mutator.js');
+        const ok = new LiveSkillMutator().unpin(name);
+        print({ kind: 'skill_unpin', name, ok }, options, ok ? `Unpinned ${name}` : `Skill not found: ${name}`);
+    });
+    improve
+        .command('skills-restore <name>')
+        .description('Restore a previously archived authored skill')
+        .option('--json', 'output JSON')
+        .action(async (name, options) => {
+        const { LiveSkillMutator } = await import('../../agent/self-improvement/skill-mutator.js');
+        const ok = new LiveSkillMutator().restore(name);
+        print({ kind: 'skill_restore', name, ok }, options, ok ? `Restored ${name}` : `No archived skill: ${name}`);
+    });
+    improve
+        .command('skills-consolidate')
+        .description('Merge overlapping authored skills into one umbrella (coverage-gated)')
+        .option('--json', 'output JSON')
+        .option('--apply', 'install the umbrella + archive merged siblings (else preview)')
+        .action(async (options) => {
+        const { LiveSkillMutator } = await import('../../agent/self-improvement/skill-mutator.js');
+        const { consolidateCluster, buildClusterFromInstalled, LlmUmbrellaProposer } = await import('../../agent/self-improvement/skill-consolidator.js');
+        const { SEED_SKILL_SCENARIOS } = await import('../../agent/self-improvement/skill-benchmark.js');
+        const mutator = new LiveSkillMutator();
+        const cluster = buildClusterFromInstalled(mutator, SEED_SKILL_SCENARIOS);
+        const out = await consolidateCluster(cluster, new LlmUmbrellaProposer(), mutator, new EvolutionaryArchive(), {
+            keepOnAccept: options.apply === true,
+        });
+        const text = out.accepted
+            ? out.absorbed.length
+                ? `Consolidated ${out.absorbed.join(', ')} into ${out.umbrellaName}` + (out.skippedPinned.length ? ` (kept pinned: ${out.skippedPinned.join(', ')})` : '')
+                : `Would consolidate into ${out.umbrellaName} — re-run with --apply` + (out.skippedPinned.length ? ` (would keep pinned: ${out.skippedPinned.join(', ')})` : '')
+            : `No consolidation: ${out.rejectionReason} — ${out.reasons.join('; ')}`;
+        print({ kind: 'skill_consolidation', ...out }, options, text);
+    });
     improve
         .command('loop')
         .description('Run improvement cycles until no further validated progress is made')

package/dist/commands/cli/native-engine-commands.js

@@ -9,6 +9,16 @@ import { buildHeartbeatStatusReport } from '../../daemon/status-reports.js';
 // Heartbeat commands
 // ============================================================================
 export { buildHeartbeatStatusReport };
+function parsePositiveIntegerCliOption(value, flagName) {
+    if (value === undefined)
+        return undefined;
+    const trimmed = value.trim();
+    const n = Number(trimmed);
+    if (!/^[1-9]\d*$/.test(trimmed) || !Number.isSafeInteger(n)) {
+        throw new Error(`${flagName} must be a positive integer`);
+    }
+    return n;
+}
 export function registerHeartbeatCommands(program) {
     const heartbeat = program
         .command('heartbeat')
@@ -745,7 +755,7 @@ export function registerFleetAutonomyCommands(program) {
         .action(async (opts) => {
         const { createDefaultAutonomousLoop, FleetAutonomousDaemon, watchFleetTasks } = await import('../../daemon/autonomous-daemon.js');
         const path = await import('path');
-        const loop = createDefaultAutonomousLoop({
+        const loop = await createDefaultAutonomousLoop({
             ...(opts.dir ? { dir: opts.dir } : {}),
             ...(opts.outputDir ? { outputDir: opts.outputDir } : {}),
         });
@@ -780,6 +790,86 @@ export function registerFleetAutonomyCommands(program) {
             console.log(`\nDone: ${summary.ticks} tick(s), ${JSON.stringify(summary.outcomes)} (${summary.stoppedReason}).`);
         }
     });
+    fleet
+        .command('bench')
+        .description('Benchmark live Tailnet Ollama peers and rank the network model tier')
+        .option('--peer <pattern>', 'only benchmark peers whose hostname or IP contains the pattern')
+        .option('--models <csv>', 'only benchmark models whose name contains one of the comma-separated patterns')
+        .option('--prompt-set <name>', 'prompt set: balanced, coding, or latency', 'coding')
+        .option('--runs <n>', 'repeat the prompt set N times per candidate', '1')
+        .option('--timeout <ms>', 'request timeout per prompt', '60000')
+        .option('--json', 'output JSON')
+        .option('--no-write-cache', 'do not persist the score cache used by the router')
+        .action(async (opts) => {
+        const { TailscaleManager } = await import('../../integrations/tailscale.js');
+        const { BENCHMARK_PROMPT_SETS, benchmarkCandidates, writeBenchmarkIndex, defaultBenchmarkIndexPath, } = await import('../../agent/model-benchmark.js');
+        const peers = await TailscaleManager.getInstance().discoverOllamaPeers();
+        const filteredPeers = opts.peer
+            ? peers.filter((peer) => peer.hostname.toLowerCase().includes(opts.peer.toLowerCase())
+                || peer.ip.includes(opts.peer.trim()))
+            : peers;
+        const modelFilters = opts.models
+            ? opts.models.split(',').map((part) => part.trim()).filter(Boolean)
+            : [];
+        const candidates = filteredPeers.flatMap((peer) => peer.models
+            .filter((model) => modelFilters.length === 0
+            ? true
+            : modelFilters.some((filter) => model.toLowerCase().includes(filter.toLowerCase())))
+            .map((model) => ({
+            model,
+            baseUrl: peer.baseURL,
+            label: peer.hostname,
+        })));
+        if (candidates.length === 0) {
+            const message = opts.peer
+                ? `No Tailnet Ollama peers matched "${opts.peer}".`
+                : 'No Tailnet Ollama peers were discovered.';
+            if (opts.json) {
+                console.log(JSON.stringify({ ok: false, error: message }, null, 2));
+                return;
+            }
+            console.log(message);
+            return;
+        }
+        const suite = BENCHMARK_PROMPT_SETS[opts.promptSet] ? opts.promptSet : 'coding';
+        const reports = await benchmarkCandidates(candidates, {
+            promptSet: suite,
+            runs: Math.max(1, parseInt(opts.runs, 10) || 1),
+            timeoutMs: Math.max(5_000, parseInt(opts.timeout, 10) || 60_000),
+        });
+        const ranked = [...reports].sort((a, b) => b.summary.score - a.summary.score);
+        let indexPath;
+        if (opts.writeCache !== false) {
+            indexPath = defaultBenchmarkIndexPath();
+            await writeBenchmarkIndex(ranked, suite, indexPath);
+        }
+        const best = ranked[0];
+        if (opts.json) {
+            console.log(JSON.stringify({
+                ok: true,
+                suite,
+                indexPath,
+                best,
+                reports: ranked,
+            }, null, 2));
+            return;
+        }
+        console.log(`\nTailnet Ollama benchmark (${suite})`);
+        if (indexPath)
+            console.log(`  Cache: ${indexPath}`);
+        console.log(`  Candidates: ${ranked.length}`);
+        if (best) {
+            console.log(`  Best: ${best.candidate.label ?? best.candidate.model} / ${best.candidate.model}`);
+            console.log(`    Score: ${best.summary.score.toFixed(1)}  compliance ${(best.summary.complianceRate * 100).toFixed(0)}%  ttft ${Math.round(best.summary.avgTtftMs)}ms  total ${Math.round(best.summary.avgTotalMs)}ms`);
+        }
+        console.log('');
+        ranked.forEach((report, index) => {
+            console.log(`${String(index + 1).padStart(2, ' ')}. ${report.candidate.label ?? report.candidate.model} / ${report.candidate.model}`);
+            console.log(`    ${report.candidate.baseUrl}`);
+            console.log(`    score=${report.summary.score.toFixed(1)} compliance=${(report.summary.complianceRate * 100).toFixed(0)}% ttft=${Math.round(report.summary.avgTtftMs)}ms total=${Math.round(report.summary.avgTotalMs)}ms`);
+        });
+        console.log('');
+    });
     fleet
         .command('status')
         .description('Show the fleet task queue + presence')
@@ -822,6 +912,15 @@ export function registerFleetAutonomyCommands(program) {
         .option('--dir <path>', 'colab dir')
         .option('--json', 'output JSON')
         .action(async (title, opts) => {
+        let goalMaxTurns;
+        try {
+            goalMaxTurns = parsePositiveIntegerCliOption(opts.goalMaxTurns, '--goal-max-turns');
+        }
+        catch (error) {
+            console.error(error instanceof Error ? error.message : String(error));
+            process.exit(1);
+            return;
+        }
         const { FleetColabStore } = await import('../../fleet/colab-store.js');
         const store = new FleetColabStore({ ...(opts.dir ? { dir: opts.dir } : {}) });
         const priority = ['critical', 'high', 'medium', 'low'].find((p) => p === opts.priority) ?? 'medium';
@@ -831,7 +930,7 @@ export function registerFleetAutonomyCommands(program) {
             ...(opts.description ? { description: opts.description } : {}),
             ...(opts.dependsOn ? { dependsOn: opts.dependsOn.split(',').map((s) => s.trim()).filter(Boolean) } : {}),
             ...(opts.goalMode ? { goalMode: true } : {}),
-            ...(opts.goalMaxTurns ? { goalMaxTurns: parseInt(opts.goalMaxTurns, 10) } : {}),
+            ...(goalMaxTurns !== undefined ? { goalMaxTurns } : {}),
         });
         if (opts.json) {
             console.log(JSON.stringify({ task }, null, 2));
@@ -1129,7 +1228,7 @@ export function registerCompanionCommands(program) {
         .option('--no-set-model', 'Do not set the project model to the ChatGPT companion default')
         .option('--language <lang>', 'Voice language', 'fr')
         .option('--stt-provider <provider>', 'Voice input provider (system, whisper-local, whisper-api)')
-        .option('--tts-provider <provider>', 'TTS provider (edge-tts, espeak, say, piper, audioreader, kokoro)')
+        .option('--tts-provider <provider>', 'TTS provider (edge-tts, espeak, say, piper, audioreader)')
         .option('--tts-voice <voice>', 'TTS voice name')
         .option('--model <model>', 'ChatGPT model to use when OAuth credentials are present')
         .action(async (opts) => {

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

@@ -4,6 +4,7 @@
  * Extracted from index.ts for modularity.
  */
 import { resolve } from 'path';
+import { buildOllamaUpdatePlan, fetchOllamaStatus, runOllamaUpdatePlan } from '../ollama.js';
 function resolveCommandDirectory(program) {
     const directory = program.opts().directory;
     return resolve(process.cwd(), directory || process.cwd());
@@ -93,6 +94,50 @@ export function registerUtilityCommands(program) {
         const { runOnboarding } = await import('../../wizard/onboarding.js');
         await runOnboarding();
     });
+    const ollamaCommand = program
+        .command('ollama')
+        .description('Inspect or update the local Ollama runtime');
+    ollamaCommand
+        .command('status')
+        .description('Show local Ollama version and models')
+        .option('--url <url>', 'Ollama base URL', process.env.OLLAMA_HOST ?? 'http://localhost:11434')
+        .option('--json', 'Output JSON')
+        .action(async (options) => {
+        const status = await fetchOllamaStatus(options.url);
+        if (options.json) {
+            console.log(JSON.stringify(status, null, 2));
+            return;
+        }
+        console.log('\nOllama status\n');
+        console.log(`  Base URL: ${status.baseUrl}`);
+        console.log(`  Reachable: ${status.reachable ? 'YES' : 'NO'}`);
+        console.log(`  Version: ${status.version ?? '(unknown)'}`);
+        console.log(`  Models: ${status.models.length > 0 ? status.models.join(', ') : '(none)'}`);
+        if (status.error) {
+            console.log(`  Error: ${status.error}`);
+        }
+        console.log('');
+    });
+    ollamaCommand
+        .command('update')
+        .description('Run the official Ollama Windows update script')
+        .option('--script-url <url>', 'Official installer/update script URL', 'https://ollama.com/install.ps1')
+        .option('--repo-root <dir>', 'Repository root', resolveCommandDirectory(program))
+        .action(async (options) => {
+        const plan = buildOllamaUpdatePlan({
+            repoRoot: options.repoRoot,
+            scriptUrl: options.scriptUrl,
+        });
+        if (!plan.supported) {
+            console.error(plan.message);
+            console.error(`Use the update script directly on Windows: ${plan.scriptPath}`);
+            process.exit(1);
+            return;
+        }
+        console.log(`Running Ollama updater: ${plan.scriptPath}`);
+        await runOllamaUpdatePlan(plan);
+        console.log('Ollama update completed.');
+    });
     // Webhook command
     const webhookCommand = program
         .command('webhook')

package/dist/commands/enhanced-command-handler.js

@@ -314,7 +314,7 @@ export class EnhancedCommandHandler {
         ['__ULTRAPLAN__', (args) => handleUltraplan(args)],
         ['__LIST_CHECKPOINTS__', (args) => handleListCheckpoints(args)],
         ['__RESTORE_CHECKPOINT__', (args) => handleRestoreCheckpoint(args)],
-        ['__INIT_GROK__', () => handleInitGrok()],
+        ['__INIT_GROK__', (args) => handleInitGrok(args)],
         ['__REINIT_GROK__', () => handleReinitGrok()],
         ['__FEATURES__', () => handleFeatures()],
         ['__LESSONS__', (args) => handleLessonsCommand(args.join(' '))],
@@ -340,7 +340,7 @@ export class EnhancedCommandHandler {
         // Heartbeat engine activation (fleet AUTONOMOUS-FLEET-PROTOCOL v0.1)
         ['__HEARTBEAT__', (args) => handleHeartbeat(args)],
         // Standing goal — judge + auto-continue loop (Hermes Agent parity)
-        ['__GOAL__', (args) => handleGoal(args)],
+        ['__GOAL__', (args) => handleGoal(args, { client: this.codebuddyClient })],
         ['__SUBGOAL__', (args) => handleSubgoal(args)],
         // Daily reset scheduler (audit OpenClaw heritage activation)
         ['__DAILY_RESET__', (args) => handleDailyReset(args)],

package/dist/commands/goal-cli.d.ts

@@ -15,14 +15,22 @@
 import { Command } from 'commander';
 import type { ChatEntry } from '../agent/codebuddy-agent.js';
 import type { CodeBuddyClient } from '../codebuddy/client.js';
+import { type GoalJudgeProviderInfo } from '../goals/goal-judge-client.js';
 import { GoalStatus } from '../goals/goal-state.js';
 /** The slice of CodeBuddyAgent the loop needs — injectable for tests. */
 export interface GoalLoopAgent {
     processUserMessage(input: string): Promise<ChatEntry[]>;
     getClient(): CodeBuddyClient;
 }
+export interface GoalCommandRuntimeAgent extends GoalLoopAgent {
+    systemPromptReady: Promise<unknown>;
+    setSystemPrompt?: (prompt: string) => void;
+    dispose?: () => void | Promise<void>;
+}
 export interface GoalLoopRunOptions {
     maxTurns?: number;
+    /** Optional standalone judge client. Defaults to the agent client. */
+    judgeClient?: CodeBuddyClient;
     /** Progress sink (status lines ⊙/↻/✓/⏸). Defaults to silent. */
     onMessage?: (text: string) => void;
 }
@@ -31,6 +39,19 @@ export interface GoalLoopRunResult {
     turnsUsed: number;
     lastReason?: string;
 }
+export interface GoalCommandRuntimeOptions {
+    maxTurns?: number;
+    judgeModel?: string;
+    provider: GoalJudgeProviderInfo;
+    workingDirectory?: string;
+    onMessage?: (text: string) => void;
+    createJudgeClient?: typeof createStandaloneJudgeClient;
+    runLoop?: typeof runGoalLoop;
+}
+export declare const LOCAL_GOAL_ACTOR_SYSTEM_PROMPT: string;
+export declare function buildLocalGoalActorSystemPrompt(workingDirectory?: string): string;
+export declare function shouldUseLocalGoalActorPrompt(provider: GoalJudgeProviderInfo): boolean;
+export declare function resolveLocalGoalActorSystemPrompt(provider: GoalJudgeProviderInfo, workingDirectory?: string): string | undefined;
 /**
  * Drive the goal loop headlessly on an in-process agent. Sets the goal,
  * runs the first turn with the goal text (mirroring the interactive
@@ -38,4 +59,13 @@ export interface GoalLoopRunResult {
  * stops continuing.
  */
 export declare function runGoalLoop(agent: GoalLoopAgent, goalText: string, options?: GoalLoopRunOptions): Promise<GoalLoopRunResult>;
+declare function createStandaloneJudgeClient(judgeModel: string | undefined, agentProvider: GoalJudgeProviderInfo, currentClient: CodeBuddyClient): Promise<CodeBuddyClient | undefined>;
+export declare function runGoalCommandWithAgent(agent: GoalCommandRuntimeAgent, goal: string, options: GoalCommandRuntimeOptions): Promise<GoalLoopRunResult>;
+export declare function resolveGoalCliJudgeModel(explicitJudgeModel: string | undefined): string | undefined;
+export declare function resolveGoalCliMaxToolRounds(commandValue: number | undefined, command?: Command): number;
+export declare function resolveGoalCliWorkingDirectory(command?: Command): string | undefined;
+export declare function applyGoalCliWorkingDirectory(command?: Command): string;
+export declare function parsePositiveIntegerOption(value: string, optionName: string): number;
+export declare function validateGoalCommandNumericOptions(argv: readonly string[]): void;
 export declare function createGoalCommand(): Command;
+export {};