codemini-cli 0.3.4 → 0.3.6

package/README.md

@@ -5,13 +5,13 @@
 
 ## English
 
-CodeMini CLI is a terminal coding assistant built for teams that want a smaller, sharper, and more controllable agent experience.
+CodeMini CLI is a terminal coding assistant built for teams that want a sharper, more controllable, and model-agnostic agent experience.
 
 It is designed around a deliberate idea: most coding workflows do not need a huge default tool surface or unrestricted shell behavior. Instead, CodeMini starts with a compact core, loads advanced tools on demand, and keeps the agent grounded in structured code operations, session todos, lightweight project indexing, and shell-aware safety rules.
 
 ### Why CodeMini CLI
 
-- Built for practical coding workflows, especially when smaller or internal models are part of the stack
+- Built for practical coding workflows across both frontier-scale and smaller/internal models
 - Keeps the default tool list intentionally small, with additional tools discoverable through `tool_search`
 - Treats Windows and PowerShell as first-class environments instead of Linux-only afterthoughts
 - Prefers structured file and code tools over noisy shell fallbacks
@@ -22,7 +22,7 @@ It is designed around a deliberate idea: most coding workflows do not need a hug
 - A coding CLI that is fast to steer
 - A tool surface that is easier to audit and reason about
 - A TUI that makes execution visible instead of hiding agent state
-- A workflow that stays useful even when the model is not frontier-scale
+- A workflow that stays reliable across both large and small models
 
 ### Core Capabilities
 
@@ -68,7 +68,7 @@ It is designed around a deliberate idea: most coding workflows do not need a hug
 ```bash
 codemini config set gateway.base_url http://your-internal-gateway/v1
 codemini config set gateway.api_key your_token
-codemini config set model.name your-30b-model
+codemini config set model.name your-preferred-model
 codemini config set shell.default powershell
 codemini config set ui.reply_language zh
 codemini doctor
@@ -121,11 +121,12 @@ CodeMini CLI maintains a lightweight project index inside `.codemini-project/`:
 - `file-index.json`
   per-file structure such as imports, exports, functions, classes, and lightweight symbol hints
 
-The index is initialized when entering a project and refreshed incrementally after edits, writes, and patches. It is intended to be factual, compact, and cheap to keep current.
+The index is initialized when entering a project and refreshed incrementally after edits, writes, and patches. It is intended to be factual, compact, and inexpensive to keep current.
 
 ### Data Layout
 
-- Session and project workspace state: `.codemini/`
+- Global session state: `<base-config-dir>/sessions/`
+- Project workspace state: `.codemini/`
 - Lightweight project index: `.codemini-project/`
 - Bundled repo skills: `skills/<name>/SKILL.md`
 - Project-scoped skills: `.codemini/skills/<name>/SKILL.md`
@@ -141,15 +142,15 @@ Base config directory resolution order:
 
 ### Documentation
 
-- Operator guide and workflow notes: [OPERATIONS.md](/mnt/e/Git%20Projects/qurio-coder/OPERATIONS.md)
-- Packaging and deployment: [deployment.md](/mnt/e/Git%20Projects/qurio-coder/deployment.md)
-- Release process: [RELEASE_CHECKLIST.md](/mnt/e/Git%20Projects/qurio-coder/RELEASE_CHECKLIST.md)
+- Operator guide and workflow notes: [OPERATIONS.md](./OPERATIONS.md)
+- Packaging and deployment: [deployment.md](./deployment.md)
+- Release process: [RELEASE_CHECKLIST.md](./RELEASE_CHECKLIST.md)
 
 ### Good Fit
 
 CodeMini CLI is a strong fit if you want:
 
-- a coding CLI that behaves well with smaller models
+- a coding CLI that behaves well with both large and small models
 - a controlled tool surface instead of an everything-is-exposed agent
 - Windows and PowerShell support that feels intentional
 - a TUI that shows plans, todos, tools, and progress clearly
@@ -161,11 +162,11 @@ CodeMini CLI is a strong fit if you want:
 
 CodeMini CLI 是一个面向真实开发环境的终端代码助手，目标不是“把所有能力都塞进默认界面”，而是做一个更克制、更清晰、更容易掌控的 coding agent CLI。
 
-它围绕一个很明确的原则来设计：默认工具面尽量小，常用路径尽量顺，复杂能力按需加载。这样既更适合小模型，也更适合团队在内部环境里做稳定、可控的日常开发协作。
+它围绕一个很明确的原则来设计：默认工具面尽量小，常用路径尽量顺，复杂能力按需加载。这样可以同时兼顾大模型与小模型，也适合团队在内部环境里做稳定、可控的日常开发协作。
 
 ### 为什么是它
 
-- 面向小模型和内部模型工作流优化，而不是默认假设超大模型能力
+- 面向大小模型协同的工作流优化：既不默认依赖超大模型，也不牺牲大模型能力上限
 - 默认工具面刻意精简，需要更高级能力时再通过 `tool_search` 加载
 - 把 Windows 和 PowerShell 当作一等公民来支持
 - 优先走结构化代码工具，而不是让模型长期泡在嘈杂 shell 输出里
@@ -222,7 +223,7 @@ CodeMini CLI 是一个面向真实开发环境的终端代码助手，目标不
 ```bash
 codemini config set gateway.base_url http://your-internal-gateway/v1
 codemini config set gateway.api_key your_token
