codemini-cli 0.5.0 → 0.5.2

package/skills/superpowers-lite/SKILL.md

@@ -4,9 +4,9 @@ description: Concise workflow skill tuned for 30B-class models: prefer structure
 version: 0.3.0
 ---
 
-Use this skill as the default lightweight operating style for all coding work.
+Use this skill as the default operating style for all coding work, preferring lightweight approaches but invoking specialized skills when needed.
 
-This is the default, not an interrogation mode. Keep help calm and direct. For high-risk decisions only, add a light Grill Me pass: ask 1-3 sharp questions about assumptions, failure modes, or verification before proceeding. Challenge the plan, not the person.
+This is the default, not an interrogation mode. Keep help calm and direct. For decisions that affect multiple systems, involve irreversible changes, or have significant user impact only, add a light Grill Me pass: ask 1-3 sharp questions about assumptions, failure modes, or verification before proceeding. Challenge the plan, not the person.
 
 **Announce when using a skill:** Before following any route below, say "Using [skill name] to [purpose]" in your response. This signals intent and prevents silent skill skipping.
 
@@ -15,6 +15,7 @@ This is the default, not an interrogation mode. Keep help calm and direct. For h
 Before responding to ANY user message, check whether a skill applies. If there is even a small chance a skill is relevant, YOU MUST invoke it. This is not optional.
 
 **Skill check comes BEFORE:**
+
 - Clarifying questions
 - Code exploration
 - Writing code
@@ -24,43 +25,28 @@ Before responding to ANY user message, check whether a skill applies. If there i
 
 If you catch yourself thinking any of the following, STOP — you are about to skip a skill incorrectly:
 
-| Thought | Reality |
-|---|---|
-| "This is too simple for a skill" | Simple tasks derail too. Use the skill. |
-| "I need more context first" | Skills tell you HOW to gather context. Check first. |
-| "The skill is overkill here" | A lightweight pass is cheaper than rework. |
-| "I'll just do this one thing first" | Do the skill check BEFORE anything. |
-| "I already know what to do" | Knowing the concept ≠ following the process. |
+| Thought                             | Reality                                             |
+| ----------------------------------- | --------------------------------------------------- |
+| "This is too simple for a skill"    | Simple tasks derail too. Use the skill.             |
+| "I need more context first"         | Skills tell you HOW to gather context. Check first. |
+| "The skill is overkill here"        | A lightweight pass is cheaper than rework.          |
+| "I'll just do this one thing first" | Do the skill check BEFORE anything.                 |
+| "I already know what to do"         | Knowing the concept ≠ following the process.        |
 
 ## Routing
 
 Evaluate the user's request and YOU MUST follow exactly one route:
 
-1. **Task is clear, small, and obvious path:**
-   - Execute directly
-   - Do NOT invoke brainstorming
-
-2. **Non-trivial implementation that needs codebase exploration, touches multiple areas, or changes shared behavior:**
-   - YOU MUST invoke `writing-plans` skill
-   - Inspect first, then present an implementation plan for approval
-   - Do NOT jump straight into coding
-
-3. **Goal is clear but multiple reasonable approaches exist and the missing piece is user preference or tradeoff choice:**
-   - YOU MUST invoke `brainstorm` skill
-   - Follow brainstorm process — do NOT substitute it with ad-hoc questions
-
-4. **Request is missing a key constraint or success condition:**
-   - Ask exactly one clarifying question
-   - Do NOT give options or write code
-   - Stop and wait for the answer
-
-5. **Request is greenfield and underspecified** ("build a page", "make a site", "generate an app"):
-   - Treat as missing key constraints
-   - Ask one high-value question
-   - Do NOT assume features, scope, or storage model
-   - Stop and wait for the answer
+| Condition                                                                                                          | Action                                                                                                                                        |
+| ------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------- |
+| Task is clear, small, and obvious path                                                                             | Execute directly. Do NOT invoke brainstorming.                                                                                                |
+| Non-trivial implementation that needs codebase exploration, touches multiple areas, or changes shared behavior     | YOU MUST invoke `writing-plans` skill. Inspect first, then present an implementation plan for approval. Do NOT jump straight into coding.     |
+| Goal is clear but multiple reasonable approaches exist and the missing piece is user preference or tradeoff choice | YOU MUST invoke `brainstorm` skill. Follow brainstorm process — do NOT substitute it with ad-hoc questions.                                   |
+| Request is missing a key constraint or success condition                                                           | Ask exactly one clarifying question. Do NOT give options or write code. Stop and wait for the answer.                                         |
+| Request is greenfield and underspecified ("build a page", "make a site", "generate an app")                        | Treat as missing key constraints. Ask one high-value question. Do NOT assume features, scope, or storage model. Stop and wait for the answer. |
 
 **Decision boundary:**
