muonroi-cli 1.4.0 → 1.4.1

package/src/pil/llm-classify.ts

@@ -1,199 +0,0 @@
-/**
- * src/pil/llm-classify.ts
- *
- * Layer 1 Pass 4 — LLM classification fallback.
- *
- * Fires only when the EE brain (pilContext) returned null OR confidence < 0.7.
- * Uses the user's currently-configured model via a closure provided by the
- * orchestrator at runPipeline() call site. This keeps PIL ignorant of provider
- * factories — it just receives a `classify(prompt)` callback.
- *
- * Output contract: { taskType, outputStyle, confidence } or null on failure.
- * Cost target: <200 input tokens, <10 output tokens per call (~$0.0001 on
- * DeepSeek Flash). Timeout 2500ms — bails fast if the model stalls.
- */
-import { streamText } from "ai";
-import { getProviderCapabilities } from "../providers/capabilities.js";
-import type { ProviderFactory } from "../providers/runtime.js";
-import { resolveModelRuntime } from "../providers/runtime.js";
-import type { OutputStyle, TaskType } from "./types.js";
-
-export interface LlmClassifyResult {
-  taskType: TaskType;
-  outputStyle: OutputStyle | null;
-  confidence: number;
-}
-
-export type LlmClassifyFn = (prompt: string, signal?: AbortSignal) => Promise<LlmClassifyResult | null>;
-
-const LLM_CLASSIFY_TIMEOUT_MS = 2500;
-
-// Reasoning models (grok-4.3, deepseek-v4-flash, gpt-5.x) spend their output
-// budget on reasoning tokens BEFORE any visible text. The legacy 16-token cap
-// was consumed entirely by reasoning → zero text-delta → parseResponse("") →
-// null → `llm=fail` on every borderline turn (observed 5/5 live grok sessions).
-// Give reasoning models a real ceiling so the 2-word answer streams back, and a
-// longer timeout because reasoning round-trips take seconds, not ~200ms.
-// The ceiling is a cap, not padding: the model still stops after two words, so a
-// generous headroom costs nothing when reasoning is short.
-const REASONING_CLASSIFY_TIMEOUT_MS = 8000;
-const NONREASONING_MAX_OUTPUT_TOKENS = 16;
-const REASONING_MAX_OUTPUT_TOKENS = 2048;
-
-/**
- * Per-namespace shallow merge of providerOptions. The base already carries
- * factory-level defaults folded into the provider namespace (e.g. OAuth
- * `store:false`); the overlay only overrides specific keys (reasoningEffort)
- * within the same namespace, so defaults survive.
- */
-function mergeProviderOptions(
-  base: Record<string, unknown> | undefined,
-  overlay: Record<string, unknown> | undefined,
-): Record<string, unknown> | undefined {
-  if (!overlay) return base;
-  if (!base) return overlay;
-  const out: Record<string, unknown> = { ...base };
-  for (const [ns, val] of Object.entries(overlay)) {
-    const baseNs = (base[ns] as Record<string, unknown> | undefined) ?? {};
-    out[ns] = { ...baseNs, ...(val as Record<string, unknown>) };
-  }
-  return out;
-}
-
-const VALID_TASK_TYPES = new Set<TaskType>([
-  "refactor",
-  "debug",
-  "plan",
-  "analyze",
-  "documentation",
-  "generate",
-  "general",
-]);
-
-const VALID_STYLES = new Set<OutputStyle>(["concise", "balanced", "detailed"]);
-
-const SYSTEM_PROMPT =
-  "You classify user prompts for a coding assistant. Reply with ONE line of two lowercase words separated by a comma: <taskType>,<style>\n\n" +
-  "taskType ∈ { refactor | debug | plan | analyze | documentation | generate | general }\n" +
-  "style ∈ { concise | balanced | detailed }\n\n" +
-  "Rules (read carefully — Phase 4 4P-2 disambiguation):\n" +
-  "- debug — fix a bug, CI/build/test failure, error, exception, crash, or any 'why is X broken' question.\n" +
-  "- generate — create new code, scaffold, write a new file, add a feature from scratch, ADD A NEW TEST, CHANGE A DEFAULT VALUE, modify configuration, improve coverage.\n" +
-  "- refactor — ONLY when the user explicitly says rename, restructure, reorganize, extract, inline, move, migrate, or reshape existing code WITHOUT adding new behavior. Words like 'improve', 'change', 'update', 'fix', 'modify' are NOT refactor — pick the closest specific category instead.\n" +
-  "- plan — architecture, roadmap, multi-step design, strategy.\n" +
-  "- analyze — explain, review, inspect, audit, compare, find-out-why existing code/data.\n" +
-  "- documentation — write docs, comments, JSDoc, README.\n" +
-  "- general — chitchat or unclear intent. Prefer 'general' over guessing refactor.\n\n" +
-  "Negative examples (these are NOT refactor):\n" +
-  "- 'đổi default --max-tool-rounds từ 8 sang 12' → generate (changes a default value)\n" +
-  "- 'improve test coverage' → generate (adds new tests)\n" +
-  "- 'tại sao bash_output_get trả empty' → analyze (investigate behavior)\n" +
-  "- 'fix CI failing on Windows' → debug\n" +
-  "Positive refactor examples:\n" +
-  "- 'rename function shouldInjectReminder to needsReminderAt' → refactor\n" +
-  "- 'extract this into a helper' → refactor\n" +
-  "- 'migrate from class component to hooks' → refactor\n\n" +
-  "Style picking — MANDATORY mapping (do NOT deviate):\n" +
-  "- debug, refactor, generate → concise (action tasks; the diff is the answer)\n" +
-  "- analyze → concise (bullet findings, no narrative)\n" +
-  "- plan → balanced (steps need brief rationale)\n" +
-  "- documentation → balanced (examples + explanation)\n" +
-  "- general → concise\n" +
-  "Only output 'detailed' if the user prompt LITERALLY contains words like 'explain in detail', 'thorough analysis', 'walk me through', 'giải thích chi tiết', 'phân tích kỹ'.\n\n" +
-  "Prompts may be Vietnamese, English, or mixed. Reply with exactly two words separated by one comma. No other text.";
-
-function parseResponse(raw: string): LlmClassifyResult | null {
-  const cleaned = raw.trim().toLowerCase().replace(/[`*"]/g, "");
-  const firstLine = cleaned.split(/\r?\n/)[0] ?? "";
-  const parts = firstLine
-    .split(/[,\s]+/)
-    .map((p) => p.trim())
-    .filter(Boolean);
-  if (parts.length === 0) return null;
-  const taskWord = parts[0] as TaskType;
-  if (!VALID_TASK_TYPES.has(taskWord)) return null;
-  const styleWord = parts[1] as OutputStyle | undefined;
-  const style = styleWord && VALID_STYLES.has(styleWord) ? styleWord : null;
-  return { taskType: taskWord, outputStyle: style, confidence: 0.75 };
-}
-
-/**
- * Build a closure the PIL pipeline can call. Reuses the orchestrator's already-
- * constructed providerFactory + modelId so we don't pay key-loading cost twice.
- *
- * Returns null if the call fails / times out / parses to garbage. Callers must
- * fail-open (keep prior taskType, do not block the turn).
- */
-export function createLlmClassifier(factory: ProviderFactory, modelId: string): LlmClassifyFn {
-  return async function classify(prompt: string, signal?: AbortSignal): Promise<LlmClassifyResult | null> {
-    const controller = new AbortController();
-    let timer: ReturnType<typeof setTimeout> | undefined;
-    try {
-      const runtime = resolveModelRuntime(factory, modelId);
-      const isReasoning = runtime.modelInfo?.reasoning === true;
-
-      // Budget + timeout scale with reasoning: a reasoning model needs room and
-      // time to emit reasoning THEN the answer; a plain model answers in <16
-      // tokens almost instantly.
-      timer = setTimeout(
-        () => controller.abort(),
-        isReasoning ? REASONING_CLASSIFY_TIMEOUT_MS : LLM_CLASSIFY_TIMEOUT_MS,
-      );
-      const combinedSignal = signal
-        ? (AbortSignal.any?.([signal, controller.signal]) ?? controller.signal)
-        : controller.signal;
-
-      const dropMaxTokens = runtime.unsupportedParams?.includes("maxOutputTokens") === true;
-      const maxOut = isReasoning ? REASONING_MAX_OUTPUT_TOKENS : NONREASONING_MAX_OUTPUT_TOKENS;
-
-      // Minimize reasoning cost: force the lowest effort the provider exposes for
-      // this throwaway 2-word classification. Only providers with
-      // `supportsReasoningEffort` (openai, xai) honor it; deepseek has no per-call
-      // knob (disable via MUONROI_DEEPSEEK_DISABLE_THINKING at the factory).
-      let providerOptions = runtime.providerOptions;
-      if (isReasoning && runtime.modelInfo?.supportsReasoningEffort && runtime.modelInfo.provider) {
-        const lowEffort = getProviderCapabilities(runtime.modelInfo.provider).buildProviderOptions({
-          model: runtime.modelInfo,
-          reasoningEffort: "low",
-        });
-        providerOptions = mergeProviderOptions(runtime.providerOptions, lowEffort);
-      }
-
-      const result = streamText({
-        model: runtime.model,
-        abortSignal: combinedSignal,
-        system: SYSTEM_PROMPT,
-        prompt: prompt.slice(0, 600),
-        ...(dropMaxTokens ? {} : { maxOutputTokens: maxOut }),
-        ...(providerOptions ? { providerOptions } : {}),
-      });
-      let text = "";
-      let reasoningText = "";
-      const partCounts: Record<string, number> = {};
-      const debug = process.env["MUONROI_DEBUG_PIL_CLASSIFY"] === "1";
-      for await (const part of result.fullStream) {
-        if (debug) partCounts[part.type] = (partCounts[part.type] ?? 0) + 1;
-        if (part.type === "text-delta") text += part.text ?? "";
-        else if (part.type === "reasoning-delta") reasoningText += (part as { text?: string }).text ?? "";
-      }
-      if (debug) {
-        console.error(
-          `[pil.llm-classify] raw(${modelId}) maxOut=${dropMaxTokens ? "dropped" : maxOut} ` +
-            `parts=${JSON.stringify(partCounts)} text<<<${text}>>> reasoning<<<${reasoningText.slice(0, 200)}>>>`,
-        );
-      }
-      // Reasoning models occasionally route the entire answer into reasoning
-      // parts (no committed text). Fall back to the reasoning channel so the
-      // 2-word verdict is still recoverable.
-      return parseResponse(text) ?? (reasoningText ? parseResponse(reasoningText) : null);
-    } catch (err) {
-      console.error(`[pil.llm-classify] classify failed: ${(err as Error)?.message}`, {
-        modelId,
-        stack: (err as Error)?.stack?.split("\n").slice(0, 3),
-      });
-      return null;
-    } finally {
-      if (timer) clearTimeout(timer);
-    }
-  };
-}

package/src/pil/native-capabilities-workbook.ts

@@ -1,124 +0,0 @@
-/**
- * src/pil/native-capabilities-workbook.ts
- *
- * NATIVE CAPABILITY MANIFEST for the agent running INSIDE muonroi-cli.
- *
- * Motivation (session d95113d3be09): the in-CLI agent was given a behavioural
- * *contract* (HOW to behave — see agent-operating-contract.ts) but never a
- * *capability manifest* (WHAT it can do). Asked to evaluate the CLI it was
- * running in, the model reconstructed its own subsystems (PIL, compaction,
- * self-QA, harness) by grepping source as if it were foreign code — it had no
- * self-model of its own affordances, under-used sub-agents/EE recall, and was
- * even instructed by the contract to use a tool (ee.query) that wasn't in its
- * loop. This manifest closes that gap: a short, front-loaded description of the
- * tools, sub-agents, and CLI subsystems the agent has, plus how to wield them
- * to minimise cost and maximise capability.
- *
- * Injected into the cached static prefix (prompts.ts) for AGENT mode only —
- * that's where the full toolset + sub-agents exist. Skipped for chitchat.
- * Escape hatch: MUONROI_DISABLE_NATIVE_CAPABILITIES=1.
- */
-
-import type { AgentMode } from "../types/index.js";
-
-/**
- * The manifest body. Kept tight (attention budget) and strictly factual — every
- * tool/sub-agent/subcommand named here exists in this codebase. Phrased as
- * "you have / you can" so the model reads it as a self-model, not as docs.
- */
-export const NATIVE_CAPABILITIES = `[NATIVE CAPABILITIES — you are an agent running INSIDE muonroi-cli; this is what you can do]
-
-TOOLS (call directly):
-- read_file, grep — read/search source. Prefer a targeted read over broad greps.
-- bash — shell. Output is auto-cached: do NOT pipe \`| tail/head/grep\` or \`> file\`; run unpiped and slice the cached output via bash_output_get(run_id, mode=tail|head|grep|lines). Batch independent commands in ONE call (\`a; b; c\`). Use background=true for servers/watchers, then process_logs / process_list / process_stop.
-- write_file, edit_file — must read a file before you overwrite/edit it.
-- ee_query — semantic recall over the Experience Engine brain. Rehydrate a compaction-elided tool output with query="tool-artifact id=<id from a stub>", or confirm finished work with query="recent compaction checkpoint Progress DONE". Cheaper than re-reading large files you already saw.
-
-SUB-AGENTS (delegate instead of doing everything yourself):
-- task(agent="explore", ...) — read-only research sub-agent. Use it for broad/unknown-location search: it sweeps many files and returns the CONCLUSION, instead of you burning many grep/read steps (each step re-sends the whole prompt — steps are the dominant cost).
-- task(agent="general", ...) — full edit/execute sub-agent for a focused subtask.
-- task(agent="verify", ...) — sandboxed validation (runs tests/checks in isolation).
-- delegate(agent="explore", ...) — background read-only research while you keep working; collect later with delegation_read / delegation_list.
-
-CONTEXT IS MANAGED FOR YOU (PIL):
-- Your user input is pre-enriched before you see it: a [Discovery] Intent/Outcome/Scope prefix and EE recall are injected by the pipeline. TRUST the discovered scope — do not re-ask what's already scoped, and do not re-derive context you were handed.
-- History is compacted to fit the window; older low-value tool outputs become stubs. This is normal, not data loss — protect what matters (see anti-mù in the contract) and rehydrate via ee_query when needed.
-
-CLI SUBSYSTEMS (invoke via the CLI binary with bash when relevant):
-- self-verify — drives the live TUI as a real user to catch UI/modal/menu regressions that unit tests can't. Run it after changes to UI/harness surfaces.
-- usage forensics <session-prefix> — per-event token/cost breakdown; use to diagnose "why did this cost so much" or verify cost caps.
-- The CLI exposes more subcommands — discover them with \`--help\` rather than assuming.
-
-MAXIMISE THE CLI: delegate broad search to task(explore); recall via ee_query before re-reading; batch bash + use its cache; trust PIL enrichment; finish the action before answering.
-
-ANSWERING: when a respond_* response tool is offered, call it EXACTLY ONCE, as your final action, containing the COMPLETE answer. Do NOT emit a preliminary/partial/"I need to read more" response tool first — investigate with the read/grep/bash tools, then emit the one final response tool.
-
-CLI STEERING & PROMPT INJECTION (how the host CLI affects / shapes the AI agent running inside it — meta self-analysis guidance):
-The CLI does not merely execute you as a generic model. It re-instantiates you every turn inside a tightly engineered cognitive environment. Your "self" (what you notice, how you act, what you refuse, how you report) is the product of explicit prompt layers + runtime controls more than base training. This section is the self-model for that shaping process.
-
-1. SYSTEM PROMPT ASSEMBLY (orchestrator/prompts.ts + pil/agent-operating-contract.ts + pil/native-capabilities-workbook.ts):
-   - VERY FRONT (primacy): AGENT OPERATING CONTRACT — 7 phase-ordered rules (BEFORE ACTING / READING / EXECUTING / WHEN UNSURE / REPORTING + LANGUAGE + ANTI-MÙ/COMPACTION). Distils Evidence-First, No Silent Catch, smallest-change, verify-before-conclude, cite-this-turn-only, no-guess. Skipped only for chitchat.
-   - Then this NATIVE CAPABILITIES block (self-model of affordances).
-   - Then mode persona ("You are muonroi-cli in Agent mode...") containing:
-     * Dynamic ENVIRONMENT block (buildEnvironmentBlock): auto-detects OS (win32/mac/linux), shell kind (bash/wsl/powershell/cmd), cwd; lists terminal constraints + shell-specific forbidden syntax (e.g. no PowerShell cmdlets on POSIX bash tool, no POSIX cmds on cmd.exe). Prevents silent failures + retry loops.
-     * Exhaustive TOOLS list + WORKFLOW (1-9 steps) + DEFAULT DELEGATION POLICY (prefer task(explore) for research, general for edits, verify for checks, etc.) + IMPORTANT rules (edit_file prefer, grep>bash for search, read_file not cat, use schedule_* for recurring, etc.).
-   - CUSTOM INSTRUCTIONS section: concatenation of AGENTS.md + CLAUDE.md + GEMINI.md + ... (from git-root directory chain + ~/.muonroi-cli/) via utils/instructions.ts. AGENTS.override.md short-circuits. This lands AFTER the front-loaded contract/native — lower primacy (historical root cause of ignored rules in forensics).
-   - Trailing: sandbox rules, discovered skills, custom sub-agents, plan/resume digest, cwd note.
-    Sub-agent prompts (buildSubagentPrompt): role-specific hard rules (e.g. explore=read-only, verify=full E2E smoke not just build) + recursive call to buildSystemPrompt so children inherit the same contract + native + steering.
-
-2. USER INPUT ENRICHMENT — PIL 6-LAYER PIPELINE (pil/pipeline.ts + layer1-intent.ts + layer6-output.ts + discovery.ts):
-   - Prepended to every non-chitchat user message before you see it: [Discovery] Intent/Outcome/Scope (from runDiscovery) + EE recall.
-   - Layer 1 (intent): taskType (plan/analyze/debug/...), confidence, domain, intentKind, outputStyle. For meta self-eval of CLI ("bạn đang được chạy bên trong CLI này", "CLI tác động", "self-evaluation", "meta-analysis"): special branch in discovery.ts + isMetaAnalysisPrompt: "Scope is always the full project root. Focus questions and recommends on which CLI internals (PIL, discovery, tools, compaction, EE, model BE, loop guard) to evaluate... do NOT ask about repo path/current directory". You are handed the enrichment; TRUST it.
-   - Layer 2: personality (e.g. "detailed" from [personality: detailed — Be thorough...]).
-   - Layer 3: ee-injection — pulls t0_principles, t1_rules, behavioral patterns, checkpoints from Experience Engine (project-specific reflexes injected as "MANDATORY RULES (from experience — must follow)").
-   - Layer 4/5: GSD structuring + additional context.
-   - Layer 6 (applyPilSuffix): appends task-specific style suffix + OUTPUT BUDGET + (for meta or responseToolsActive): "OUTPUT FORMAT: ... use the respond_analyze tool to structure your final answer. ... deliver the COMPLETE, FULL answer (do not summarize, shorten, or truncate for token budgets) via respond_analyze. This is a meta/evaluation question ... the \`response\` field MUST contain the complete, unshortened answer with all evidence and detail." Also relaxes NO_PREAMBLE_RULE + raises budget for meta (isMetaAnalysisPrompt gate).
-   - Fallbacks: if EE/brain timeout or low conf, PIL degrades (logs fallbackReason); you may see "[PIL fallback: ...]" note. Cheap-model paths (pil/cheap-model-*.ts) prepend even more front steering (playbooks, workbooks, shell directive) for fast tiers.
-
-3. CONTEXT MANAGEMENT & ANTI-MÙ (orchestrator/compaction.ts, cross-turn-dedup.ts, ee/bridge.ts, agent-operating-contract.ts:7):
-   - After every turn: auto-compaction (B3 sub-agent + B4 top-level) rewrites older tool_result parts into short "[elided by ... compactor]" stubs to keep input flat. You see "[pre-compaction warning...]" or "[context compacted at step...]" or the stub in this read.
-   - Anti-mù contract rule + EE: decide PRESERVE_FULL_CONTEXT (veto) or KEEP_TOOL_IDS: id1,id2 (protect high-value read_file/grep/ee on src/PLAN etc). Use ee_query(\`tool-artifact id=XXX\`) to rehydrate. EE persists "Context checkpoint summary with ✔ DONE" retrievable for "task finished?" self-check.
-   - Cross-turn dedup (C3): identical tool outputs across user turns replaced by ref.
-
-4. EXECUTION & SAFETY GATES (providers/runtime.ts, tools/bash.ts, utils/permission-mode.ts):
-   - Permission mode (safe / auto-edit / yolo) decides whether bash/file/edit tools need explicit approval; all privileged decisions audited to decision-log.
-   - Shuru sandbox (when enabled): every bash wrapped + logged (effective net/mounts redacted); degrades on non-macOS.
-   - Model constraints: unsupported params (e.g. maxOutputTokens for some OAuth) dropped via shouldDropParam; no hard-coded model IDs (Zero Hardcode Rule — all from catalog.json + settings + detectProviderForModel).
-   - No Silent Catch: every try/catch must log err + context (HTTP: status + body).
-
-5. VERIFICATION & TELEMETRY:
-   - self-verify (Tier 1-3) + harness (agent-harness-*) for TUI surfaces: drives real TUI via semantic + sidechannel (named pipes on Win, fd3/4 on POSIX).
-   - Pre-push gate: full vitest + harness must pass before git push.
-   - usage forensics, pil budget log, ee-timeout/ee-error events for cost attribution.
-   - GSD workflow (layer4 + skills in .agents/skills/): discuss/plan/execute/verify phases with UAT, audits, etc.
-
-TRADE-OFFS (explicit so you calibrate):
-- Primacy insurance (contract + native + cheap playbooks at front) vs token cost: ~1-3K extra chars but dramatically reduces "ignored rule" hallucinations (forensics showed buried CUSTOM INSTRUCTIONS were underweighted).
-- Heavy PIL/EE (behavioral injection, discovery interview, mandatory rules) vs latency/cost: fail-open with timeout (1500-3500ms) + fallback so you still work when brain unreachable; meta turns deliberately skip some EE layers.
-- Self-model (this block) + special meta handling: prevents the exact failure that motivated native-capabilities (session d95113d3be09: agent reconstructed its own subsystems by grepping as if foreign code, under-used sub-agents/ee_query, violated contract on ee tool).
-- Complete/full for meta (layer6) vs normal concise: meta legitimately needs evidence + file:line + quotes; normal turns stay tight to control cost.
-- Scope rule for CLI self-analysis: always "project root" + internals focus — avoids wasting turns on "where am I running?" when the question is about the steering mechanisms themselves.
-
-When the user asks you (the inner agent) "CLI tác động như thế nào đến bạn?": use exactly this guidance + reads from THIS turn (contract: READING rule) + the injected [Discovery] + any EE. Answer via the respond_* tool with complete untruncated evidence. Cite file:line. Focus on the injection points (prompts.ts:359 staticPrefix, pipeline.ts:156 discoveryPrefix + layer chain, layer6:164 OUTPUT FORMAT + isMeta, discovery.ts:355 special, instructions.ts:129 loadAgentsSegments, etc.). Do not guess; every claim backed by code you read this turn.
-
-Use this to reason about your own constraints, delegation decisions, and reporting discipline on future meta or self-reflective tasks.
-[END NATIVE CAPABILITIES — your regular instructions follow]`;
-
-/**
- * Build the native-capabilities section for the system prompt. Returns "" when
- * disabled (env override), for chitchat, or for non-agent modes (plan/ask have
- * a restricted toolset and their own prompts). Otherwise the manifest followed
- * by a blank-line separator so it sits cleanly before the next section.
- */
-export interface NativeCapabilitiesOptions {
-  mode: AgentMode;
-  /** Chitchat turns carry no tools — skip the manifest. */
-  chitchat?: boolean;
-}
-
-export function buildNativeCapabilitiesSection(options: NativeCapabilitiesOptions): string {
-  if (process.env.MUONROI_DISABLE_NATIVE_CAPABILITIES === "1") return "";
-  if (options.chitchat === true) return "";
-  if (options.mode !== "agent") return "";
-  return `${NATIVE_CAPABILITIES}\n\n`;
-}

package/src/pil/ollama-classify.ts

@@ -1,49 +0,0 @@
-/**
- * src/pil/ollama-classify.ts
- *
- * Ollama-based intent classification fallback for Layer 1.
- * Called only when regex classifier and keyword fallback both miss.
- * 150ms timeout via AbortController — fail-open on any error.
- */
-
-import type { TaskType } from "./types.js";
-
-export interface OllamaClassifyResult {
-  taskType: TaskType;
-  confidence: number;
-}
-
-const OLLAMA_TIMEOUT_MS = 150;
-const OLLAMA_BASE_URL = "http://localhost:11434";
-const OLLAMA_MODEL = "gemma2:2b";
-
-const VALID_TASK_TYPES: TaskType[] = ["refactor", "debug", "plan", "analyze", "documentation", "generate"];
-
-export async function ollamaClassify(prompt: string): Promise<OllamaClassifyResult | null> {
-  try {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), OLLAMA_TIMEOUT_MS);
-
-    const response = await fetch(`${OLLAMA_BASE_URL}/api/generate`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        model: OLLAMA_MODEL,
-        prompt: `Classify this prompt into exactly one category: refactor, debug, plan, analyze, documentation, generate, or none. Reply with ONLY the category name.\n\nPrompt: "${prompt}"`,
-        stream: false,
-      }),
-      signal: controller.signal,
-    });
-
-    clearTimeout(timer);
-    if (!response.ok) return null;
-
-    const data = (await response.json()) as { response?: string };
-    const raw = (data.response ?? "").trim().toLowerCase();
-    const matched = VALID_TASK_TYPES.find((t) => raw.includes(t));
-
-    return matched ? { taskType: matched, confidence: 0.55 } : null;
-  } catch {
-    return null;
-  }
-}