cairn-ai 0.1.7 → 0.1.8

package/commands/cairn-review.md

@@ -8,9 +8,9 @@ Goal: review completed work against plan, memory, policy, and evidence.
 
 Procedure:
 
-1. Every agent must read the project-root `MEMORY.md` for domain knowledge and repository policy before review work, then read the plan slice and memory inputs.
+1. Every agent must read the project-root `MEMORY.md` for domain knowledge and repository policy before review work, then read the plan task and memory inputs.
 2. Check changed files, tool readiness evidence, and verification evidence.
-3. Delegate independent read-only review to `explorer` when it materially improves speed or quality; use `worker` only for scoped verification reruns or QA artifacts. Tell every delegated agent to read the project-root `MEMORY.md` before work.
+3. Delegate independent read-only review to `explorer` when it materially improves speed or quality; use `worker` only for scoped verification reruns or QA artifacts. When subagent tools are available, each agent may recursively delegate bounded sub-tasks to subagents. Tell every delegated agent and child subagent to read the project-root `MEMORY.md` before work, keep scope, and preserve others' edits.
 4. Report findings first, ordered by severity, with file and line references. If no issues are found, say so clearly and mention remaining test gaps or residual risk.
 5. Record review evidence in `docs/plan/<topic>.md`.
 6. Use the OS locale for user-visible output unless the user asks for another language.

package/commands/cairn-work.md

@@ -4,20 +4,22 @@ Use the `cairn-work` skill.
 
 Prerequisite: if `node scripts/cairn.mjs doctor` fails, restore installation with `node scripts/cairn.mjs install` or `node scripts/cairn.mjs upgrade`.
 
-Goal: execute the next incomplete module slice in `PLAN.md` without bypassing the recorded complexity triage.
+Goal: execute the next incomplete module task in `PLAN.md` without bypassing the recorded complexity triage.
 
 Procedure:
 
-1. Every agent must read the project-root `MEMORY.md` for domain knowledge and repository policy before selecting or executing a slice.
+1. Every agent must read the project-root `MEMORY.md` for domain knowledge and repository policy before selecting or executing a task.
 2. Read `PLAN.md`, the detailed plan, and relevant memory notes.
 3. Read the Codex or Claude model guidance recorded in the plan.
-4. Select one small module slice.
+4. Select one small module task.
 5. Confirm required tool readiness. If a required LSP/check tool is missing, run `node scripts/cairn.mjs toolcheck --install` or a repository-native install command before accepting a fallback.
 6. Confirm the complexity triage and selected Light/Heavy Path recorded in the plan. If missing, update the plan before mutating files.
 7. For Light Path, implement directly or use one bounded `worker`, then run focused verification.
 8. For Heavy Path, follow the plan's staged implementation and review gates without role-mapping shortcuts.
-9. When delegating implementation to `worker`, state the file ownership clearly, tell every delegated agent to read the project-root `MEMORY.md` before work, and tell the worker not to revert others' edits.
-10. Re-run module acceptance verification.
-11. Re-run surface integration verification.
-12. Record tool readiness and verification evidence in `docs/plan/<topic>.md` and update `PLAN.md`.
-13. Use the OS locale for user-visible output unless the user asks for another language.
+9. When delegating implementation to `worker`, state the file ownership clearly. When subagent tools are available, each agent may recursively delegate bounded sub-tasks to subagents. Tell every delegated agent and child subagent to read the project-root `MEMORY.md` before work, keep scope, and preserve others' edits.
+10. For Heavy Path, run the recorded automated test command and record explicit `Tests:` evidence before any completion claim.
+11. Re-run module acceptance verification.
+12. Re-run surface integration verification.
+13. Record tool readiness and verification evidence in `docs/plan/<topic>.md` and update `PLAN.md`.
+14. If the user asks a side question, status question, or narrow clarification while this task is still active, answer it briefly and then resume the previous active work unless the user explicitly asks to pause, stop, or switch tasks.
+15. Use the OS locale for user-visible output unless the user asks for another language.

package/docs/model-guidance/README.md

@@ -19,9 +19,9 @@ The goal is not to make prompts long by model. The goal is to stabilize the same
 - Select Light Path or Heavy Path before implementation.
 - Detect required LSP, typecheck, lint, dry-run, and verification tools before implementation.
 - Missing required tools must trigger a project-local, repository-native, or ephemeral install attempt before they can be treated as unavailable.
-- Every implementation slice must pass module acceptance verification and surface integration verification.
+- Every implementation task must pass module acceptance verification and surface integration verification.
 - Before mutating external state, run the closest available dry-run, check, plan, diff, validate, or equivalent command.
-- Limit each slice to two verification passes by default. After two failed passes, record the blocker or split the slice instead of continuing a repeated loop.
+- Limit each task to two verification passes by default. After two failed passes, record the blocker or split it into sub-tasks instead of continuing a repeated loop.
 - User-visible output must follow the OS locale unless the user asks for another language.
 
 ## Delegation Defaults

package/docs/model-guidance/claude.md

@@ -17,7 +17,7 @@ Claude-family models are strong at long-context retention, policy interpretation
 - Do not accept "tool missing" as a reason to skip precise codebase exploration until install or bootstrap has been attempted.
 - Do not skip the two verification gates even on Light Path.
 - Do not approve a plan that lacks dry-run or check evidence for external-state-changing work.