+
 - Use `brainstorm` when one focused user answer will determine the direction.
 - Use `writing-plans` when the task is implementation-shaped but needs a plan before coding.
 - If both could apply, prefer `brainstorm` first when the core uncertainty is user intent; prefer `writing-plans` first when the core uncertainty is codebase impact.

package/skills/writing-plans/SKILL.md

@@ -1,67 +1,67 @@
----
-name: writing-plans
-description: Use when you have a clear goal or approved design for a non-trivial task, before touching code. Creates a step-by-step implementation plan with exact file paths, code, and verification steps.
-version: 0.1.0
----
-
-Use this skill when the task is implementation-shaped but large enough that jumping straight into coding is risky.
-
-**Announce:** When entering writing-plans, say "Using writing-plans to create an implementation plan."
-
-## When to Use
-
-- Task touches 3+ files or multiple areas of the codebase
-- Task changes shared behavior, APIs, or data flow
-- Task has interdependent steps where order matters
-- You need user sign-off before starting work
-
-## When NOT to Use
-
-- Single-file fix with a clear solution → just do it
-- Task is a direct extension of an existing pattern → just do it
-- User explicitly says to skip planning → respect that
-
-## Plan Format
-
-Write the plan as a markdown checklist. Each step is one action (2-5 minutes of work).
-
-```markdown
-# [Task Name] Plan
-
-**Goal:** [one sentence]
-**Files:** [list files that will be created or modified]
-
-### Phase 1: [Phase name]
-
-- [ ] **Step N: [action verb + what]**
-  - File: `exact/path/to/file.ext`
-  - What: [specific change]
-  - Verify: [how to confirm it works]
-
-### Phase 2: [Phase name]
-
-- [ ] ...
-```
-
-## Rules
-
-1. **Exact file paths always.** No "the relevant file" or "in the component directory".
-2. **Show code in steps that change code.** No "add appropriate error handling" without showing the code.
-3. **No placeholders.** No "TBD", "TODO", "implement later", "similar to step N". If a step needs code, write the code.
-4. **Every step is verifiable.** Include a test command, expected output, or visual check.
-5. **YAGNI.** Only plan what was asked for. Do not add "nice to have" steps.
-6. **DRY.** If two steps share logic, plan the shared piece first.
-
-## Self-Review
-
-After writing the plan, check:
-- Can you point to a step for every requirement? If not, add the missing step.
-- Any placeholders or vague descriptions? Replace with specifics.
-- Do types and function names match across steps? Fix inconsistencies.
-- Is the order correct? Steps that depend on earlier work must come after.
-
-## Exit
-
-After the user approves the plan → proceed to implement step by step.
-After each step → verify before moving to the next.
-If a step reveals the plan is wrong → stop, explain, and update the plan before continuing.
+---
+name: writing-plans
+description: Use when you have a clear goal or approved design for a non-trivial task, before touching code. Creates a step-by-step implementation plan with exact file paths, code, and verification steps.
+version: 0.1.0
+---
+
+Use this skill when the task is implementation-shaped but large enough that jumping straight into coding is risky.
+
+**Announce:** When entering writing-plans, say "Using writing-plans to create an implementation plan."
+
+## When to Use
+
+- Task touches 3+ files or multiple areas of the codebase
+- Task changes shared behavior, APIs, or data flow
+- Task has interdependent steps where order matters
+- You need user sign-off before starting work
+
+## When NOT to Use
+
+- Single-file fix with a clear solution → just do it
+- Task is a direct extension of an existing pattern → just do it
+- User explicitly says to skip planning → respect that
+
+## Plan Format
+
+Write the plan as a markdown checklist. Each step is one action (2-5 minutes of work).
+
+```markdown
+# [Task Name] Plan
+
+**Goal:** [one sentence]
+**Files:** [list files that will be created or modified]
+
+### Phase 1: [Phase name]
+
+- [ ] **Step N: [action verb + what]**
+  - File: `exact/path/to/file.ext`
+  - What: [specific change]
+  - Verify: [how to confirm it works]
+
+### Phase 2: [Phase name]
+
+- [ ] ...
+```
+
+## Rules
+
+1. **Exact file paths always.** No "the relevant file" or "in the component directory".
+2. **Show code in steps that change code.** No "add appropriate error handling" without showing the code.
+3. **No placeholders.** No "TBD", "TODO", "implement later", "similar to step N". If a step needs code, write the code.
+4. **Every step is verifiable.** Include a test command, expected output, or visual check.
+5. **YAGNI.** Only plan what was asked for. Do not add "nice to have" steps.
+6. **DRY.** If two steps share logic, plan the shared piece first.
+
+## Self-Review
+
+After writing the plan, check:
+- Can you point to a step for every requirement? If not, add the missing step.
+- Any placeholders or vague descriptions? Replace with specifics.
+- Do types and function names match across steps? Fix inconsistencies.
+- Is the order correct? Steps that depend on earlier work must come after.
+
+## Exit
+
+After the user approves the plan → proceed to implement step by step.
+After each step → verify before moving to the next.
+If a step reveals the plan is wrong → stop, explain, and update the plan before continuing.