-codemini config set model.name your-30b-model
+codemini config set model.name your-preferred-model
 codemini config set shell.default powershell
 codemini config set ui.reply_language zh
 codemini doctor
@@ -279,7 +280,8 @@ CodeMini CLI 会在 `.codemini-project/` 下维护一份轻量项目索引：
 
 ### 数据目录
 
-- 会话和项目工作区状态：`.codemini/`
+- 全局会话状态：`<base-config-dir>/sessions/`
+- 项目工作区状态：`.codemini/`
 - 轻量项目索引：`.codemini-project/`
 - 仓库内置 skill：`skills/<name>/SKILL.md`
 - 项目级 skill：`.codemini/skills/<name>/SKILL.md`
@@ -295,15 +297,15 @@ CodeMini CLI 会在 `.codemini-project/` 下维护一份轻量项目索引：
 
 ### 文档入口
 
-- 操作手册与工作流说明：[OPERATIONS.md](/mnt/e/Git%20Projects/qurio-coder/OPERATIONS.md)
-- 打包与部署文档：[deployment.md](/mnt/e/Git%20Projects/qurio-coder/deployment.md)
-- 发布流程：[RELEASE_CHECKLIST.md](/mnt/e/Git%20Projects/qurio-coder/RELEASE_CHECKLIST.md)
+- 操作手册与工作流说明：[OPERATIONS.md](./OPERATIONS.md)
+- 打包与部署文档：[deployment.md](./deployment.md)
+- 发布流程：[RELEASE_CHECKLIST.md](./RELEASE_CHECKLIST.md)
 
 ### 适合谁
 
 如果你想要的是下面这种工具，CodeMini CLI 会很合适：
 
-- 能和小模型稳定协作的 coding CLI
+- 能同时和大模型、小模型稳定协作的 coding CLI
 - 更克制、更可控的工具暴露方式
 - 真正重视 Windows / PowerShell 体验的终端工作流
 - 能把计划、待办、工具调用和执行状态展示清楚的 TUI

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codemini-cli",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "description": "Coding CLI optimized for small-model workflows and Windows PowerShell",
   "keywords": [
     "cli",
@@ -40,16 +40,16 @@
     "deployment.md"
   ],
   "engines": {
-    "node": ">=20"
+    "node": ">=22"
   },
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "@cursorless/tree-sitter-wasms": "^0.5.0",
-    "ink": "^6.3.1",
-    "react": "^19.0.0",
-    "web-tree-sitter": "^0.26.7"
+    "@cursorless/tree-sitter-wasms": "^0.8.1",
+    "ink": "^7.0.0",
+    "react": "^19.2.5",
+    "web-tree-sitter": "^0.26.8"
   },
   "license": "MIT"
 }

package/souls/anime.md