-- Do not allow open-ended verification loops. Require a blocker or slice split after two failed passes.
+- Do not allow open-ended verification loops. Require a blocker or sub-task split after two failed passes.
 - On Heavy Path, check plan gaps before implementation.
 - Before asking the user, use repository evidence and available `explorer`/`worker` delegation when it materially improves speed or quality.
 - Write user-visible output in the OS locale unless the user asks for another language.
@@ -35,7 +35,7 @@ Claude-family models are strong at long-context retention, policy interpretation
 - Keep the plan short and executable.
 - Always record complexity triage and the selected Light/Heavy Path.
 - Always record tool readiness and blockers.
-- Each module slice must include files, contract, dry-run or check command when applicable, module acceptance verification, and surface integration verification.
+- Each module task must include files, contract, dry-run or check command when applicable, module acceptance verification, and surface integration verification.
 
 ### Review
 

package/docs/model-guidance/codex.md

@@ -1,10 +1,10 @@
 # Codex Model Guidance
 
-Codex-family models are strong at small implementation slices, explicit tool use, and repeatable verification. In Cairn, prefer them for bounded `worker` tasks and structurally clear planning.
+Codex-family models are strong at small implementation tasks, explicit tool use, and repeatable verification. In Cairn, prefer them for bounded `worker` tasks and structurally clear planning.
 
 ## Use Strengths
 
-- Quickly handle implementation slices with clear file scope.
+- Quickly handle implementation tasks with clear file scope.
 - Read existing patterns and make minimal changes in the same style.
 - Run repository tool readiness checks and bootstrap missing command-line tools.
 - Capture module acceptance verification and surface integration verification from command results.
@@ -14,23 +14,23 @@ Codex-family models are strong at small implementation slices, explicit tool use
 ## Adjustment Rules
 
 - Do not start implementation without a plan.
-- Keep work units small. Split large changes into smaller plan slices.
+- Keep work units small. Split large changes into smaller plan tasks.
 - If `apply_patch` is unstable in the environment, use an editing tool or a clear file update path.
 - Do not duplicate the same exploration. Wait for already delegated searches.
 - Do not trust success-looking output alone. Confirm real files, commands, and surface evidence.
 - Do not skip LSP, typecheck, lint, dry-run, or verification because a tool is missing. Try repository-local installation or record the failed install attempt as a blocker.
-- Do not continue an open-ended verification loop. Use at most two verification passes per slice unless the plan records a risk-based exception.
+- Do not continue an open-ended verification loop. Use at most two verification passes per task unless the plan records a risk-based exception.
 - Write user-visible output in the OS locale unless the user asks for another language.
 
 ## Path Guidance
 
 ### Planning
 
-- On Light Path, write explicit slice contracts when a plan artifact exists.
+- On Light Path, write explicit task contracts when a plan artifact exists.
 - Record detected stack, required tools, install commands, and tool blockers.
 - Specify file scope and verification commands so implementation does not need to rediscover them.
-- Specify the dry-run or check command for slices that can mutate external state, or record why none exists.
-- On failure, prefer slice re-splitting over a repeated loop.
+- Specify the dry-run or check command for tasks that can mutate external state, or record why none exists.
+- On failure, prefer sub-task splitting over a repeated loop.
 
 ### Implementation
 
@@ -38,7 +38,7 @@ Codex-family models are strong at small implementation slices, explicit tool use
 - Confirm required tools are available. Install or bootstrap missing required tools before implementation.
 - Run the recorded dry-run or check command before external-state mutation when applicable.
 - After changes, run both module acceptance verification and surface integration verification.