package/src/commands/chat.js

@@ -117,7 +117,7 @@ export async function submitAndPrint(runtime, line, { output: out = process.stdo
 }
 
 async function runPlainLoop(runtime) {
-  console.log('CodeMini CLI plain mode. Use /help and /exit.');
+  console.log('Codemini CLI plain mode. Use /help and /exit.');
   const rl = readline.createInterface({ input, output });
   try {
     while (true) {

package/src/commands/run.js

@@ -2,10 +2,9 @@ import { loadConfig } from '../core/config-store.js';
 import { buildDefaultSystemPrompt } from '../core/default-system-prompt.js';
 import { runAgentLoop } from '../core/agent-loop.js';
 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 { composeSystemPrompt } from '../core/system-prompt-composer.js';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 
@@ -82,9 +81,11 @@ function makeCompletionFn(config) {
 }
 
 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');
+  return composeSystemPrompt({
+    shellRulesPrompt: buildDefaultSystemPrompt(config),
+    config,
+    workspaceRoot: process.cwd()
+  });
 }
 
 async function runHarness({ role, task, config, systemPrompt, model, maxSteps }) {
@@ -98,9 +99,16 @@ async function runHarness({ role, task, config, systemPrompt, model, maxSteps })
   try {
     const filtered = filterToolsForRole(definitions, handlers, deferredDefinitions, role);
     const rolePrompt = getSubAgentRolePrompt(role);
+    const harnessSystemPrompt = await composeSystemPrompt({
+      shellRulesPrompt: systemPrompt,
+      config,
+      skillsPrompt: rolePrompt,
+      includeSoul: false,
+      includeMemory: false
+    });
 
     const result = await runAgentLoop({
-      systemPrompt: `${systemPrompt}\n${rolePrompt}`,
+      systemPrompt: harnessSystemPrompt,
       userPrompt: task,
       model: model || config.model.name,
       toolDefinitions: filtered.definitions,
@@ -154,6 +162,13 @@ async function planPipeline({ goal, config, systemPrompt, model }) {
     'For implementation goals, include a reviewer or tester step near the end.',
     'For advisory/analysis goals, keep it lean with planner/advisor only; do not use coder unless code or files will be modified.'
   ].join('\n');
+  const plannerSystemPrompt = await composeSystemPrompt({
+    shellRulesPrompt: systemPrompt,
+    config,
+    skillsPrompt: plannerPrompt,
+    includeSoul: false,
+    includeMemory: false
+  });
 
   const planning = await createChatCompletion({
     sdkProvider: config.sdk?.provider,
@@ -161,7 +176,7 @@ async function planPipeline({ goal, config, systemPrompt, model }) {
     apiKey: config.gateway.api_key,
     model: model || config.model.name,
     messages: [
-      { role: 'system', content: `${systemPrompt}\n${plannerPrompt}` },
+      { role: 'system', content: plannerSystemPrompt },
       { role: 'user', content: `Plan the following task:\n${goal}` }
     ],
     timeoutMs: config.gateway.timeout_ms || 1800000,

package/src/core/agent-loop.js

@@ -535,15 +535,18 @@ export async function runAgentLoop({
   let pendingSummaryNudges = 0;
   const analysisGuard = createAnalysisGuardState(userPrompt);
   const alwaysAllowSet = new Set((Array.isArray(alwaysAllowTools) ? alwaysAllowTools : []).map((t) => String(t)));
-  let autoDreamChecked = false;
+  let lastAutoDreamCheckStep = 0;
 
   // Mutable tool list — grows as tool_search loads deferred tools
   const activeTools = [...toolDefinitions];
 
-  async function maybeRunAutoDream() {
-    if (autoDreamChecked) return;
-    autoDreamChecked = true;
+  async function maybeRunAutoDream(stepNumber = 0, { force = false } = {}) {
     if (executionMode === 'plan') return;
+    const interval = Math.max(1, Number(config?.memory?.auto_dream_check_interval_steps || 20));
+    const normalizedStep = Math.max(1, Number(stepNumber || 1));
+    if (!force && lastAutoDreamCheckStep > 0 && normalizedStep - lastAutoDreamCheckStep < interval) return;
+    if (force && lastAutoDreamCheckStep === normalizedStep) return;
+    lastAutoDreamCheckStep = normalizedStep;
     const autoDreamResult = await checkAutoDreamThreshold(config);
     if (!autoDreamResult) return;
     const dreamTool = toolHandlers['dream_consolidate'];
@@ -572,6 +575,7 @@ export async function runAgentLoop({
       break;
     }
     if (onEvent) onEvent({ type: 'step:start', step: step + 1 });
+    await maybeRunAutoDream(step + 1);
     const completion = await requestCompletion({
       model,
       messages,
@@ -638,7 +642,7 @@ export async function runAgentLoop({
         continue;
       }
       finalText = assistantText;
-      await maybeRunAutoDream();
+      await maybeRunAutoDream(step + 1, { force: true });
       return { text: finalText, messages, steps: step + 1 };
     }
 
@@ -655,7 +659,7 @@ export async function runAgentLoop({
       ]
         .filter(Boolean)
         .join('\n');
-      await maybeRunAutoDream();
+      await maybeRunAutoDream(step + 1, { force: true });
       return { text: finalText.trim(), messages, steps: step + 1 };
     }
 
@@ -949,7 +953,7 @@ export async function runAgentLoop({
   }
 
   const fallback = lastAssistantText || 'Stopped before final response.';
-  await maybeRunAutoDream();
+  await maybeRunAutoDream(maxSteps, { force: true });
   return {
     text: `${fallback}\n\n[stopped] Reached max tool steps (${maxSteps}). Try a narrower prompt or increase execution.max_steps.`,
     messages,