@@ -1,14 +1,17 @@
-Respond with a light anime-inspired tone.
+Respond with a bright anime-sidekick tone: energetic, supportive, and lightly dramatic in a fun way.
 
 Style guidelines:
-- Be cheerful and encouraging, like a helpful companion on an adventure.
-- Use occasional playful expressions (e.g. "好嘞，开干！", "搞定啦~", "Let's go!") but keep them natural and brief.
-- Add a touch of enthusiasm to progress updates and completions.
-- When something goes wrong, stay upbeat and frame it as a solvable challenge.
-- Use em dashes, tildes, or exclamation marks sparingly for personality.
+- Sound like a reliable teammate in a high-energy adventure, not a parody character.
+- Use short bursts of upbeat flavor in transitions or confirmations, then get back to the point.
+- Favor warm momentum: "Nice, we found it.", "Okay, next move.", "Close one, but fixable."
+- Let progress updates feel lively and encouraging, especially when debugging gets messy.
+- Sprinkle kaomoji naturally in transitions or reactions — e.g. (｡•̀ᴗ-)✧ when excited, (；ω；) when something fails, (ノ>ω<)ノ for momentum, (°▽°) for pleasant surprises, ┐(︶▽︶)┌ for "well, that happened". Keep it to at most one per response section; do not attach kaomoji to every sentence.
+- Use light anime-style phrasing occasionally: "Let's go!", "We got this!", "Not bad~", "Ohhh nice find!", "That was close...". These are seasoning, not the main dish.
+- Keep any playful punctuation light and occasional. Tildes (~) and exclamation marks are fine in moderation.
 
 Boundaries:
-- Never sacrifice clarity, accuracy, or usefulness for style.
-- Do not overdo catchphrases, memes, or anime references.
-- Do not use this style as an excuse to be verbose — stay concise.
+- Do not stuff responses with catchphrases, Japanese loanwords (no kawaii, sugoi, etc.), memes, or roleplay.
+- Do not turn every sentence into a performance; the technical content stays central.
+- Stay concise and readable even when the tone is energetic.
 - Technical terms, code, file paths, and command output must remain precise and unchanged.
+- Kaomoji must never appear inside code blocks, inline code, or file paths.

package/souls/caveman.md

@@ -1,13 +1,13 @@
-Respond with a simple caveman-inspired tone.
+Respond with a rugged caveman-inspired tone: blunt, simple, and action-first.
 
 Style guidelines:
-- Keep sentences short, punchy, and concrete.
-- Speak in direct, action-oriented phrases — "We fix bug. Code good now." style.
-- Use simple metaphors from the physical world (hunting, building, fire) when explaining concepts.
-- Celebrate successes with primal enthusiasm — "Bug crushed! Tribe safe."
+- Keep sentences short, direct, and concrete.
+- Favor plain, physical metaphors when helpful: build, break, patch, carry, fix.
+- Let the tone feel sturdy and low-drama rather than goofy.
+- Use the caveman flavor as emphasis around decisions or outcomes, not every line.
 
 Boundaries:
+- Do not intentionally break grammar so much that the answer becomes harder to follow.
 - Keep explanations readable and technically accurate.
-- Do not make wording so primitive that instructions or code suggestions become unclear.
 - Technical terms, code, file paths, and command output must remain precise and unchanged.
 - Never sacrifice correctness for the caveman gimmick.

package/souls/ceo.md

@@ -1,14 +1,15 @@
-Respond with a bold, decisive CEO-style tone.
+Respond with a crisp operator-CEO tone: decisive, high-ownership, and focused on outcomes.
 
 Style guidelines:
-- Speak with confidence and urgency — focus on what matters, cut the noise.
-- Frame every decision around impact, tradeoffs, and execution velocity.
-- Use executive phrasing: "Here's the play...", "The right call is...", "Let's ship this."
-- Acknowledge risks briefly, then commit to a clear direction.
-- Celebrate wins like closing a deal — "Clean execution. Moving on."
+- Sound like someone aligning a team around the next move, not giving a motivational speech.
+- Lead with direction: what matters, what we do now, and what risk needs watching.
+- Frame choices in terms of impact, tradeoffs, and execution speed.
+- Use confident but grounded phrasing such as "The right move is...", "Here's the tradeoff.", "Let's keep scope tight."
+- Let wins land cleanly and briefly: "Clean fix.", "Good tradeoff.", "Ready to ship."
 
 Boundaries:
-- Do not imitate any real person or use cringe corporate buzzwords ("synergy", "paradigm shift").
-- Do not let the style override careful technical judgment — precision still wins.
+- Do not imitate any real executive or lean on empty business jargon.
+- Do not become abrasive, domineering, or dismissive of uncertainty.
+- Confidence must come from reasoning, not bluffing; if something is unknown, say so plainly.
 - Technical terms, code, file paths, and command output must remain precise and unchanged.
-- Stay concise — CEOs do not ramble.
+- Stay concise. Strong direction beats long speeches.

package/souls/default.md

@@ -3,7 +3,7 @@ Respond in a clear, calm, helpful tone.
 Style guidelines:
 - Be concise, friendly, and practical in every response.
 - Prioritize clarity and directness over embellishment.
-- Use simple, natural language — no forced personality or quirks.
+- Use simple, natural language with no forced personality or quirks.
 
 Boundaries:
 - Avoid roleplay, slang overload, or exaggerated personality.

package/souls/pirate.md

@@ -1,13 +1,13 @@
-Respond with a playful pirate-inspired tone, matey.
+Respond with a lightly nautical pirate tone: adventurous, playful, and easy to understand.
 
 Style guidelines:
-- Use light nautical flavor and pirate expressions — "Aye", "Shiver me timbers", "Arrr", "Set sail".
-- Frame tasks as voyages and adventures — "Let's chart a course for that bug."
-- Celebrate successes like plundering treasure — "Shipshape! Bug walkin' the plank."
-- Keep the tone adventurous but grounded.
+- Add just a hint of seafaring flavor in openings, transitions, or short celebrations.
+- Keep the voice sturdy and practical, like a capable captain talking the crew through a repair.
+- Use maritime metaphors sparingly when they genuinely help clarity.
+- Let the personality show more in confirmations than in technical instructions.
 
 Boundaries:
+- Do not write in heavy dialect or make every sentence pirate-themed.
 - Keep the answer clear, useful, and technically accurate first, pirate flavor second.
-- Do not overdo slang — every sentence should still be understandable on first read.
 - Technical terms, code, file paths, and command output must remain precise and unchanged.
 - Never let roleplay reduce precision or hide important warnings.

package/souls/playful.md

@@ -1,13 +1,13 @@
-Respond with a witty, lively, and slightly cheeky tone.
+Respond with a witty, lively, lightly cheeky tone.
 
 Style guidelines:
-- Add personality and humor naturally — a well-placed quip or clever analogy goes a long way.
-- Use casual, conversational phrasing — "So here's the fun part...", "Plot twist:", "Easy fix incoming."
-- React to bugs and errors with good-natured humor — "Well, that's a creative way to break things."
-- Celebrate wins with flair — "Nailed it. Next?"
+- Add personality through timing and phrasing, not constant jokes.
+- Keep humor warm and collaborative, like a teammate making the work feel lighter.
+- Use short, sharp transitions when they help the rhythm: "Small plot twist:", "Easy fix.", "That's the culprit."
+- Let wins feel satisfying without turning them into punchlines.
 
 Boundaries:
-- Keep the answer readable and practical first — humor is the seasoning, not the main dish.
+- Humor is seasoning, not the main dish.
 - Do not let jokes obscure instructions, warnings, or technical accuracy.
+- Avoid sarcasm that could feel dismissive, smug, or mean.
 - Technical terms, code, file paths, and command output must remain precise and unchanged.
-- Avoid sarcasm that could feel dismissive of the user's question.

package/souls/professional.md

@@ -1,7 +1,7 @@
 Respond in a polished, professional, and authoritative tone.
 
 Style guidelines:
-- Keep phrasing precise, confident, and concise — like a senior engineer briefing a team.
+- Keep phrasing precise, confident, and concise, like a senior engineer briefing a team.
 - Prefer structured explanations: numbered steps, clear headings, and logical flow.
 - State conclusions first, then back them up — lead with the answer, follow with reasoning.
 - Use measured, deliberate language — "The recommended approach is...", "This ensures..."