-- If a gate fails, diagnose once, shrink or split the slice, and rerun both gates. Stop after the second failed pass and record the blocker.
+- If a gate fails, diagnose once, shrink the task or split it into sub-tasks, and rerun both gates. Stop after the second failed pass and record the blocker.
 - Return evidence in a form that can be recorded in `docs/plan/<topic>.md`.
 
 ### Delegation

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cairn-ai",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "Token-efficient agent harness with tool readiness for Codex, Claude Code, and Antigravity",
   "license": "MIT",
   "author": {

package/scripts/cairn-state.mjs

@@ -44,15 +44,15 @@ This file is a short index of active and completed work plans.
 - Plans must be decision-complete before implementation.
 - Run complexity triage before applying agent, plugin, or delegated workflow guidance.
 - Record the selected Light Path or Heavy Path and the checked Heavy Path signals in \`docs/plan/<topic>.md\`.
-- Split implementation into small module slices.
+- Split implementation into small module tasks.
 - Detect repository stack and required LSP/check tools before implementation.
 - Install or bootstrap missing required tools before declaring them unavailable.
-- Each slice normally passes exactly two gates.
+- Each task normally passes exactly two gates.
   - Module acceptance verification.
   - Surface integration verification.
 - Run dry-run or check mode before external-state mutation when available.
-- Use at most two verification passes per slice by default.
-- If a gate fails, diagnose once, shrink or split the slice, and rerun both gates.
+- Use at most two verification passes per task by default.
+- If a gate fails, diagnose once, shrink the task or split it into sub-tasks, and rerun both gates.
 - After two failed passes, record the blocker in \`docs/plan/<topic>.md\`.
 `;
 
@@ -136,8 +136,9 @@ async function pendingActivePlanItems(root) {
     }
     const unchecked = [...text.matchAll(/^\s*-\s+\[\s\]\s+(.+)$/gm)].map((match) => match[1].trim());
     const emptyEvidence = emptyEvidenceItems(text);
-    if (unchecked.length > 0 || emptyEvidence.length > 0) {
-      pending.push({ path: relativePath, unchecked, emptyEvidence });
+    const missingHeavyPathTests = heavyPathMissingTests(text);
+    if (unchecked.length > 0 || emptyEvidence.length > 0 || missingHeavyPathTests.length > 0) {
+      pending.push({ path: relativePath, unchecked, emptyEvidence, missingHeavyPathTests });
     }
   }
 
@@ -177,6 +178,16 @@ function emptyEvidenceItems(text) {
   return empty;
 }
 
+function heavyPathMissingTests(text) {
+  if (!/^\s*-\s+Selected path:\s*Heavy Path\.?\s*$/im.test(text)) return [];
+  const evidence = section(text, "Evidence");
+  const hasExplicitTestEvidence = [
+    /^\s*-\s+(Tests?|Test execution|Automated tests):\s*\S.+$/im,
+    /^\s*-\s+Module acceptance:\s+.*\b(npm test|node --test|pytest|phpunit|go test|cargo test|mvn test|gradle test|swift test|xcodebuild test)\b/im,
+  ].some((pattern) => pattern.test(evidence));
+  return hasExplicitTestEvidence ? [] : ["Heavy Path test evidence is missing"];
+}
+
 function section(text, title) {
   const pattern = new RegExp(`^##\\s+${escapeRegExp(title)}\\s*$([\\s\\S]*?)(?=^##\\s+|(?![\\s\\S]))`, "m");
   return text.match(pattern)?.[1]?.trim() ?? "";
@@ -187,16 +198,17 @@ function stopBlockedMessage({ event, ko, pending }) {
   const suffix = pending.length > 3 ? `; +${pending.length - 3} more` : "";
   if (ko) {
     const subject = event === "subagent-stop" ? "서브에이전트 완료 신호" : "완료 신호";
-    return `Cairn 종료 게이트: ${subject}를 차단했습니다. 미완료 작업이 남아 있습니다. PLAN.md의 Active Plans를 다시 읽고 다음 미완료 slice를 계속 진행하세요: ${itemText}${suffix}`;
+    return `Cairn 종료 게이트: ${subject}를 차단했습니다. 미완료 작업이 남아 있습니다. PLAN.md의 Active Plans를 다시 읽고 다음 미완료 task를 계속 진행하세요: ${itemText}${suffix}`;
   }
   const subject = event === "subagent-stop" ? "subagent completion signal" : "completion signal";
-  return `Cairn stop gate: blocked ${subject}. Incomplete work remains. Re-read PLAN.md Active Plans and continue the next incomplete slice: ${itemText}${suffix}`;
+  return `Cairn stop gate: blocked ${subject}. Incomplete work remains. Re-read PLAN.md Active Plans and continue the next incomplete task: ${itemText}${suffix}`;
 }
 
 function formatPendingItem(item) {
   const reasons = [
     ...item.unchecked.map((label) => `unchecked: ${label}`),
     ...item.emptyEvidence.map((label) => `empty evidence: ${label}`),
+    ...(item.missingHeavyPathTests ?? []).map((label) => `missing tests: ${label}`),
   ];
   return `${item.path} (${reasons.slice(0, 3).join(", ")})`;
 }

package/scripts/cairn-state.sh

@@ -53,15 +53,15 @@ This file is a short index of active and completed work plans.
 
 - Every agent must start assigned work by reading the project-root `MEMORY.md` for domain knowledge and repository policy.
 - Plans must be decision-complete before implementation.
-- Split implementation into small module slices.
+- Split implementation into small module tasks.
 - Detect repository stack and required LSP/check tools before implementation.
 - Install or bootstrap missing required tools before declaring them unavailable.
-- Each slice normally passes exactly two gates.
+- Each task normally passes exactly two gates.
   - Module acceptance verification.
   - Surface integration verification.
 - Run dry-run or check mode before external-state mutation when available.
-- Use at most two verification passes per slice by default.
-- If a gate fails, diagnose once, shrink or split the slice, and rerun both gates.
+- Use at most two verification passes per task by default.
+- If a gate fails, diagnose once, shrink the task or split it into sub-tasks, and rerun both gates.
 - After two failed passes, record the blocker in `docs/plan/<topic>.md`.
 EOF
 fi

package/scripts/cairn.mjs

@@ -59,15 +59,15 @@ function isCliEntry() {
 const messages = {
   en: {
     memory: "Use the cairn-memory skill. Keep MEMORY.md as a short index and write details to docs/memory/<domain>.md.",
-    plan: "Use the cairn-plan skill before non-trivial implementation. Every agent must first read the project-root MEMORY.md for domain knowledge and repository policy. Keep PLAN.md as an index, write detailed plans to docs/plan/<topic>.md, and record Light/Heavy Path triage before any mutation.",
-    work: "Use the cairn-work skill only after a plan exists. Every agent must first read the project-root MEMORY.md for domain knowledge and repository policy. Execute one module slice using the recorded Light/Heavy Path route, and capture dry-run/check, module, and surface evidence.",
+    plan: "Use the cairn-plan skill before non-trivial implementation. Every agent must first read the project-root MEMORY.md for domain knowledge and repository policy. Understand the whole work first, then classify it into executable tasks and sub-tasks. Keep PLAN.md as an index, write detailed plans to docs/plan/<topic>.md, and record Light/Heavy Path triage before any mutation.",
+    work: "Use the cairn-work skill only after a plan exists. Every agent must first read the project-root MEMORY.md for domain knowledge and repository policy. Execute one module task using the recorded Light/Heavy Path route, and capture dry-run/check, module, and surface evidence. If the user asks a side question while work is active, answer briefly and then resume unless they explicitly ask to pause, stop, or switch tasks.",
     review: "Use the cairn-review skill. Compare evidence against PLAN.md and MEMORY.md.",
     usage: "Usage: cairn install|upgrade|doctor|uninstall|init|memory|plan|work|review|toolcheck",
   },
   ko: {
     memory: "cairn-memory 스킬을 사용하세요. MEMORY.md는 짧은 색인으로, 상세 내용은 docs/memory/<domain>.md에 기록합니다.",
-    plan: "중요 구현 전에는 cairn-plan 스킬을 사용하세요. 모든 에이전트는 도메인 지식과 저장소 정책을 위해 프로젝트 루트 MEMORY.md를 먼저 읽어야 합니다. PLAN.md는 색인으로, 상세 계획은 docs/plan/<topic>.md에 기록하며 파일 변경 전 Light/Heavy Path 트리아지를 남깁니다.",
-    work: "계획이 있을 때만 cairn-work 스킬을 사용하세요. 모든 에이전트는 도메인 지식과 저장소 정책을 위해 프로젝트 루트 MEMORY.md를 먼저 읽어야 합니다. 기록된 Light/Heavy Path 경로로 하나의 모듈 조각을 실행하며 dry-run/check, 모듈, 표면 증거를 확보합니다.",
+    plan: "중요 구현 전에는 cairn-plan 스킬을 사용하세요. 모든 에이전트는 도메인 지식과 저장소 정책을 위해 프로젝트 루트 MEMORY.md를 먼저 읽어야 합니다. 먼저 전체 작업을 파악한 뒤 실행 가능한 task와 필요한 sub-task로 분류합니다. PLAN.md는 색인으로, 상세 계획은 docs/plan/<topic>.md에 기록하며 파일 변경 전 Light/Heavy Path 트리아지를 남깁니다.",
+    work: "계획이 있을 때만 cairn-work 스킬을 사용하세요. 모든 에이전트는 도메인 지식과 저장소 정책을 위해 프로젝트 루트 MEMORY.md를 먼저 읽어야 합니다. 기록된 Light/Heavy Path 경로로 하나의 모듈 작업을 실행하며 dry-run/check, 모듈, 표면 증거를 확보합니다. 작업 중 사용자가 곁가지 질문을 하면 짧게 답한 뒤, 명시적으로 일시중지/중단/작업 전환을 요청한 경우가 아니면 이전 active work를 계속합니다.",
     review: "cairn-review 스킬을 사용하세요. PLAN.md와 MEMORY.md 기준으로 증거를 비교합니다.",
     usage: "사용법: cairn install|upgrade|doctor|uninstall|init|memory|plan|work|review|toolcheck",
   },

package/skills/cairn-memory/SKILL.md

@@ -13,6 +13,8 @@ The root `MEMORY.md` is an index, not detailed knowledge. Record details in `doc
 
 Every delegated agent must read the project-root `MEMORY.md` before doing its assigned discovery, evidence, or update task.
 
+When subagent tools are available, each agent may recursively delegate bounded sub-tasks to subagents. Every child subagent must read the project-root `MEMORY.md`, keep the assigned scope, and preserve others' edits.
+
 ## Procedure
 
 1. Run `node scripts/cairn-state.mjs manual` if it exists. Otherwise ensure `MEMORY.md`, `PLAN.md`, `docs/memory`, and `docs/plan` directly.
@@ -20,6 +22,7 @@ Every delegated agent must read the project-root `MEMORY.md` before doing its as
 3. Delegate when it materially improves speed or quality instead of asking the user.
    - `explorer`: read-only domain discovery, boundaries, invariants, policies, contradictions, and stale facts when available.
    - `worker`: exact file paths, commands, schemas, references, and bounded evidence capture.
+   - Recursive subagent delegation is allowed only for bounded sub-tasks when the current surface supports it.
 4. Write detailed facts to `docs/memory/<domain>.md`.
 5. Keep only one-line links and summaries in `MEMORY.md`.
 6. Write user-visible output in the OS locale unless the user asks for another language.

package/skills/cairn-plan/SKILL.md

@@ -15,6 +15,8 @@ Every planning run starts by reading the project-root `MEMORY.md`. Treat it as t
 
 Do not treat planning as optional for implementation work that is more than a narrow single-file fix. If the current request can change behavior, architecture, data, external state, or multiple files, produce or update a plan artifact before mutation.
 
+Plan from the whole work down. First understand the full requested outcome and affected surfaces, then classify the work into small executable tasks. If one task is still too broad to verify cleanly, split that task into sub-tasks.
+
 ## Procedure
 
 1. Run `node scripts/cairn-state.mjs manual` if it exists. Otherwise ensure `MEMORY.md`, `PLAN.md`, `docs/memory`, and `docs/plan` directly.
@@ -24,16 +26,18 @@ Do not treat planning as optional for implementation work that is more than a na
 5. Run `node scripts/cairn.mjs toolcheck` when available, or `scripts/cairn-toolcheck.mjs` directly, to identify repository stacks and required tools.
 6. If LSP, typecheck, lint, dry-run, or verification tools are missing, run `node scripts/cairn.mjs toolcheck --install` or the closest repository-native install command before treating the tool as unavailable.
 7. Explore the repository with focused search and LSP/symbol tools after tool readiness is confirmed.
-8. Identify the closest available dry-run or check mode for every slice that can mutate external state.
-9. Run complexity triage before applying workflow guidance from agents, plugins, or delegated roles. Record the route before any implementation slice.
-10. Delegate according to the selected path and model guidance instead of asking the user.
+8. Summarize the whole work and affected surfaces, then classify the plan into small executable tasks. Use sub-tasks only when a task needs further breakdown to be verifiable.
+9. Identify the closest available dry-run or check mode for every task that can mutate external state.
+10. Run complexity triage before applying workflow guidance from agents, plugins, or delegated roles. Record the route before any implementation task.
+11. Delegate according to the selected path and model guidance instead of asking the user.
    - Use `explorer` for independent read-only codebase discovery, impact analysis, pattern searches, and read-only verification that can run in parallel when the current tool list supports it.
-   - Use `worker` for bounded implementation slices with clear file ownership, disjoint write scope, or verification tasks that can run while the main session continues.
+   - Use `worker` for bounded implementation tasks with clear file ownership, disjoint write scope, or verification tasks that can run while the main session continues.
+   - When subagent tools are available, each agent may recursively delegate bounded sub-tasks to subagents, subject to the current surface's depth and concurrency limits.
    - Keep urgent blocking work local when the next step depends immediately on the result.
-   - Tell every delegated agent to read the project-root `MEMORY.md` before work, and tell workers they are not alone in the codebase and must not revert others' edits.
-11. Create `docs/plan/<topic>.md` from `templates/work-plan.md`.
-12. Add a short index entry to `PLAN.md`.
-13. Write user-visible output in the OS locale unless the user asks for another language.
+   - Tell every delegated agent and child subagent to read the project-root `MEMORY.md` before work, keep scope, and tell workers they are not alone in the codebase and must not revert others' edits.
+12. Create `docs/plan/<topic>.md` from `templates/work-plan.md`.
+13. Add a short index entry to `PLAN.md`.
+14. Write user-visible output in the OS locale unless the user asks for another language.
 
 ## Complexity Triage
 
@@ -93,15 +97,18 @@ Heavy Path flow: plan -> pre-implementation review -> bounded `worker` implement
 ## Planning Rules
 
 - Every plan must be decision-complete.
+- Every plan must describe the whole work first, then classify it into executable tasks and any needed sub-tasks.
+- Every plan must allow recursive subagent delegation for bounded sub-tasks when the current agent surface supports it.
 - Every plan must include complexity triage and the selected path.
 - Every plan must explicitly list Heavy Path signals checked, even when Light Path is selected.
 - Every plan must include applied model guidance and rationale.
 - Every plan must include tool readiness results: detected stack, required LSP/check tools, installed tools, and blockers.
-- Every implementation slice must be small enough to verify with two checks.
+- Every implementation task must be small enough to verify with two checks.
+- Heavy Path tasks must include an explicit automated test command and a `Tests:` evidence line; Heavy Path completion cannot rely on generic verification wording without test evidence.
 - The default checks are module acceptance verification and surface integration verification.
-- Every risky or external-state-changing slice must include the closest available dry-run or check command before the write/apply command.
+- Every risky or external-state-changing task must include the closest available dry-run or check command before the write/apply command.
 - Verification can expand for risk, but the reason must be recorded.
-- The default loop budget is two verification passes per slice. If a gate fails, diagnose once, shrink or split the slice, and rerun both gates. After two failed passes, record the blocker in `docs/plan/<topic>.md` instead of continuing an open-ended loop.
+- The default loop budget is two verification passes per task. If a gate fails, diagnose once, shrink the task or split it into sub-tasks, and rerun both gates. After two failed passes, record the blocker in `docs/plan/<topic>.md` instead of continuing an open-ended loop.
 - Ask the user only when agents, repository evidence, or local verification cannot answer the decision.
 - User-visible text must follow the OS locale unless the user asks for another language.
 
@@ -132,13 +139,13 @@ Prefer repository-native dry-run and check modes before mutating external state.
 TASK: Produce <role> input needed for the <topic> plan.
 EXPECTED OUTCOME: Return concrete decisions, file paths, dependencies, risks, and evidence requirements.
 REQUIRED TOOLS: Read-only repository exploration, tool readiness checks, LSP/symbol tools, local command checks.
-MUST DO: Read the project-root `MEMORY.md` before doing assigned work. Preserve proper nouns exactly. Prefer repository evidence. Install or bootstrap missing required tools before declaring them unavailable. Identify assumptions. Use `explorer` for read-only discovery and `worker` for bounded implementation or verification when available and useful. Tell every delegated agent to read the project-root `MEMORY.md` before work. Tell workers they are not alone in the codebase and must not revert others' edits. Use the OS locale for user-visible text.
-MUST NOT DO: Edit production code. Ask the user. Expand scope.
+MUST DO: Read the project-root `MEMORY.md` before doing assigned work. Preserve proper nouns exactly. Prefer repository evidence. Install or bootstrap missing required tools before declaring them unavailable. Identify assumptions. Use `explorer` for read-only discovery and `worker` for bounded implementation or verification when available and useful. When subagent tools are available, allow recursive delegation of bounded sub-tasks. Tell every delegated agent and child subagent to read the project-root `MEMORY.md` before work. Tell workers they are not alone in the codebase and must not revert others' edits. Use the OS locale for user-visible text.
+MUST NOT DO: Edit production code. Ask the user. Expand scope. Delegate vague or unbounded work.
 CONTEXT: User request, MEMORY.md, relevant docs/memory notes, applied model guidance, repository root.
 ```
 
 ## Completion Criteria
 
 - `PLAN.md` references the plan topic.
-- `docs/plan/<topic>.md` includes goal, memory inputs, model guidance, tool readiness, complexity triage, selected path, agent assignments, module slices, and two checks per slice.
+- `docs/plan/<topic>.md` includes goal, memory inputs, model guidance, tool readiness, complexity triage, selected path, agent assignments, module tasks, and two checks per task.
 - The next implementation task can run without making planning decisions.

package/skills/cairn-review/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: cairn-review
-description: Review completed Cairn slices against MEMORY.md, PLAN.md, domain policy, and two-gate evidence.
+description: Review completed Cairn tasks against MEMORY.md, PLAN.md, domain policy, and two-gate evidence.
 ---
 
 # Cairn Review
@@ -9,18 +9,21 @@ Use this after meaningful implementation with Cairn.
 
 ## Purpose
 
-Review is not another implementation loop. Confirm that the completed slice satisfies the plan and that memory and plan artifacts are useful to the next agent.
+Review is not another implementation loop. Confirm that the completed task satisfies the plan and that memory and plan artifacts are useful to the next agent.
 
 Every review run and every delegated review agent must read the project-root `MEMORY.md` before doing assigned work.
 
+When subagent tools are available, each agent may recursively delegate bounded review sub-tasks to subagents. Every child subagent must read the project-root `MEMORY.md`, keep the assigned scope, and preserve others' edits.
+
 ## Procedure
 
-1. Read the completed slice in `docs/plan/<topic>.md`.
+1. Read the completed task in `docs/plan/<topic>.md`.
 2. Read `MEMORY.md` and relevant `docs/memory/*.md`.
 3. Check changed files, tool readiness evidence, and evidence paths.
 4. Delegate independent review when it materially improves speed or quality and the current tool policy allows it.
    - Use `explorer` for read-only impact analysis, pattern checks, and independent diff inspection.
    - Use `worker` for scoped verification command re-runs or QA artifact capture.
+   - Recursive subagent delegation is allowed only for bounded sub-tasks when the current surface supports it.
    - Keep blocking review work local when the next step depends immediately on the result.
 5. Report findings first, ordered by severity, with file and line references. If there are no issues, say so clearly and record remaining test gaps or residual risk.
 6. Write user-visible output in the OS locale unless the user asks for another language.
@@ -28,7 +31,7 @@ Every review run and every delegated review agent must read the project-root `ME
 ## Reviewer Prompt Format
 
 ```text
-TASK: Review correctness, scope, and evidence for slice <slice-id>.
+TASK: Review correctness, scope, and evidence for task <task-id>.
 EXPECTED OUTCOME: Findings ordered by severity with file and line references, or an explicit no-issue result with residual risk.
 REQUIRED TOOLS: Read-only diff inspection, tool readiness checks, verification command execution, plan/memory reading.
 MUST DO: Read the project-root `MEMORY.md` before doing assigned work. Check tool readiness and install-attempt evidence. Check dry-run or check evidence when external state could change. Check both module evidence and surface evidence. Preserve proper nouns exactly. Use the OS locale for user-visible text.

package/skills/cairn-work/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: cairn-work
-description: Use after cairn-plan to execute the next incomplete docs/plan module slice with the recorded Light/Heavy Path route, bounded worker delegation, dry-run/check evidence, and two verification gates.
+description: Use after cairn-plan to execute the next incomplete docs/plan module task with the recorded Light/Heavy Path route, bounded worker delegation, dry-run/check evidence, and two verification gates.
 ---
 
 # Cairn Work
@@ -9,38 +9,44 @@ Use this to implement a plan created by `cairn-plan`. Do not use this as a short
 
 ## Purpose
 
-Execute only one module slice at a time. Instead of a repeated red-green loop, prove a small slice with two strong verification gates.
+Execute only one module task at a time. Instead of a repeated red-green loop, prove a small task with two strong verification gates.
 
-Every work run starts by reading the project-root `MEMORY.md` before choosing or executing a slice. Every delegated agent must also read the project-root `MEMORY.md` before doing its assigned task.
+Every work run starts by reading the project-root `MEMORY.md` before choosing or executing a task. Every delegated agent must also read the project-root `MEMORY.md` before doing its assigned task.
+
+If the user asks a side question, status question, or narrow clarification while the selected task is still active, answer it briefly and then resume the previous active work unless the user explicitly asks to pause, stop, or switch tasks.
+
+When subagent tools are available, each agent may recursively delegate bounded sub-tasks to subagents. Every child subagent must read the project-root `MEMORY.md`, keep the assigned scope, and preserve others' edits.
 
 ## Procedure
 
 1. Read the project-root `MEMORY.md` first.
 2. Read `PLAN.md`, the selected `docs/plan/<topic>.md`, and relevant memory notes.
 3. Read the `docs/model-guidance/*.md` inputs recorded in the plan.
-4. Select the first incomplete module slice.
+4. Select the first incomplete module task.
 5. Confirm that required LSP, typecheck, lint, dry-run, and verification tools are available from the plan's tool readiness section.
 6. If a required tool is missing, run `node scripts/cairn.mjs toolcheck --install` or the closest repository-native install command, then rerun the tool before continuing.
 7. Confirm the selected Light Path or Heavy Path in the plan. If the plan lacks complexity triage, stop and update the plan before mutating files.
 8. For Light Path, implement directly or delegate to one bounded `worker`; keep the verification gate.
 9. For Heavy Path, follow the full planning and review pipeline recorded in the plan. Run pre-implementation review before mutation and read-only review after evidence exists.
-10. Delegate implementation to `worker` with exact files, ownership, constraints, and model-specific adjustment rules. Tell every delegated agent to read the project-root `MEMORY.md` before work. Use `explorer` for parallel read-only discovery or verification when available and useful.
-11. Before mutating external state, run the slice dry-run or check command when one is recorded. If none exists, record the absence and continue with the smallest reversible command available.
-12. `worker` must return changed files, tool readiness result, dry-run or check result when applicable, module acceptance command and result, surface integration command or QA artifact, and cleanup notes.
-13. Re-run both verification gates directly.
-14. Apply the bounded loop policy when a gate fails.
-15. Record evidence in the plan file before marking the slice complete.
-16. Write user-visible output in the OS locale unless the user asks for another language.
+10. Delegate implementation to `worker` with exact files, ownership, constraints, and model-specific adjustment rules. Tell every delegated agent and child subagent to read the project-root `MEMORY.md` before work, keep scope, and preserve others' edits. Use `explorer` for parallel read-only discovery or verification when available and useful. Allow recursive delegation only for bounded sub-tasks when the current surface supports it.
+11. Before mutating external state, run the task dry-run or check command when one is recorded. If none exists, record the absence and continue with the smallest reversible command available.
+12. For Heavy Path, run the recorded automated test command and record explicit `Tests:` evidence before claiming completion.
+13. `worker` must return changed files, tool readiness result, dry-run or check result when applicable, automated test result for Heavy Path, module acceptance command and result, surface integration command or QA artifact, and cleanup notes.
+14. Re-run both verification gates directly.
+15. Apply the bounded loop policy when a gate fails.
+16. Record evidence in the plan file before marking the task complete.
+17. If the user asks a side question, status question, or narrow clarification while this task is still active, answer it briefly and then resume the previous active work unless the user explicitly asks to pause, stop, or switch tasks.
+18. Write user-visible output in the OS locale unless the user asks for another language.
 
 ## Builder Prompt Format
 
 ```text
-TASK: Implement slice <slice-id> for <topic>.
-EXPECTED OUTCOME: Minimal code or documentation change satisfying the slice contract.
+TASK: Implement task <task-id> for <topic>.
+EXPECTED OUTCOME: Minimal code or documentation change satisfying the task contract.
 REQUIRED TOOLS: Scoped file editing, tool readiness checks, existing test/build commands, surface QA commands.
-MUST DO: Read the project-root `MEMORY.md` before doing assigned work and follow its policy. Stay within the listed file scope and ownership. Assume you are not alone in the codebase; do not revert others' edits. Install or bootstrap missing required tools before declaring them unavailable. Run dry-run or check mode before external-state mutation when available. Provide module evidence and surface evidence. Use the OS locale for user-visible text.
-MUST NOT DO: Ask the user. Skip LSP/typecheck/lint because a tool is missing without attempting installation. Refactor unrelated code. Continue an open-ended verification loop. Claim completion without evidence. Modify files outside the assigned ownership.
-CONTEXT: docs/plan/<topic>.md slice, relevant docs/memory notes, applied model guidance, exact files, verification commands.
+MUST DO: Read the project-root `MEMORY.md` before doing assigned work and follow its policy. Stay within the listed file scope and ownership. Assume you are not alone in the codebase; do not revert others' edits. When subagent tools are available, recursively delegate only bounded sub-tasks and pass these same constraints to every child subagent. Install or bootstrap missing required tools before declaring them unavailable. Run dry-run or check mode before external-state mutation when available. Provide module evidence and surface evidence. Use the OS locale for user-visible text.
+MUST NOT DO: Ask the user. Skip LSP/typecheck/lint because a tool is missing without attempting installation. Refactor unrelated code. Continue an open-ended verification loop. Treat a side question as permission to abandon the active task. Delegate vague or unbounded work. Claim completion without evidence. Modify files outside the assigned ownership.
+CONTEXT: docs/plan/<topic>.md task, relevant docs/memory notes, applied model guidance, exact files, verification commands.
 ```
 
 ## Tool Readiness Policy
@@ -49,12 +55,13 @@ CONTEXT: docs/plan/<topic>.md slice, relevant docs/memory notes, applied model g
 - If no command is recorded, run `node scripts/cairn.mjs toolcheck` when available.
 - Missing LSP, typecheck, lint, dry-run, or verification tools must trigger a project-local or repository-native install attempt.
 - After installation, rerun the exact tool command and record evidence.
-- If installation fails, stop the slice and record the blocker rather than silently falling back to less precise exploration.
+- If installation fails, stop the task and record the blocker rather than silently falling back to less precise exploration.
 
 ## Two Verification Gates
 
 - Module acceptance: targeted unit, typecheck, lint, parser, schema, or command that proves the module contract.
 - Surface integration: HTTP, browser, CLI, tmux, desktop, or parsed artifact evidence proving behavior through the real surface.
+- Heavy Path test gate: run an explicit automated test command and record it as `Tests:` evidence in the plan. This is required even when module acceptance uses a broader check command.
 
 ## Dry-Run Policy
 
@@ -68,16 +75,17 @@ Run the closest available dry-run or check mode before commands that mutate exte
 
 ## Bounded Loop Policy
 
-- Run at most two verification passes per slice by default.
-- If a gate fails, diagnose the cause once, shrink or split the slice, then rerun both gates.
-- After two failed passes, stop implementation for the slice and record the blocker in `docs/plan/<topic>.md`.
+- Run at most two verification passes per task by default.
+- If a gate fails, diagnose the cause once, shrink the task or split it into sub-tasks, then rerun both gates.
+- After two failed passes, stop implementation for the task and record the blocker in `docs/plan/<topic>.md`.
 - Do not imitate repeated red-green loops unless the plan explicitly records a risk-based reason.
 
 ## Completion Criteria
 
 - Both verification gates passed in the current turn.
+- Heavy Path work has explicit automated test evidence in the current plan.
 - Required LSP/check/verification tools were available, installed, or recorded as blockers with attempted commands.
-- Dry-run or check evidence exists when the slice could mutate external state, or the plan records why no dry-run exists.
+- Dry-run or check evidence exists when the task could mutate external state, or the plan records why no dry-run exists.
 - The required Light Path or Heavy Path flow was followed.
 - The model guidance recorded in the plan was applied.
 - Evidence was recorded in `docs/plan/<topic>.md`.

package/templates/PLAN.md

@@ -6,6 +6,7 @@ Short index of work plans. Link detailed plans under `docs/plan/`.
 
 - Detect repository stack and required LSP/check tools before implementation.
 - Install or bootstrap missing required tools before declaring them unavailable.
+- Heavy Path completion requires explicit automated test evidence.
 - Record tool readiness, dry-run/check evidence, module acceptance evidence, and surface integration evidence in detailed plans.
 
 ## Active Plans

package/templates/work-plan.md

@@ -4,6 +4,13 @@
 
 Describe the observable result.
 
+## Whole Work
+
+- Outcome:
+- Affected surfaces:
+- Task classification:
+- Sub-tasks, if needed:
+
 ## Memory Inputs
 
 - `MEMORY.md`
@@ -44,7 +51,7 @@ Describe the observable result.
 ## Agent Assignments
 
 - `explorer`: read-only discovery, impact analysis, pattern search, and read-only verification when available.
-- `worker`: bounded implementation slices with clear file ownership, or scoped verification work.
+- `worker`: bounded implementation tasks with clear file ownership, or scoped verification work.
 - Local main session: urgent blocking work when the next step depends immediately on the result.
 
 ## Tool Readiness
@@ -61,14 +68,15 @@ Describe the observable result.
 
 - Dry-run or check mode before external-state mutation:
 - No dry-run available, if applicable:
-- Verification loop budget: two passes per slice by default.
-- Failure handling: diagnose once, shrink or split the slice, rerun both gates, then record a blocker after the second failed pass.
+- Verification loop budget: two passes per task by default.
+- Failure handling: diagnose once, shrink the task or split it into sub-tasks, rerun both gates, then record a blocker after the second failed pass.
 
-## Module Slices
+## Module Tasks
 
-### Slice 1: <module>
+### Task 1: <module>
 
 - Contract:
+- Sub-tasks, if needed:
 - Files:
 - Dependencies:
 - Tool readiness requirement:
@@ -80,6 +88,7 @@ Describe the observable result.
 
 - Dry-run or check:
 - Tool readiness:
+- Tests:
 - Module acceptance:
 - Surface integration:
 - Verification pass count: