@phuetz/code-buddy 1.1.0 → 1.3.0

package/dist/commands/goal-cli.js

@@ -12,10 +12,72 @@
  *
  * Exit codes: 0 = goal done, 1 = paused (budget/judge) or error.
  */
-import { Command } from 'commander';
+import { Command, InvalidArgumentError } from 'commander';
+import path from 'path';
+import { resolveGoalJudgeClient } from '../goals/goal-judge-client.js';
 import { maybeContinueGoalAfterTurn } from '../goals/goal-loop.js';
-import { getGoalManager } from '../goals/goal-manager.js';
+import { getGoalManager, resolveGoalsConfig } from '../goals/goal-manager.js';
 import { resolveCommandProvider } from './llm-provider-resolution.js';
+const TOOL_RESULT_SNIPPET_CHARS = 1600;
+export const LOCAL_GOAL_ACTOR_SYSTEM_PROMPT = 'You are Code Buddy running in headless goal mode on a local model. ' +
+    'Work only toward the user standing goal. Use available tools when they are necessary, ' +
+    'then report concrete progress or the final result. For simple answer-only goals, ' +
+    'output exactly the requested answer and no extra text. Do not greet the user, add markdown, ' +
+    'or explain unless the goal asks for it.';
+export function buildLocalGoalActorSystemPrompt(workingDirectory = process.cwd()) {
+    return `${LOCAL_GOAL_ACTOR_SYSTEM_PROMPT}
+
+Workspace:
+- Current project directory: ${workingDirectory}
+- Use paths relative to the current project directory whenever possible.
+- Do not invent container paths such as /workspace or root paths such as /src unless a tool result proves they exist.`;
+}
+export function shouldUseLocalGoalActorPrompt(provider) {
+    const label = provider.providerLabel?.toLowerCase() ?? '';
+    const baseURL = provider.baseURL?.toLowerCase() ?? '';
+    return provider.apiKey === 'ollama' || label.includes('ollama') || baseURL.includes(':11434');
+}
+export function resolveLocalGoalActorSystemPrompt(provider, workingDirectory = process.cwd()) {
+    return shouldUseLocalGoalActorPrompt(provider)
+        ? buildLocalGoalActorSystemPrompt(workingDirectory)
+        : undefined;
+}
+function truncateGoalTurnPart(text) {
+    if (text.length <= TOOL_RESULT_SNIPPET_CHARS)
+        return text;
+    return `${text.slice(0, TOOL_RESULT_SNIPPET_CHARS)}... [truncated]`;
+}
+function buildGoalTurnSummary(entries) {
+    const parts = [];
+    let hasToolResult = false;
+    for (const entry of entries) {
+        if (entry.type === 'assistant' && entry.content.trim()) {
+            parts.push(entry.content.trim());
+            continue;
+        }
+        if (entry.type !== 'tool_result')
+            continue;
+        hasToolResult = true;
+        const toolOutput = (entry.toolResult?.success ? entry.toolResult.output : entry.toolResult?.error) ??
+            entry.content;
+        const trimmedOutput = String(toolOutput ?? '').trim();
+        if (!trimmedOutput)
+            continue;
+        const toolName = entry.toolCall?.function?.name ?? 'tool';
+        const status = entry.toolResult ? (entry.toolResult.success ? 'success' : 'error') : 'result';
+        parts.push(`[tool:${toolName} ${status}]\n${truncateGoalTurnPart(trimmedOutput)}`);
+    }
+    const summary = parts.join('\n\n');
+    if (summary && !hasToolResult) {
+        return `[tool evidence: none]\n\n${summary}`;
+    }
+    return summary;
+}
+function buildGoalRunSummary(turnSummaries) {
+    return turnSummaries
+        .map((summary, index) => `[Goal turn ${index + 1}]\n${summary}`)
+        .join('\n\n');
+}
 /**
  * Drive the goal loop headlessly on an in-process agent. Sets the goal,
  * runs the first turn with the goal text (mirroring the interactive
@@ -24,25 +86,32 @@ import { resolveCommandProvider } from './llm-provider-resolution.js';
  */
 export async function runGoalLoop(agent, goalText, options = {}) {
     const manager = getGoalManager();
-    const state = manager.set(goalText, options.maxTurns ? { maxTurns: options.maxTurns } : {});
+    const state = manager.set(goalText, options.maxTurns !== undefined ? { maxTurns: options.maxTurns } : {});
     const emit = options.onMessage ?? (() => { });
+    const judgeClient = options.judgeClient ?? agent.getClient();
     emit(`⊙ Goal set (${state.maxTurns}-turn budget): ${state.goal}`);
     let prompt = state.goal;
+    const turnSummaries = [];
     // Hard backstop on top of the manager's own budget/auto-pause guards.
     const maxIterations = state.maxTurns + 1;
     for (let i = 0; i < maxIterations; i++) {
         const entries = await agent.processUserMessage(prompt);
-        const lastResponse = entries
-            .filter(entry => entry.type === 'assistant' && entry.content)
-            .map(entry => entry.content)
-            .join('\n');
+        const lastResponse = buildGoalTurnSummary(entries);
+        if (lastResponse.trim()) {
+            turnSummaries.push(lastResponse);
+        }
         const outcome = await maybeContinueGoalAfterTurn({
-            client: agent.getClient(),
-            lastResponse,
+            client: judgeClient,
+            lastResponse: lastResponse.trim() ? buildGoalRunSummary(turnSummaries) : lastResponse,
             interrupted: false,
         });
         if (outcome?.message)
             emit(outcome.message);
+        if (!outcome && !lastResponse.trim() && manager.isActive()) {
+            manager.pause('empty response (nothing to evaluate)');
+            emit('⏸ Goal paused — the agent produced no judgeable response.');
+            break;
+        }
         if (!outcome?.continuationPrompt)
             break;
         prompt = outcome.continuationPrompt;
@@ -54,37 +123,151 @@ export async function runGoalLoop(agent, goalText, options = {}) {
         ...(final?.lastReason ? { lastReason: final.lastReason } : {}),
     };
 }
+async function createStandaloneJudgeClient(judgeModel, agentProvider, currentClient) {
+    const resolved = await resolveGoalJudgeClient(currentClient, judgeModel, agentProvider);
+    return resolved === currentClient ? undefined : resolved;
+}
+export async function runGoalCommandWithAgent(agent, goal, options) {
+    try {
+        const createJudgeClient = options.createJudgeClient ?? createStandaloneJudgeClient;
+        const runLoop = options.runLoop ?? runGoalLoop;
+        const judgeClient = await createJudgeClient(options.judgeModel, options.provider, agent.getClient());
+        await agent.systemPromptReady;
+        if (shouldUseLocalGoalActorPrompt(options.provider)) {
+            agent.setSystemPrompt?.(buildLocalGoalActorSystemPrompt(options.workingDirectory));
+        }
+        return await runLoop(agent, goal, {
+            ...(options.maxTurns !== undefined ? { maxTurns: options.maxTurns } : {}),
+            ...(judgeClient ? { judgeClient } : {}),
+            ...(options.onMessage ? { onMessage: options.onMessage } : {}),
+        });
+    }
+    finally {
+        await Promise.resolve(agent.dispose?.());
+    }
+}
+export function resolveGoalCliJudgeModel(explicitJudgeModel) {
+    const explicit = explicitJudgeModel?.trim();
+    if (explicit)
+        return explicit;
+    const configured = resolveGoalsConfig().judgeModel.trim();
+    return configured || undefined;
+}
+export function resolveGoalCliMaxToolRounds(commandValue, command) {
+    const commandSource = command?.getOptionValueSource?.('maxToolRounds');
+    if (commandSource && commandSource !== 'default') {
+        return commandValue ?? 50;
+    }
+    const parentSource = command?.parent?.getOptionValueSource?.('maxToolRounds');
+    const parentValue = command?.optsWithGlobals?.()?.maxToolRounds;
+    if (parentSource && parentSource !== 'default' && parentValue !== undefined) {
+        return parsePositiveIntegerOption(String(parentValue), '--max-tool-rounds');
+    }
+    return commandValue ?? 50;
+}
+export function resolveGoalCliWorkingDirectory(command) {
+    const value = command?.optsWithGlobals?.()?.directory;
+    if (typeof value !== 'string')
+        return undefined;
+    const directory = value.trim();
+    if (!directory)
+        return undefined;
+    return path.resolve(process.cwd(), directory);
+}
+export function applyGoalCliWorkingDirectory(command) {
+    const directory = resolveGoalCliWorkingDirectory(command);
+    if (directory) {
+        process.chdir(directory);
+    }
+    return process.cwd();
+}
+async function loadGoalCliEnv(directory) {
+    const dotenv = await import('dotenv');
+    dotenv.config({ path: path.join(directory, '.env') });
+}
+async function prepareGoalCliWorkspace(command) {
+    const launchDirectory = process.cwd();
+    await loadGoalCliEnv(launchDirectory);
+    const cwd = applyGoalCliWorkingDirectory(command);
+    if (cwd !== launchDirectory) {
+        await loadGoalCliEnv(cwd);
+    }
+    const opts = command?.optsWithGlobals?.();
+    const { initializeWorkspaceIsolation } = await import('../workspace/workspace-isolation.js');
+    initializeWorkspaceIsolation({
+        allowOutside: opts?.allowOutside,
+        directory: cwd,
+        additionalPaths: opts?.addDir,
+    });
+    return cwd;
+}
+export function parsePositiveIntegerOption(value, optionName) {
+    const trimmed = value.trim();
+    const n = Number(trimmed);
+    if (!/^[1-9]\d*$/.test(trimmed) || !Number.isSafeInteger(n)) {
+        throw new InvalidArgumentError(`${optionName} must be a positive integer`);
+    }
+    return n;
+}
+export function validateGoalCommandNumericOptions(argv) {
+    for (let i = 2; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === undefined)
+            continue;
+        if (arg === '--')
+            break;
+        if (arg === '--max-turns' || arg === '--max-tool-rounds') {
+            const value = argv[i + 1];
+            if (value === undefined)
+                continue;
+            parsePositiveIntegerOption(value, arg);
+            i++;
+            continue;
+        }
+        const eqIndex = arg?.indexOf('=') ?? -1;
+        if (eqIndex <= 0)
+            continue;
+        const optionName = arg.slice(0, eqIndex);
+        if (optionName === '--max-turns' || optionName === '--max-tool-rounds') {
+            parsePositiveIntegerOption(arg.slice(eqIndex + 1), optionName);
+        }
+    }
+}
 export function createGoalCommand() {
     const cmd = new Command('goal')
         .description('Run the agent toward a standing goal until a judge model confirms it is done (Ralph loop)')
         .argument('<goal>', 'The goal to pursue')
-        .option('--max-turns <n>', 'Turn budget (default 20, or goals.maxTurns from settings)')
+        .option('--max-turns <n>', 'Turn budget (default 20, or goals.maxTurns from settings)', value => parsePositiveIntegerOption(value, '--max-turns'))
         .option('--judge-model <model>', 'Model for the goal judge (default: session model)')
         .option('-m, --model <model>', 'Override the agent model for this run')
-        .option('--max-tool-rounds <n>', 'Max tool rounds per turn', '50')
+        .option('--max-tool-rounds <n>', 'Max tool rounds per turn', value => parsePositiveIntegerOption(value, '--max-tool-rounds'), 50)
         .action(async (goal, options, command) => {
-        const modelOverride = options.model ?? command?.optsWithGlobals?.()?.model;
-        const resolved = resolveCommandProvider({ explicitModel: modelOverride });
-        if (!resolved) {
-            console.error('Error: No provider available — set an API key, run `buddy onboard`, or point CODEBUDDY_PROVIDER=ollama at a local Ollama.');
-            process.exit(1);
-        }
-        if (options.judgeModel) {
-            process.env.CODEBUDDY_GOAL_JUDGE_MODEL = options.judgeModel;
-        }
-        process.env.CODEBUDDY_DISABLE_MCP = process.env.CODEBUDDY_DISABLE_MCP ?? 'true';
-        process.env.CODEBUDDY_HEADLESS = 'true';
         try {
+            const cwd = await prepareGoalCliWorkspace(command);
+            const modelOverride = options.model ?? command?.optsWithGlobals?.()?.model;
+            const resolved = resolveCommandProvider({ explicitModel: modelOverride });
+            if (!resolved) {
+                console.error('Error: No provider available — set an API key, run `buddy onboard`, or point CODEBUDDY_PROVIDER=ollama at a local Ollama.');
+                process.exit(1);
+            }
+            if (options.judgeModel) {
+                process.env.CODEBUDDY_GOAL_JUDGE_MODEL = options.judgeModel;
+            }
+            const judgeModel = resolveGoalCliJudgeModel(options.judgeModel);
+            const maxToolRounds = resolveGoalCliMaxToolRounds(options.maxToolRounds, command);
+            process.env.CODEBUDDY_DISABLE_MCP = process.env.CODEBUDDY_DISABLE_MCP ?? 'true';
+            process.env.CODEBUDDY_HEADLESS = 'true';
             const { CodeBuddyAgent } = await import('../agent/codebuddy-agent.js');
             const { ConfirmationService } = await import('../utils/confirmation-service.js');
             ConfirmationService.getInstance().setSessionFlag('allOperations', true);
-            const agent = new CodeBuddyAgent(resolved.apiKey, resolved.baseURL, resolved.model, parseInt(options.maxToolRounds, 10));
-            await agent.systemPromptReady;
-            const result = await runGoalLoop(agent, goal, {
-                ...(options.maxTurns ? { maxTurns: parseInt(options.maxTurns, 10) } : {}),
+            const agent = new CodeBuddyAgent(resolved.apiKey, resolved.baseURL, resolved.model, maxToolRounds, true, undefined, cwd, undefined, resolveLocalGoalActorSystemPrompt(resolved, cwd));
+            const result = await runGoalCommandWithAgent(agent, goal, {
+                provider: resolved,
+                judgeModel,
+                workingDirectory: cwd,
+                ...(options.maxTurns !== undefined ? { maxTurns: options.maxTurns } : {}),
                 onMessage: text => console.log(`\n${text}`),
             });
-            agent.dispose?.();
             process.exit(result.status === 'done' ? 0 : 1);
         }
         catch (err) {

package/dist/commands/handlers/goal-handler.d.ts

@@ -1,4 +1,11 @@
+import type { CodeBuddyClient } from '../../codebuddy/client.js';
+import { type GoalPlan } from '../../goals/goal-decomposer.js';
 import { CommandHandlerResult } from './branch-handlers.js';
+export interface GoalHandlerOptions {
+    sessionKey?: string;
+    client?: CodeBuddyClient | null;
+    planner?: (goal: string, client: CodeBuddyClient) => Promise<GoalPlan | null>;
+}
 /**
  * /goal — standing goal with judge + auto-continue loop (the Ralph loop,
  * ported from Hermes Agent).
@@ -10,7 +17,7 @@ import { CommandHandlerResult } from './branch-handlers.js';
  *   /goal resume     restart the loop (resets the turn budget)
  *   /goal clear      discard the goal (aliases: stop, done)
  */
-export declare function handleGoal(args: string[]): Promise<CommandHandlerResult>;
+export declare function handleGoal(args: string[], options?: GoalHandlerOptions): Promise<CommandHandlerResult>;
 /**
  * /subgoal — extra acceptance criteria added mid-loop.
  *
@@ -24,4 +31,4 @@ export declare function handleGoal(args: string[]): Promise<CommandHandlerResult
  * them) and the continuation prompt (agent sees them) on the next turn
  * boundary — no special kick needed.
  */
-export declare function handleSubgoal(args: string[]): Promise<CommandHandlerResult>;
+export declare function handleSubgoal(args: string[], options?: GoalHandlerOptions): Promise<CommandHandlerResult>;

package/dist/commands/handlers/goal-handler.js

@@ -1,3 +1,4 @@
+import { decomposeGoal, formatGoalPlan, shouldAutoDecomposeGoal, } from '../../goals/goal-decomposer.js';
 import { getGoalManager } from '../../goals/goal-manager.js';
 /**
  * /goal — standing goal with judge + auto-continue loop (the Ralph loop,
@@ -10,10 +11,10 @@ import { getGoalManager } from '../../goals/goal-manager.js';
  *   /goal resume     restart the loop (resets the turn budget)
  *   /goal clear      discard the goal (aliases: stop, done)
  */
-export async function handleGoal(args) {
+export async function handleGoal(args, options = {}) {
     const arg = args.join(' ').trim();
     const lower = arg.toLowerCase();
-    const mgr = getGoalManager();
+    const mgr = getGoalManager(options.sessionKey);
     if (!arg || lower === 'status') {
         return textResult(mgr.statusLine());
     }
@@ -35,13 +36,37 @@ export async function handleGoal(args) {
         return textResult(had ? '✓ Goal cleared.' : 'No active goal.');
     }
     // Otherwise treat the arg as the goal text.
+    let plan = null;
+    let planAttempted = false;
+    let planError = '';
+    if (options.client && shouldAutoDecomposeGoal(arg)) {
+        planAttempted = true;
+        try {
+            plan = await (options.planner ?? decomposeGoal)(arg, options.client);
+        }
+        catch (error) {
+            planError = error instanceof Error ? error.message : String(error);
+        }
+    }
     let state;
     try {
-        state = mgr.set(arg);
+        state = mgr.set(arg, {
+            ...(plan ? { goalPlan: plan } : {}),
+            ...(planAttempted ? { goalPlanAttempted: true } : {}),
+        });
+        if (planAttempted && !plan && planError) {
+            mgr.markGoalPlanAttempted(planError);
+            state = mgr.state ?? state;
+        }
     }
     catch (error) {
         return textResult(`Invalid goal: ${error instanceof Error ? error.message : String(error)}`);
     }
+    const planBlock = state.goalPlan
+        ? `\n\nHermes-style task graph attached:\n${formatGoalPlan(state.goalPlan)}`
+        : planError
+            ? `\n\nGoal planning was skipped after an LLM planner error: ${planError}`
+            : '';
     return {
         handled: true,
         entry: {
@@ -51,7 +76,8 @@ export async function handleGoal(args) {
                 'keeps working until it is, you pause/clear it, or the budget is ' +
                 'exhausted. Use /goal status, /goal pause, /goal resume, /goal clear. ' +
                 'Tip: for unattended runs, enable auto-approval (/yolo or auto-edit) so ' +
-                'the loop is not blocked on confirmations.',
+                'the loop is not blocked on confirmations.' +
+                planBlock,
             timestamp: new Date(),
         },
         // Kick the loop off immediately — the dispatcher feeds the goal text as
@@ -73,9 +99,9 @@ export async function handleGoal(args) {
  * them) and the continuation prompt (agent sees them) on the next turn
  * boundary — no special kick needed.
  */
-export async function handleSubgoal(args) {
+export async function handleSubgoal(args, options = {}) {
     const arg = args.join(' ').trim();
-    const mgr = getGoalManager();
+    const mgr = getGoalManager(options.sessionKey);
     if (!mgr.hasGoal()) {
         return textResult('No active goal. Set one with /goal <text>.');
     }
@@ -88,9 +114,10 @@ export async function handleSubgoal(args) {
         if (!rest) {
             return textResult('Usage: /subgoal remove <n>');
         }
-        const idx = Number(rest.split(/\s+/)[0]);
-        if (!Number.isInteger(idx)) {
-            return textResult('/subgoal remove: <n> must be an integer (1-based index).');
+        const indexToken = rest.split(/\s+/)[0] ?? '';
+        const idx = Number(indexToken);
+        if (!/^[1-9]\d*$/.test(indexToken) || !Number.isSafeInteger(idx)) {
+            return textResult('/subgoal remove: <n> must be a positive integer (1-based index).');
         }
         try {
             const removed = mgr.removeSubgoal(idx);

package/dist/commands/handlers/infra-handlers.js

@@ -6,6 +6,7 @@
  * and the current TurboQuant routing statistics.
  */
 import { logger } from '../../utils/logger.js';
+import { fetchOllamaStatus } from '../ollama.js';
 async function checkEndpoint(name, url, timeoutMs = 4000) {
     const start = Date.now();
     try {
@@ -49,6 +50,35 @@ function formatRoutingStats(stats) {
     }
     return lines.join('\n');
 }
+function formatOllamaSummary(status) {
+    const lines = [
+        `  Reachable: ${status.reachable ? 'YES' : 'NO'}`,
+        `  Version: ${status.version ?? '(unknown)'}`,
+        `  Models: ${status.models.length > 0 ? status.models.join(', ') : '(none)'}`,
+    ];
+    if (status.error) {
+        lines.push(`  Error: ${status.error}`);
+    }
+    lines.push(`  Gemma 4 ready: ${isGemma4Ready(status.version, status.models) ? 'YES' : 'NO'}`);
+    return lines.join('\n');
+}
+function isGemma4Ready(version, models) {
+    if (!version)
+        return false;
+    const [majorRaw, minorRaw, patchRaw] = version.split('.');
+    const major = Number.parseInt(majorRaw ?? '', 10);
+    const minor = Number.parseInt(minorRaw ?? '', 10);
+    const patch = Number.parseInt(patchRaw ?? '', 10);
+    if (!Number.isFinite(major) || !Number.isFinite(minor) || !Number.isFinite(patch))
+        return false;
+    if (major > 0)
+        return true;
+    if (minor > 24)
+        return true;
+    if (minor === 24 && patch >= 1)
+        return true;
+    return models.some((model) => model.toLowerCase().includes('gemma4'));
+}
 // ---------------------------------------------------------------------------
 // Main handler
 // ---------------------------------------------------------------------------
@@ -102,6 +132,9 @@ async function handleInfraDashboard() {
         lines.push(formatStatus(s));
     }
     lines.push('');
+    lines.push('Ollama Summary:');
+    lines.push(formatOllamaSummary(await fetchOllamaStatus(ollamaUrl)));
+    lines.push('');
     // Routing stats from TurboQuant plugin
     try {
         const { getTurboQuantStats } = await import('../../plugins/bundled/turboquant-plugin.js');
@@ -159,6 +192,9 @@ async function handleInfraHealth() {
     for (const s of statuses) {
         lines.push(formatStatus(s));
     }
+    lines.push('');
+    lines.push('Ollama Summary:');
+    lines.push(formatOllamaSummary(await fetchOllamaStatus(ollamaUrl)));
     return { handled: true, response: lines.join('\n') };
 }
 //# sourceMappingURL=infra-handlers.js.map

package/dist/commands/handlers/memory-handlers.js

@@ -27,6 +27,9 @@ function formatTimeAgo(date, now = new Date()) {
     const yr = Math.floor(day / 365);
     return `${yr} year${yr === 1 ? "" : "s"} ago`;
 }
+function clip(text, max = 180) {
+    return text.length > max ? text.slice(0, max - 1) + "…" : text;
+}
 /**
  * Memory - Manage persistent memory using PersistentMemoryManager (Markdown) and EnhancedMemory (SQLite/Vector)
  */
@@ -103,10 +106,10 @@ export async function handleMemory(args) {
                         content = `Usage: /memory remember <key> <content> [project|user]`;
                         break;
                     }
-                    const value = args.slice(2).join(" ");
                     const scope = (args[args.length - 1] === "user" || args[args.length - 1] === "project")
                         ? args.pop()
                         : "project";
+                    const value = args.slice(2).join(" ");
                     // Store in both for redundancy and better retrieval
                     await persistentMemory.remember(key, value, { scope, category: "custom" });
                     await enhancedMemory.store({
@@ -121,6 +124,30 @@ export async function handleMemory(args) {
                     content = `Usage: /memory remember <key> <content> [project|user]`;
                 }
                 break;
+            case "replace":
+            case "update":
+                if (args.length >= 3) {
+                    const key = args[1];
+                    if (key === undefined) {
+                        content = `Usage: /memory replace <key> <content> [project|user]`;
+                        break;
+                    }
+                    const scope = (args[args.length - 1] === "user" || args[args.length - 1] === "project")
+                        ? args.pop()
+                        : "project";
+                    const value = args.slice(2).join(" ");
+                    const result = await persistentMemory.replace(key, value, { scope });
+                    if (result.status === 'missing') {
+                        content = result.message;
+                    }
+                    else {
+                        content = `✅ ${result.message}\nCapacity: ${result.usage.used}/${result.usage.limit} chars (${result.usage.percent}%).`;
+                    }
+                }
+                else {
+                    content = `Usage: /memory replace <key> <content> [project|user]`;
+                }
+                break;
             case "context":
                 const enhancedContext = await enhancedMemory.buildContext({
                     includeProject: true,
@@ -154,6 +181,74 @@ export async function handleMemory(args) {
                 }
                 break;
             }
+            case "candidates":
+            case "candidate":
+            case "pending": {
+                const { getMemoryCandidateQueue } = await import("../../memory/memory-candidate-queue.js");
+                const statusArg = args[1];
+                const status = statusArg === "pending" || statusArg === "accepted" || statusArg === "rejected"
+                    ? statusArg
+                    : undefined;
+                const rawLimit = parseInt(args[status ? 2 : 1] ?? "20", 10);
+                const limit = Math.min(50, Math.max(1, Number.isFinite(rawLimit) ? rawLimit : 20));
+                const candidates = getMemoryCandidateQueue(process.cwd()).list(status).slice(0, limit);
+                if (candidates.length === 0) {
+                    content = status ? `No ${status} memory candidates.` : "No memory candidates yet.";
+                }
+                else {
+                    const lines = [`🧠 Memory candidates (${candidates.length}${status ? ` ${status}` : ""})`, "═".repeat(50)];
+                    for (const candidate of candidates) {
+                        const created = formatTimeAgo(new Date(candidate.createdAt));
+                        const confidence = typeof candidate.confidence === "number"
+                            ? ` | confidence ${(candidate.confidence * 100).toFixed(0)}%`
+                            : "";
+                        lines.push(`[${candidate.status}] ${candidate.id} | ${candidate.scope}/${candidate.category}${confidence} | ${created}`);
+                        lines.push(`  ${candidate.key}: ${clip(candidate.value)}`);
+                        const citation = candidate.citations?.[0];
+                        if (citation) {
+                            const label = citation.sessionId
+                                ? `${citation.sessionId}${citation.messageId ? `#${citation.messageId}` : citation.messageIndex ? `#${citation.messageIndex}` : ""}`
+                                : citation.messageIndex ? `message ${citation.messageIndex}` : "evidence";
+                            lines.push(`  citation: ${label}${citation.role ? ` (${citation.role})` : ""} — ${clip(citation.snippet, 140)}`);
+                        }
+                        lines.push("");
+                    }
+                    lines.push("Approve: /memory accept <id> [reviewer]");
+                    lines.push("Reject:  /memory reject <id> [reason]");
+                    content = lines.join("\n").trimEnd();
+                }
+                break;
+            }
+            case "accept":
+            case "approve": {
+                const id = args[1];
+                if (!id) {
+                    content = `Usage: /memory accept <candidate-id> [reviewer]`;
+                    break;
+                }
+                const reviewedBy = args.slice(2).join(" ").trim() || "user";
+                const { getMemoryCandidateQueue } = await import("../../memory/memory-candidate-queue.js");
+                const { candidate, write } = await getMemoryCandidateQueue(process.cwd()).accept(id, { reviewedBy });
+                content = `✅ Accepted ${candidate.id} into ${candidate.scope} memory as "${candidate.key}".\n` +
+                    `Write status: ${write.status}. Capacity: ${write.usage.used}/${write.usage.limit} chars (${write.usage.percent}%).`;
+                break;
+            }
+            case "reject":
+            case "discard": {
+                const id = args[1];
+                if (!id) {
+                    content = `Usage: /memory reject <candidate-id> [reason]`;
+                    break;
+                }
+                const reason = args.slice(2).join(" ").trim();
+                const { getMemoryCandidateQueue } = await import("../../memory/memory-candidate-queue.js");
+                const candidate = getMemoryCandidateQueue(process.cwd()).reject(id, {
+                    reviewedBy: "user",
+                    ...(reason ? { reason } : {}),
+                });
+                content = `🗑️ Rejected memory candidate ${candidate.id}.`;
+                break;
+            }
             case "status":
             case "list":
             default:

package/dist/commands/handlers/missing-handlers.d.ts

@@ -22,7 +22,7 @@ export declare function handleDiffCheckpoints(args: string[]): Promise<CommandHa
 export declare function handleFeatures(): CommandHandlerResult;
 export declare function handleListCheckpoints(_args: string[]): Promise<CommandHandlerResult>;
 export declare function handleRestoreCheckpoint(args: string[]): Promise<CommandHandlerResult>;
-export declare function handleInitGrok(): Promise<CommandHandlerResult>;
+export declare function handleInitGrok(args?: string[]): Promise<CommandHandlerResult>;
 export declare function handleReinitGrok(): Promise<CommandHandlerResult>;
 export declare function handleStatus(): Promise<CommandHandlerResult>;
 export declare function handleNew(args: string[]): Promise<CommandHandlerResult>;

package/dist/commands/handlers/missing-handlers.js

@@ -660,17 +660,40 @@ Use /checkpoints to see available checkpoints.`,
 // ============================================================================
 // /init - Initialize Code Buddy Project
 // ============================================================================
-export async function handleInitGrok() {
+export async function handleInitGrok(args = []) {
     try {
-        const { initCodeBuddyProject, formatInitResult } = await import('../../utils/init-project.js');
+        const fast = args.some((a) => a === '--fast' || a === '-f');
+        const { initCodeBuddyProject, formatInitResult, buildInitPrompt } = await import('../../utils/init-project.js');
+        // Deterministic scaffolding first (.codebuddy plumbing + template files,
+        // skip-if-exists). This always runs, so the config + a baseline AGENTS.md exist.
         const initResult = await initCodeBuddyProject();
+        if (fast) {
+            // --fast: deterministic template only (the legacy behavior).
+            return {
+                handled: true,
+                entry: { type: 'assistant', content: formatInitResult(initResult), timestamp: new Date() },
+            };
+        }
+        // Default: hand off to the agent to read the code and write a tailored
+        // AGENTS.md, grounded on the RepoProfiler's verified facts.
+        let contextPack = '';
+        try {
+            const { getRepoProfiler } = await import('../../agent/repo-profiler.js');
+            const profile = await getRepoProfiler().getProfile();
+            contextPack = profile.contextPack ?? '';
+        }
+        catch {
+            /* profiler optional — the prompt still works without the facts block */
+        }
         return {
             handled: true,
             entry: {
                 type: 'assistant',
-                content: formatInitResult(initResult),
+                content: `${formatInitResult(initResult)}\n\nNow analyzing the repository to write a tailored \`AGENTS.md\`… (run \`/init --fast\` for the deterministic template only)`,
                 timestamp: new Date(),
             },
+            passToAI: true,
+            prompt: buildInitPrompt(contextPack),
         };
     }
     catch (error) {

package/dist/commands/headless-slash.d.ts

@@ -33,6 +33,8 @@ export interface HeadlessSlashContext {
     conversationHistory?: ChatEntry[];
     /** LLM client, for tokens that call the model directly (ai-test, btw). */
     client?: CodeBuddyClient;
+    /** Optional goal-state key for non-TUI surfaces with their own session ids. */
+    goalSessionKey?: string;
 }
 /** Result of running a special token outside the TUI. */
 export interface HeadlessSlashResult {