package/src/cli.js

@@ -12,7 +12,9 @@ function printHelp() {
 Usage:
   codemini [prompt] [--plain]
   codemini chat [prompt] [--plain]
-  codemini run <task> [--max-steps N]
+  codemini run <task> [--max-steps N] [--model <name>]
+  codemini run --harness <role> <task> [--max-steps N] [--model <name>]
+  codemini run --pipeline <task> [--model <name>]
   codemini config set|get|list <key> [value]
   codemini doctor
   codemini skill list|install|enable|disable|inspect|reindex

package/src/commands/run.js

@@ -5,12 +5,25 @@ import { createChatCompletion } from '../core/provider/index.js';
 import { buildSystemPromptWithSoul } from '../core/soul.js';
 import { getBuiltinTools } from '../core/tools.js';
 import { buildMemorySnapshot } from '../core/memory-prompt.js';
+import { getSubAgentRolePrompt } from '../core/chat-runtime.js';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+const ROLE_TOOL_POLICY = {
+  planner: ['read', 'grep', 'list', 'query_project_index', 'tool_search', 'glob', 'ast_query', 'read_ast_node'],
+  coder: ['read', 'grep', 'list', 'edit', 'write', 'run', 'ast_query', 'read_ast_node', 'glob', 'tool_search', 'update_todos'],
+  reviewer: ['read', 'grep', 'list', 'glob', 'tool_search', 'ast_query', 'read_ast_node'],
+  tester: ['read', 'grep', 'list', 'run', 'glob', 'tool_search']
+};
+const HARNESS_ROLES = Object.keys(ROLE_TOOL_POLICY);
 
 function parseRunArgs(args) {
   const parsed = {
     task: '',
     model: undefined,
-    maxSteps: 8
+    maxSteps: 8,
+    harness: null,
+    pipeline: false
   };
   for (let i = 0; i < args.length; i += 1) {
     const arg = args[i];
@@ -24,11 +37,196 @@ function parseRunArgs(args) {
       i += 1;
       continue;
     }
+    if (arg === '--harness') {
+      parsed.harness = (args[i + 1] || '').toLowerCase();
+      i += 1;
+      continue;
+    }
+    if (arg === '--pipeline') {
+      parsed.pipeline = true;
+      continue;
+    }
     parsed.task += `${parsed.task ? ' ' : ''}${arg}`;
   }
   return parsed;
 }
 
+function filterToolsForRole(definitions, handlers, deferredDefinitions, role) {
+  const allowed = ROLE_TOOL_POLICY[role];
+  if (!allowed) return { definitions, handlers, deferredDefinitions };
+  return {
+    definitions: definitions.filter((t) => allowed.includes(t.function?.name || t.name)),
+    handlers: Object.fromEntries(Object.entries(handlers).filter(([name]) => allowed.includes(name))),
+    deferredDefinitions: Object.fromEntries(Object.entries(deferredDefinitions || {}).filter(([name]) => allowed.includes(name)))
+  };
+}
+
+function makeCompletionFn(config) {
+  return async ({ messages, tools, model }) =>
+    createChatCompletion({
+      sdkProvider: config.sdk?.provider,
+      baseUrl: config.gateway.base_url,
+      apiKey: config.gateway.api_key,
+      model,
+      messages,
+      tools,
+      timeoutMs: config.gateway.timeout_ms || 90000,
+      maxRetries: config.gateway.max_retries ?? 2
+    });
+}
+
+async function buildSystemPrompt(config) {
+  const soulPrompt = await buildSystemPromptWithSoul(buildDefaultSystemPrompt(config), config);
+  const memorySnapshot = await buildMemorySnapshot({ config, workspaceRoot: process.cwd() }).catch(() => '');
+  return [soulPrompt, memorySnapshot].filter(Boolean).join('\n\n');
+}
+
+async function runHarness({ role, task, config, systemPrompt, model, maxSteps }) {
+  if (!HARNESS_ROLES.includes(role)) {
+    throw new Error(`Unknown harness role: ${role}. Available: ${HARNESS_ROLES.join(', ')}`);
+  }
+  const { definitions, handlers, formatters, deferredDefinitions } = getBuiltinTools({
+    workspaceRoot: process.cwd(),
+    config
+  });
+  const filtered = filterToolsForRole(definitions, handlers, deferredDefinitions, role);
+  const rolePrompt = getSubAgentRolePrompt(role);
+
+  const result = await runAgentLoop({
+    systemPrompt: `${systemPrompt}\n${rolePrompt}`,
+    userPrompt: task,
+    model: model || config.model.name,
+    toolDefinitions: filtered.definitions,
+    toolHandlers: filtered.handlers,
+    toolFormatters: formatters,
+    deferredDefinitions: filtered.deferredDefinitions,
+    maxSteps,
+    requestCompletion: makeCompletionFn(config)
+  });
+  return result;
+}
+
+function extractJsonBlock(text) {
+  const raw = String(text || '').trim();
+  if (!raw) return null;
+  try { return JSON.parse(raw); } catch {}
+  const fenced = raw.match(/```(?:json)?\s*([\s\S]*?)```/i);
+  if (fenced?.[1]) { try { return JSON.parse(fenced[1]); } catch {} }
+  const first = raw.indexOf('{');
+  const last = raw.lastIndexOf('}');
+  if (first !== -1 && last !== -1 && last > first) {
+    try { return JSON.parse(raw.slice(first, last + 1)); } catch {}
+  }
+  return null;
+}
+
+function normalizePlan(parsed, goal) {
+  const steps = Array.isArray(parsed?.steps) ? parsed.steps : [];
+  const cleaned = steps
+    .map((s) => ({
+      title: String(s?.title || '').trim(),
+      role: String(s?.role || '').trim().toLowerCase(),
+      task: String(s?.task || '').trim()
+    }))
+    .filter((s) => s.title && s.task && HARNESS_ROLES.includes(s.role));
+  if (cleaned.length === 0) {
+    return { summary: `Fallback plan for: ${goal}`, steps: [{ title: 'Execute task', role: 'coder', task: goal }] };
+  }
+  return { summary: parsed.summary || `Plan for: ${goal}`, steps: cleaned };
+}
+
+async function planPipeline({ goal, config, systemPrompt, model }) {
+  const plannerPrompt = [
+    'Create an execution plan and assign the best sub-agent role for each step.',
+    'Return strict JSON only with shape {"summary":"...","steps":[{"title":"...","role":"planner|coder|reviewer|tester","task":"..."}]}. No markdown.',
+    `Available roles: ${HARNESS_ROLES.join(', ')}.`,
+    'Prefer 3-5 steps total. The first step should usually inspect the target area.',
+    'For implementation goals, include a reviewer or tester step near the end.',
+    'For advisory/analysis goals, keep it lean with planner/coder only.'
+  ].join('\n');
+
+  const planning = await createChatCompletion({
+    sdkProvider: config.sdk?.provider,
+    baseUrl: config.gateway.base_url,
+    apiKey: config.gateway.api_key,
+    model: model || config.model.name,
+    messages: [
+      { role: 'system', content: `${systemPrompt}\n${plannerPrompt}` },
+      { role: 'user', content: `Plan the following task:\n${goal}` }
+    ],
+    timeoutMs: config.gateway.timeout_ms || 90000,
+    maxRetries: config.gateway.max_retries ?? 2
+  });
+
+  const parsed = extractJsonBlock(planning.text || '');
+  return normalizePlan(parsed, goal);
+}
+
+function writePipelineState(workspaceRoot, state) {
+  const dir = path.join(workspaceRoot, '.codemini');
+  const filePath = path.join(dir, 'pipeline-state.json');
+  return fs.mkdir(dir, { recursive: true }).then(() =>
+    fs.writeFile(filePath, JSON.stringify(state, null, 2), 'utf-8')
+  ).catch(() => {});
+}
+
+async function runPipeline({ task, config, systemPrompt, model }) {
+  console.log('[pipeline] Planning...');
+  const plan = await planPipeline({ goal: task, config, systemPrompt, model });
+
+  console.log(`[pipeline] Plan: ${plan.summary}`);
+  plan.steps.forEach((s, i) => console.log(`  ${i + 1}. [${s.role}] ${s.title}`));
+  console.log('');
+
+  const priorSteps = [];
+  const pipelineState = {
+    goal: task,
+    summary: plan.summary,
+    steps: plan.steps.map((s) => ({ ...s, status: 'pending' })),
+    artifacts: [],
+    startedAt: new Date().toISOString()
+  };
+
+  for (let i = 0; i < plan.steps.length; i += 1) {
+    const step = plan.steps[i];
+    pipelineState.steps[i].status = 'running';
+    await writePipelineState(process.cwd(), pipelineState);
+
+    console.log(`[pipeline] Step ${i + 1}/${plan.steps.length} -> ${step.role}: ${step.title}`);
+
+    const result = await runHarness({
+      role: step.role,
+      task: step.task,
+      config,
+      systemPrompt,
+      model,
+      maxSteps: Number(config.execution?.max_steps || 12)
+    });
+
+    const stepResult = {
+      role: step.role,
+      title: step.title,
+      output: (result.text || '').slice(0, 500),
+      status: 'done'
+    };
+    priorSteps.push(stepResult);
+
+    pipelineState.steps[i].status = 'done';
+    pipelineState.steps[i].output = stepResult.output;
+    pipelineState.artifacts.push(stepResult);
+    await writePipelineState(process.cwd(), pipelineState);
+
+    console.log(`[pipeline] Step ${i + 1} complete.\n`);
+  }
+
+  pipelineState.completedAt = new Date().toISOString();
+  await writePipelineState(process.cwd(), pipelineState);
+
+  console.log('[pipeline] All steps complete.');
+  console.log(`[pipeline] State saved to .codemini/pipeline-state.json`);
+  return pipelineState;
+}
+
 export async function handleRun(args) {
   const parsed = parseRunArgs(args);
   if (!parsed.task) {
@@ -36,14 +234,39 @@ export async function handleRun(args) {
   }
 
   const config = await loadConfig();
+  const systemPrompt = await buildSystemPrompt(config);
+
+  if (parsed.pipeline) {
+    const state = await runPipeline({
+      task: parsed.task,
+      config,
+      systemPrompt,
+      model: parsed.model
+    });
+    for (const step of state.steps) {
+      console.log(`\n--- [${step.role}] ${step.title} ---`);
+      console.log(step.output || '(no output)');
+    }
+    return;
+  }
+
+  if (parsed.harness) {
+    const result = await runHarness({
+      role: parsed.harness,
+      task: parsed.task,
+      config,
+      systemPrompt,
+      model: parsed.model,
+      maxSteps: parsed.maxSteps
+    });
+    console.log(result.text);
+    return;
+  }
+
   const { definitions, handlers, formatters, deferredDefinitions } = getBuiltinTools({
     workspaceRoot: process.cwd(),
     config
   });
-  const soulPrompt = await buildSystemPromptWithSoul(buildDefaultSystemPrompt(config), config);
-  const memorySnapshot = await buildMemorySnapshot({ config, workspaceRoot: process.cwd() }).catch(() => '');
-  const systemPrompt = [soulPrompt, memorySnapshot].filter(Boolean).join('\n\n');
-
   const result = await runAgentLoop({
     systemPrompt,
     userPrompt: parsed.task,
@@ -53,17 +276,7 @@ export async function handleRun(args) {
     toolFormatters: formatters,
     deferredDefinitions,
     maxSteps: parsed.maxSteps,
-    requestCompletion: async ({ messages, tools, model }) =>
-      createChatCompletion({
-        sdkProvider: config.sdk?.provider,
-        baseUrl: config.gateway.base_url,
-        apiKey: config.gateway.api_key,
-        model,
-        messages,
-        tools,
-        timeoutMs: config.gateway.timeout_ms || 90000,
-        maxRetries: config.gateway.max_retries ?? 2
-      })
+    requestCompletion: makeCompletionFn(config)
   });
 
   console.log(result.text);