@phuetz/code-buddy 1.0.0 → 1.2.0

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

@@ -0,0 +1,155 @@
+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,
+ * ported from Hermes Agent).
+ *
+ * Forms:
+ *   /goal <text>     set a new goal (replaces any old one) and start turn 1
+ *   /goal | status   show current state
+ *   /goal pause      halt auto-continuation, keep the goal
+ *   /goal resume     restart the loop (resets the turn budget)
+ *   /goal clear      discard the goal (aliases: stop, done)
+ */
+export async function handleGoal(args, options = {}) {
+    const arg = args.join(' ').trim();
+    const lower = arg.toLowerCase();
+    const mgr = getGoalManager(options.sessionKey);
+    if (!arg || lower === 'status') {
+        return textResult(mgr.statusLine());
+    }
+    if (lower === 'pause') {
+        const state = mgr.pause('user-paused');
+        return textResult(state ? `⏸ Goal paused: ${state.goal}` : 'No goal set.');
+    }
+    if (lower === 'resume') {
+        const state = mgr.resume();
+        if (!state) {
+            return textResult('No goal to resume.');
+        }
+        return textResult(`▶ Goal resumed: ${state.goal}\n` +
+            'Send any message to kick the loop off (e.g. "continue").');
+    }
+    if (['clear', 'stop', 'done'].includes(lower)) {
+        const had = mgr.hasGoal();
+        mgr.clear();
+        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, {
+            ...(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: {
+            type: 'assistant',
+            content: `⊙ Goal set (${state.maxTurns}-turn budget): ${state.goal}\n` +
+                'After each turn, a judge model checks if the goal is done. Code Buddy ' +
+                '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.' +
+                planBlock,
+            timestamp: new Date(),
+        },
+        // Kick the loop off immediately — the dispatcher feeds the goal text as
+        // the first turn, then the after-turn hook drives the continuation loop.
+        passToAI: true,
+        prompt: state.goal,
+    };
+}
+/**
+ * /subgoal — extra acceptance criteria added mid-loop.
+ *
+ * Forms:
+ *   /subgoal                show current subgoals
+ *   /subgoal <text>         append a criterion
+ *   /subgoal remove <n>     drop subgoal n (1-based)
+ *   /subgoal clear          wipe all subgoals
+ *
+ * Subgoals get appended to both the judge prompt (verdict must consider
+ * them) and the continuation prompt (agent sees them) on the next turn
+ * boundary — no special kick needed.
+ */
+export async function handleSubgoal(args, options = {}) {
+    const arg = args.join(' ').trim();
+    const mgr = getGoalManager(options.sessionKey);
+    if (!mgr.hasGoal()) {
+        return textResult('No active goal. Set one with /goal <text>.');
+    }
+    if (!arg) {
+        return textResult(`${mgr.statusLine()}\n${mgr.renderSubgoals()}`);
+    }
+    const [verb, ...restTokens] = arg.split(/\s+/);
+    const rest = restTokens.join(' ').trim();
+    if (verb?.toLowerCase() === 'remove') {
+        if (!rest) {
+            return textResult('Usage: /subgoal remove <n>');
+        }
+        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);
+            return textResult(`✓ Removed subgoal ${idx}: ${removed}`);
+        }
+        catch (error) {
+            return textResult(`/subgoal remove: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    if (verb?.toLowerCase() === 'clear') {
+        try {
+            const prev = mgr.clearSubgoals();
+            return textResult(prev ? `✓ Cleared ${prev} subgoal${prev !== 1 ? 's' : ''}.` : 'No subgoals to clear.');
+        }
+        catch (error) {
+            return textResult(`/subgoal clear: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    // Otherwise — append the whole arg as a new subgoal.
+    try {
+        const text = mgr.addSubgoal(arg);
+        const idx = mgr.state?.subgoals.length ?? 0;
+        return textResult(`✓ Added subgoal ${idx}: ${text}`);
+    }
+    catch (error) {
+        return textResult(`/subgoal: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+function textResult(content) {
+    return {
+        handled: true,
+        entry: { type: 'assistant', content, timestamp: new Date() },
+    };
+}
+//# sourceMappingURL=goal-handler.js.map

package/dist/commands/handlers/index.d.ts

@@ -36,6 +36,7 @@ export { handleFastMode, isFastModeEnabled, getFastModeModel, getFastModeService
 export { handleBackup, } from './backup-handlers.js';
 export { handleBtw, setBtwClient, } from './btw-handler.js';
 export { handleHeartbeat } from './heartbeat-handler.js';
+export { handleGoal, handleSubgoal } from './goal-handler.js';
 export { handleDailyReset } from './daily-reset-handler.js';
 export { handleShare } from './team-session-handler.js';
 export { handleAgents } from './agents-handler.js';

package/dist/commands/handlers/index.js

@@ -74,6 +74,8 @@ export { handleBackup, } from './backup-handlers.js';
 export { handleBtw, setBtwClient, } from './btw-handler.js';
 // Heartbeat handler (fleet AUTONOMOUS-FLEET-PROTOCOL v0.1)
 export { handleHeartbeat } from './heartbeat-handler.js';
+// Goal handler (Hermes Agent parity — Ralph loop)
+export { handleGoal, handleSubgoal } from './goal-handler.js';
 // Daily reset handler (audit OpenClaw heritage activation)
 export { handleDailyReset } from './daily-reset-handler.js';
 // Team session handler — slash /share (audit OpenClaw heritage activation, TeamSessionManager wake)

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/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 {

package/dist/commands/headless-slash.js

@@ -55,6 +55,18 @@ export async function executeHeadlessSlashToken(token, args, allow, ctx = {}) {
     if (ctx.client)
         handler.setCodeBuddyClient(ctx.client);
     try {
+        if (ctx.goalSessionKey && (token === '__GOAL__' || token === '__SUBGOAL__')) {
+            const { handleGoal, handleSubgoal } = await import('./handlers/goal-handler.js');
+            const result = token === '__GOAL__'
+                ? await handleGoal(args, { sessionKey: ctx.goalSessionKey, client: ctx.client ?? null })
+                : await handleSubgoal(args, { sessionKey: ctx.goalSessionKey });
+            return {
+                handled: result.handled,
+                output: result.entry?.content,
+                prompt: result.prompt,
+                passToAI: result.passToAI,
+            };
+        }
         const result = await handler.handleCommand(token, args, [token, ...args].join(" "));
         return {
             handled: result.handled,

package/dist/commands/llm-provider-resolution.d.ts

@@ -6,9 +6,11 @@
  * provider + the `PROVIDERS` map (paid keys), so a machine running on
  * local Ollama (`CODEBUDDY_PROVIDER=ollama`, $0) hit the "no API key"
  * exit even though the rest of Code Buddy — including the autonomous
- * daemon — runs fine there. This resolver keeps the legacy path first
- * (backward compatible) and falls back to {@link detectProviderFromEnv}
- * (ollama / chatgpt-oauth / env-detected providers) when either:
+ * daemon — runs fine there. This resolver keeps the legacy path for
+ * ambient paid-key defaults, but honors explicit local / ChatGPT
+ * subscription model choices before a cloud key can hijack them. It
+ * falls back to {@link detectProviderFromEnv} (ollama / chatgpt-oauth /
+ * env-detected providers) when either:
  *   - `CODEBUDDY_PROVIDER` is explicitly set (operator intent wins), or
  *   - the legacy path found no key.
  */

package/dist/commands/llm-provider-resolution.js

@@ -6,58 +6,69 @@
  * provider + the `PROVIDERS` map (paid keys), so a machine running on
  * local Ollama (`CODEBUDDY_PROVIDER=ollama`, $0) hit the "no API key"
  * exit even though the rest of Code Buddy — including the autonomous
- * daemon — runs fine there. This resolver keeps the legacy path first
- * (backward compatible) and falls back to {@link detectProviderFromEnv}
- * (ollama / chatgpt-oauth / env-detected providers) when either:
+ * daemon — runs fine there. This resolver keeps the legacy path for
+ * ambient paid-key defaults, but honors explicit local / ChatGPT
+ * subscription model choices before a cloud key can hijack them. It
+ * falls back to {@link detectProviderFromEnv} (ollama / chatgpt-oauth /
+ * env-detected providers) when either:
  *   - `CODEBUDDY_PROVIDER` is explicitly set (operator intent wins), or
  *   - the legacy path found no key.
  */
 import { getSettingsManager } from '../utils/settings-manager.js';
 import { detectProviderFromEnv } from '../utils/provider-detector.js';
-import { PROVIDERS } from './provider.js';
+import { inferProvider } from '../config/resolve-model.js';
+import { hasCodexCredentials } from '../providers/codex-oauth.js';
+import { resolveProviderFromCatalog } from '../providers/provider-catalog.js';
+import { PROVIDERS, resolveProviderCommandKey } from './provider.js';
 export function resolveCommandProvider(options = {}) {
+    const settingsManager = getSettingsManager();
+    const settings = settingsManager.loadUserSettings();
+    const configuredModel = options.explicitModel || settingsManager.getCurrentModel();
     const detectFirst = Boolean(process.env.CODEBUDDY_PROVIDER);
     if (detectFirst) {
         const detected = fromEnvDetection(options.explicitModel);
         if (detected)
             return detected;
     }
-    const settingsManager = getSettingsManager();
-    const settings = settingsManager.loadUserSettings();
+    const explicitLocal = resolveExplicitOllamaModel(configuredModel);
+    if (explicitLocal)
+        return explicitLocal;
+    const explicitChatGpt = resolveExplicitChatGptModel(configuredModel);
+    if (explicitChatGpt)
+        return explicitChatGpt;
     const currentProviderKey = settings.provider || 'grok';
-    const providerInfo = PROVIDERS[currentProviderKey];
-    let apiKey = process.env[providerInfo?.envVar || ''] || '';
-    if (!apiKey && currentProviderKey === 'grok')
-        apiKey = process.env.XAI_API_KEY || '';
-    if (!apiKey && currentProviderKey === 'gemini')
-        apiKey = process.env.GOOGLE_API_KEY || '';
-    if (!apiKey) {
-        apiKey =
-            process.env.GROK_API_KEY ||
-                process.env.ANTHROPIC_API_KEY ||
-                process.env.OPENAI_API_KEY ||
-                process.env.GOOGLE_API_KEY ||
-                '';
+    const providerInfoKey = resolveProviderCommandKey(currentProviderKey) || currentProviderKey;
+    const providerInfo = PROVIDERS[providerInfoKey];
+    if (providerInfo) {
+        const configuredProvider = resolveProviderFromCatalog({
+            providerOverride: providerInfo.providerId,
+            hasChatGptOAuth: hasCodexCredentials(),
+            requireConfigured: providerInfo.authMode === 'api-key',
+        });
+        if (configuredProvider) {
+            return {
+                apiKey: configuredProvider.apiKey,
+                baseURL: configuredProvider.baseURL,
+                model: configuredModel || configuredProvider.defaultModel,
+                providerLabel: configuredProvider.provider,
+            };
+        }
     }
-    if (apiKey) {
-        const providerEnvBaseURL = {
-            grok: process.env.GROK_BASE_URL,
-            claude: process.env.ANTHROPIC_BASE_URL,
-            openai: process.env.OPENAI_BASE_URL,
-            gemini: process.env.GEMINI_BASE_URL,
-        };
+    const ambientProvider = resolveProviderFromCatalog({
+        hasChatGptOAuth: hasCodexCredentials(),
+        requireConfigured: true,
+    });
+    if (ambientProvider) {
         return {
-            apiKey,
-            baseURL: providerEnvBaseURL[currentProviderKey] || providerInfo?.baseURL,
-            model: options.explicitModel ||
-                settingsManager.getCurrentModel() ||
-                providerInfo?.defaultModel,
-            providerLabel: providerInfo?.name || currentProviderKey,
+            apiKey: ambientProvider.apiKey,
+            baseURL: ambientProvider.baseURL,
+            model: configuredModel || ambientProvider.defaultModel,
+            providerLabel: ambientProvider.provider,
         };
     }
     // Legacy path found nothing — fall back to env detection (local
     // Ollama, ChatGPT OAuth, …) so a $0 local machine can still run.
-    return fromEnvDetection(options.explicitModel);
+    return fromEnvDetection(configuredModel);
 }
 function fromEnvDetection(explicitModel) {
     const detected = detectProviderFromEnv();
@@ -70,4 +81,47 @@ function fromEnvDetection(explicitModel) {
         providerLabel: detected.provider,
     };
 }
+function resolveExplicitOllamaModel(explicitModel) {
+    const model = explicitModel?.trim();
+    if (!model || !isLocalOllamaModel(model))
+        return null;
+    let host = process.env.OLLAMA_HOST || 'http://localhost:11434';
+    if (!/^https?:\/\//i.test(host))
+        host = `http://${host}`;
+    if (!host.endsWith('/v1'))
+        host = host.replace(/\/+$/, '') + '/v1';
+    return {
+        apiKey: 'ollama',
+        baseURL: host,
+        model,
+        providerLabel: 'ollama',
+    };
+}
+function isLocalOllamaModel(model) {
+    const normalized = model.trim().toLowerCase();
+    return inferProvider(normalized) === 'ollama' || normalized.startsWith('devstral-small-2');
+}
+function resolveExplicitChatGptModel(explicitModel) {
+    const model = explicitModel?.trim();
+    if (!model || !isChatGptSubscriptionModel(model))
+        return null;
+    const detected = detectProviderFromEnv();
+    if (detected?.provider !== 'chatgpt')
+        return null;
+    return {
+        apiKey: detected.apiKey,
+        baseURL: detected.baseURL,
+        model,
+        providerLabel: detected.provider,
+    };
+}
+function isChatGptSubscriptionModel(model) {
+    const m = model.trim().toLowerCase();
+    return (m === 'gpt-5.2' ||
+        m === 'gpt-5.5' ||
+        m.startsWith('gpt-5.5-') ||
+        m.includes('-codex') ||
+        m === 'codex-1' ||
+        m.startsWith('codex-mini'));
+}
 //# sourceMappingURL=llm-provider-resolution.js.map

package/dist/commands/ollama.d.ts

@@ -0,0 +1,25 @@
+export interface OllamaStatus {
+    baseUrl: string;
+    reachable: boolean;
+    version: string | null;
+    models: string[];
+    error: string | null;
+}
+export interface OllamaUpdatePlan {
+    supported: boolean;
+    platform: NodeJS.Platform;
+    repoRoot: string;
+    scriptPath: string;
+    scriptUrl: string;
+    command?: string;
+    args?: string[];
+    message: string;
+}
+export declare function normalizeOllamaBaseUrl(rawUrl?: string): string;
+export declare function fetchOllamaStatus(baseUrl?: string): Promise<OllamaStatus>;
+export declare function buildOllamaUpdatePlan(options: {
+    platform?: NodeJS.Platform;
+    repoRoot: string;
+    scriptUrl?: string;
+}): OllamaUpdatePlan;
+export declare function runOllamaUpdatePlan(plan: OllamaUpdatePlan): Promise<void>;