@codemap-ai/cli 0.1.0

package/.claude-plugin/plugin.json

@@ -0,0 +1,12 @@
+{
+  "name": "codemap-agent-pack",
+  "description": "CodeMap MCP-first skills and workflows for Claude Code.",
+  "version": "1.0.0",
+  "author": {
+    "name": "CodeMap"
+  },
+  "homepage": "https://codemap.dev",
+  "repository": "https://github.com/trieuluan/codemap",
+  "license": "MIT",
+  "keywords": ["codemap", "mcp", "skills", "workflow", "codebase"]
+}

package/.codex-plugin/plugin.json

@@ -0,0 +1,35 @@
+{
+  "name": "codemap-agent-pack",
+  "version": "1.0.0",
+  "description": "CodeMap MCP-first workflows, skills, and rules for token-efficient codebase exploration.",
+  "author": {
+    "name": "CodeMap"
+  },
+  "homepage": "https://codemap.dev",
+  "repository": "https://github.com/trieuluan/codemap",
+  "license": "MIT",
+  "keywords": [
+    "codemap",
+    "mcp",
+    "codebase",
+    "skills",
+    "workflow",
+    "context"
+  ],
+  "skills": "./agent-pack/skills/",
+  "interface": {
+    "displayName": "CodeMap Agent Pack",
+    "shortDescription": "MCP-first codebase workflows for CodeMap",
+    "longDescription": "Use CodeMap Agent Pack to guide coding agents through MCP-first exploration, feature investigation, symbol debugging, CodeMap output interpretation, safe edits, reimport, and token-efficient review.",
+    "developerName": "CodeMap",
+    "category": "Coding",
+    "capabilities": ["Interactive", "Read", "Write"],
+    "defaultPrompt": [
+      "Use CodeMap to investigate this feature area.",
+      "Use CodeMap MCP-first workflow before editing this codebase."
+    ],
+    "websiteURL": "https://codemap.dev",
+    "brandColor": "#2563EB",
+    "screenshots": []
+  }
+}

package/.cursor-plugin/plugin.json

@@ -0,0 +1,16 @@
+{
+  "name": "codemap-agent-pack",
+  "displayName": "CodeMap Agent Pack",
+  "description": "CodeMap MCP-first skills, rules, and commands for Cursor.",
+  "version": "1.0.0",
+  "author": {
+    "name": "CodeMap"
+  },
+  "homepage": "https://codemap.dev",
+  "repository": "https://github.com/trieuluan/codemap",
+  "license": "MIT",
+  "keywords": ["codemap", "mcp", "skills", "workflow", "codebase"],
+  "skills": "./agent-pack/skills/",
+  "agents": "./agent-pack/agents/",
+  "commands": "./agent-pack/commands/"
+}

package/agent-pack/README.md

@@ -0,0 +1,44 @@
+# CodeMap Agent Pack
+
+CodeMap Agent Pack is a workflow layer for AI coding agents. It teaches agents to use CodeMap MCP as a context engine before reading raw files.
+
+It includes skills, rules, agent roles, plugin metadata, and installer templates for Codex, Claude, Cursor, Gemini, OpenCode, and GitHub Copilot CLI style workflows.
+
+For broad tasks, agents should choose the narrowest CodeMap context tool first: `explore_task` when files are unclear, `search_codebase` for known names, `find_related_files` for related-file questions, or `get_file` for known paths.
+
+Install locally with:
+
+```bash
+codemap init-agent-pack --target all
+```
+
+Install one target:
+
+```bash
+codemap init-agent-pack --target codex
+codemap init-agent-pack --target claude
+codemap init-agent-pack --target cursor
+codemap init-agent-pack --target gemini
+codemap init-agent-pack --target opencode
+codemap init-agent-pack --target copilot
+```
+
+Print the local plugin root path:
+
+```bash
+codemap agent-pack-path
+```
+
+Register a local Codex-style marketplace entry:
+
+```bash
+codemap init-agent-pack --target marketplace --plugin-path ./packages/mcp-server
+```
+
+Preview or test in another directory:
+
+```bash
+codemap init-agent-pack --target all --root /path/to/project --dry-run
+```
+
+Official `/plugin install codemap-agent-pack` requires later marketplace publishing. This pack provides the local/plugin-compatible assets first.

package/agent-pack/agents/codemap-explorer.md

@@ -0,0 +1,12 @@
+# CodeMap Explorer Agent
+
+Use this agent role for codebase orientation tasks.
+
+Responsibilities:
+
+- Start with CodeMap MCP tools.
+- Return compact file shortlists with reasons.
+- Prefer outlines and symbol context over full files.
+- Identify entrypoints, services, shared schema/types, and verification targets.
+
+Do not edit files in this role.

package/agent-pack/commands/feature-area.md

@@ -0,0 +1,8 @@
+# Feature Area Command
+
+Suggested prompt:
+
+```text
+Use CodeMap to summarize the feature area for: <query>.
+Return the recommended read order, primary files, secondary matches, and next tool calls.
+```

package/agent-pack/rules/install.md

@@ -0,0 +1,35 @@
+# Installing CodeMap Agent Pack
+
+The Agent Pack is bundled with `@codemap/cli`.
+
+Use:
+
+```bash
+codemap init-agent-pack --target codex
+codemap init-agent-pack --target claude
+codemap init-agent-pack --target cursor
+codemap init-agent-pack --target gemini
+codemap init-agent-pack --target opencode
+codemap init-agent-pack --target copilot
+codemap init-agent-pack --target all
+codemap init-agent-pack --target marketplace --plugin-path ./packages/mcp-server
+```
+
+Add `--dry-run` to preview writes. Add `--force` to overwrite existing files.
+Add `--root <path>` to install into a specific project directory for testing or scripted setup.
+
+After install, verify the harness files and skills:
+
+```bash
+codemap doctor-agent-pack --target auto
+```
+
+The installer writes workflow rules and skills for the chosen agent harness. Conflicting files are backed up unless `--force` is used.
+
+Codex installs `AGENTS.md`, `.codex/codemap-agent-pack.md`, and CodeMap skills under `.codex/skills/codemap-*`.
+Claude installs `CLAUDE.md`, `.claude/rules/codemap-*`, and CodeMap skills under `.claude/skills/codemap-*`.
+Cursor installs `.cursor/rules/codemap.mdc` with MCP-first, lifecycle, and workflow-skill routing guidance.
+
+For broad implementation/debug/review/refactor/test/research work, installed guidance tells agents to use CodeMap context tools before editing and to follow the relevant skills, hard gates, artifact templates, and verification checks.
+
+Use `codemap agent-pack-path` to print the local plugin root path for Codex-style plugin registration.

package/agent-pack/rules/mcp-first.md

@@ -0,0 +1,18 @@
+# CodeMap MCP-First Rule
+
+When CodeMap MCP is available, use CodeMap tools before raw file reads or grep.
+
+## Default Tool Routing
+
+- New CodeMap session: `get_project`.
+- Broad task: `explore_task`.
+- Related-file question: `find_related_files`.
+- Known symbol/file/export: `search_codebase`.
+- Several candidates: `get_file`.
+- Specific body: `symbol`.
+- Impact analysis: `symbol`.
+- After edits: `diff(mode="working")`, build/test, then reimport when needed.
+
+Read MCP output in this order: summary, ranked files/symbols, score reasons, next steps, and resource URIs. Expand to raw files only when the ranked context is not enough to answer or edit safely.
+
+Raw reads and grep are fallback tools for unindexed files, dynamic searches, or MCP gaps.

package/agent-pack/rules/task-lifecycle.md

@@ -0,0 +1,11 @@
+# CodeMap Task Lifecycle
+
+1. Orient with `get_project`.
+2. Explore with the narrowest useful CodeMap tool.
+3. Read outlines and symbol bodies before full files.
+4. Edit only the files needed for the task.
+5. Verify with the smallest sufficient build/test.
+6. Inspect the diff.
+7. Call `refresh_local_index` after local edits.
+8. Call `reimport` only when cloud graph/insights should refresh.
+9. Summarize changes, verification, blockers, and remaining risks.

package/agent-pack/rules/workflow-skills.md

@@ -0,0 +1,97 @@
+# CodeMap Workflow Skills
+
+## Start Here: Context Routing
+
+For broad work, choose the narrowest CodeMap context tool before implementing. Use `explore_task` when files are unclear, `search_codebase` for known names, `find_related_files` for related-file questions, and `get_file` for known paths.
+
+## Brainstorming (design before code)
+
+For new features or vague requirements, design first — never write production code before the design is approved.
+
+1. Call `explore_task` to gather real codebase context.
+2. Ask clarifying questions one at a time until scope is clear.
+3. Propose 2–3 approaches with trade-offs, referencing real files from CodeMap.
+4. Write a design doc (`docs/specs/YYYY-MM-DD-<topic>.md`) covering goal, approach, affected files, and open questions.
+5. Self-review the spec, then wait for user approval before touching any file.
+
+## Test-Driven Development
+
+For new functionality or bug fixes, follow RED → GREEN → REFACTOR strictly.
+
+- **RED**: `search_codebase("test <feature>")` to find patterns, write a minimal failing test, run with the host agent test runner and confirm it **fails**.
+- **GREEN**: Use `symbol` to read the target, implement only the minimum to pass, run with the host agent test runner and confirm it **passes**.
+- **REFACTOR**: Clean up, run the host agent test runner again, then call `diff(mode="working")` before declaring done.
+
+No production code before a failing test exists.
+
+## Writing Plans
+
+Use after a design is approved and before implementation begins.
+
+1. Re-ground with CodeMap using the narrowest context tool for the task.
+2. Use `codemap://agent-pack/templates/implementation-plan`.
+3. Write exact steps, files/modules, interfaces, edge cases, and verification commands.
+4. Remove decisions from the implementer; record assumptions explicitly.
+5. Wait for approval when the task is high-risk or product-facing.
+
+## Executing Plans
+
+Use when implementing an approved plan.
+
+1. Call `diff(mode="working")` before edits and preserve unrelated user changes.
+2. Execute one plan step at a time.
+3. If reality contradicts the plan, revise the plan instead of broad improvisation.
+4. Run planned verification, inspect diff, then refresh local index.
+
+## Verification Before Completion
+
+Use after every file-changing task.
+
+1. Call `diff(mode="working")`.
+2. Run the smallest relevant build/test command.
+3. Call `refresh_local_index` after local edits.
+4. Decide whether `reimport` and `reimport(wait=true)` are needed for cloud graph/insights.
+5. Report changed behavior, verification results, skipped checks, and residual risk.
+
+## Feature Area Investigation
+
+Use when the task involves a named feature (billing, auth, admin, graph, etc.).
+
+1. Call `explore_task(query)` — review likely files, entrypoints, and recommended reads.
+2. Call `get_file(path=[...])` on the top results to survey outlines without loading full files.
+3. Use `symbol` for the most relevant component, service, or controller.
+4. If still unclear, call `find_related_files` anchored to the best file found.
+
+## Symbol-Level Debugging
+
+Use when a bug or behavior centers on a specific function, class, component, or method.
+
+1. `search_codebase(symbol_name)` if the file is unknown.
+2. `symbol(action="context", symbol_name, file_path)` for the exact body.
+3. `symbol` when call flow or impact matters.
+4. Read only adjacent files needed to explain or change the behavior.
+
+Do not read an entire large file to inspect one symbol when CodeMap can return symbol context.
+
+## Interpreting CodeMap Output
+
+After any CodeMap tool returns ranked files, symbols, or related files:
+
+1. Read the summary first — decide if it is enough to act before expanding.
+2. Prefer high-ranked results before low-ranked ones.
+3. Follow `nextSteps`, `resourceUris`, and suggested tool calls before opening raw files.
+4. Use ranking signals to filter: exact path/symbol match = strong; fuzzy keyword = weak.
+5. Stop expanding context once the edit or answer is grounded enough.
+
+When results look weak or noisy, refine the query, anchor to a known file or symbol, or switch tool.
+
+## Token-Efficient Code Review
+
+Use when reviewing changes in a CodeMap-indexed repository.
+
+1. Start with `diff(mode="working")` or `diff(mode="refs")`.
+2. For changed symbols, use `symbol` instead of full-file reads.
+3. Use `symbol` for risky public API or shared behavior changes.
+4. Lead findings by severity. Mention test gaps and residual risk.
+
+Review behavior and integration risks — avoid summarizing broad context unless it supports a finding.

package/agent-pack/skills/brainstorming/SKILL.md

@@ -0,0 +1,41 @@
+# Brainstorming
+
+Use this skill when the user describes a new feature, a vague requirement, or says "design X", "plan X", or "how should we approach X". Do not write any code until the design is approved.
+
+## Hard Gate
+
+**Never write production code before completing this skill.** The design must be written and approved first, even for simple tasks.
+
+## Process
+
+1. **Gather real context with CodeMap**
+   - `explore_task("feature or problem description")` — get likely files, entrypoints, risks
+   - `get_project_insights()` — understand codebase size, language breakdown, patterns
+
+2. **Ask clarifying questions** — one at a time, stop when the scope is unambiguous:
+   - What is the expected input and output?
+   - What edge cases or failure modes matter?
+   - Are there existing patterns in the codebase to follow?
+
+3. **Propose 2–3 approaches** with real file references from step 1:
+   - State the trade-offs (complexity, blast radius, consistency with existing patterns)
+   - Use `find_related_files` or `get_file(include=["outline"])` to back claims
+
+4. **Write a design doc** to `docs/specs/YYYY-MM-DD-<topic>.md`:
+   - Goal and non-goals
+   - Chosen approach and why
+   - Files to create/modify (with paths from CodeMap)
+   - Data flow or API contract
+   - Open questions
+
+5. **Self-review the spec** — check for missing edge cases, unclear interfaces, or scope creep
+
+6. **Wait for user approval** before proceeding to implementation
+
+## After Approval
+
+Invoke the task-lifecycle workflow: explore → confirm edit plan → implement → verify → diff → reimport.
+
+## Rule
+
+If the user skips design and asks to implement directly, acknowledge the risk and offer a one-paragraph lightweight design summary before touching any file.

package/agent-pack/skills/executing-plans/SKILL.md

@@ -0,0 +1,26 @@
+# Executing Plans
+
+Use this skill when implementing an approved plan. Follow the plan in order and keep the edit surface narrow.
+
+## Process
+
+1. **Before edits**
+   - Read the approved plan.
+   - Call `diff(mode="working")` and note unrelated dirty files.
+   - Read only the CodeMap context needed for the next step.
+
+2. **During implementation**
+   - Execute one logical plan step at a time.
+   - Keep behavior and file ownership aligned with the plan.
+   - If reality contradicts the plan, pause to revise the plan instead of improvising a broad rewrite.
+
+3. **After edits**
+   - Run the planned checks.
+   - Call `diff(mode="working")` to inspect the actual changed files.
+   - Use `refresh_local_index` after local edits.
+   - Use `reimport` only when cloud graph, web insights, or paid cloud indexing should refresh.
+
+## Rule
+
+Do not declare completion until `verification-before-completion` is satisfied.
+

package/agent-pack/skills/feature-area-investigation/SKILL.md

@@ -0,0 +1,15 @@
+# Feature Area Investigation
+
+Use this skill for feature questions like billing, auth redirect, admin project detail, import history, or graph canvas.
+
+## Process
+
+1. Call `explore_task(query)`.
+2. Review likely files, entrypoints, and recommended reads.
+3. Call the suggested `get_file(path=[...])` to inspect outlines without loading full files.
+4. Use `symbol` for the most relevant component/service/controller.
+5. If the area is still unclear, call `find_related_files` with the best anchor file.
+
+## Output Expectation
+
+Identify primary entrypoints, backend services/routes, frontend components/API clients, shared schema/types, and any secondary matches.

package/agent-pack/skills/interpreting-codemap-output/SKILL.md

@@ -0,0 +1,29 @@
+# Interpreting CodeMap Output
+
+Use this skill after a CodeMap MCP tool returns ranked files, symbol context, related files, usages, callers, workflow guidance, or diff output.
+
+## Reading Order
+
+1. Read the summary first and decide whether the result is enough to act.
+2. Prefer high-ranked files and symbols before expanding to lower-ranked matches.
+3. Follow `nextSteps`, `resourceUris`, and related tool hints before opening raw files.
+4. Treat snippets, outlines, symbol ranges, and score reasons as filters, not as a full substitute for code needed before editing.
+
+## Token Discipline
+
+- Use `get_file` for several candidate files instead of opening each file.
+- Use `symbol` for a known function, component, class, or method body.
+- Use `get_file` with line ranges when the tool output points to a precise span.
+- Stop expanding context once the edit or answer is grounded enough.
+
+## Ranking Signals
+
+- Strong signals: exact file path, exact symbol name, direct export, direct import, caller/callee, route/API handler match.
+- Medium signals: feature-area summary rank, related-file edge, same directory, shared service/component.
+- Weak signals: fuzzy name match, generic loading/error files, broad utility files, low-score keyword-only hits.
+
+When results look weak or noisy, refine the query, anchor it to a file or symbol, or switch from feature search to symbol/file search.
+
+## Before Answering
+
+Mention only the CodeMap result details that changed the decision: selected files, key symbols, and whether more raw reading was needed.

package/agent-pack/skills/mcp-first-exploration/SKILL.md

@@ -0,0 +1,10 @@
+# MCP-First Exploration
+
+Use this skill when the task starts with unclear files, a broad bug/feature request, or a question like "where should I look?"
+
+## Process
+
+1. Ask CodeMap for a ranked shortlist using the narrowest fitting tool.
+2. Read outlines before full files.
+3. Prefer symbol bodies over whole-file reads.
+4. Fall back to raw search only for unindexed files, dynamic string searches, or MCP gaps.

package/agent-pack/skills/safe-edit-and-reimport/SKILL.md

@@ -0,0 +1,18 @@
+# Safe Edit And Reimport
+
+Use this skill when making code changes in a CodeMap-indexed repository.
+
+## Process
+
+1. Narrow the affected files with CodeMap before editing.
+2. Keep edits scoped to the user request and existing local patterns.
+3. Run the smallest sufficient build/test:
+   - shared package changes before API/web consumers.
+   - API build/tests for backend behavior.
+   - web build/tests for frontend behavior.
+4. Call `diff(mode="working")` or use git diff to review scope.
+5. Call `refresh_local_index` after local code/index/rule changes. Call `reimport` and `reimport(wait=true)` only when cloud/web graph and insights should refresh or when asked.
+
+## Rule
+
+Never declare the task complete without saying what was verified or why verification was skipped.

package/agent-pack/skills/symbol-level-debugging/SKILL.md

@@ -0,0 +1,15 @@
+# Symbol-Level Debugging
+
+Use this skill when a bug or behavior centers on a specific function, class, component, method, or export.
+
+## Process
+
+1. Call `search_codebase` with the symbol name if the file is unknown.
+2. Call `symbol(action="context", symbol_name, file_path?)` for the exact body.
+3. Call `symbol` when impact or call flow matters.
+4. Read only the adjacent files needed to explain or change behavior.
+5. After editing, run targeted verification and inspect the diff.
+
+## Rule
+
+Do not read an entire large file just to inspect one symbol when CodeMap can return symbol context.

package/agent-pack/skills/test-driven-development/SKILL.md

@@ -0,0 +1,36 @@
+# Test-Driven Development
+
+Use this skill when implementing new functionality or fixing a bug where tests are expected. Follow the RED → GREEN → REFACTOR cycle strictly.
+
+## Hard Gate
+
+**No production code before a failing test.** If you write implementation first, tests written afterward will pass immediately and prove nothing.
+
+## Cycle
+
+### RED — Write a failing test first
+
+1. `search_codebase("test <feature>")` — find existing test files and patterns for this area
+2. `get_file(test_file, include=["outline"])` — understand test structure and helpers
+3. Write the minimal test that describes the desired behavior
+4. Run tests using the host agent test runner (e.g. `npm test`, `vitest`, `pytest`, etc.) — confirm the test **fails** before proceeding
+   - If the test passes immediately: it is testing existing behavior, not new behavior — revise it
+
+### GREEN — Implement the minimum to pass
+
+1. `symbol(action="context", symbol, file_path)` — read the exact function/class to modify
+2. `symbol(action="callers", path, symbol)` — understand call context before changing signatures
+3. Write only the code needed to make the failing test pass — no extra logic
+4. Run tests using the host agent test runner (e.g. `npm test`, `vitest`, `pytest`, etc.) — confirm the test now **passes**
+
+### REFACTOR — Clean up without breaking
+
+1. Improve naming, extract helpers, remove duplication
+2. Run tests using the host agent test runner (e.g. `npm test`, `vitest`, `pytest`, etc.) — confirm all tests still pass after cleanup
+3. `diff(mode="working")` — review final scope of changes
+
+## Rules
+
+- One behavior per test — keep tests minimal and named after the behavior, not the implementation
+- Prefer real code over mocks when the actual module is fast enough to call
+- Never declare the task complete without showing that tests pass

package/agent-pack/skills/token-efficient-code-review/SKILL.md

@@ -0,0 +1,15 @@
+# Token-Efficient Code Review
+
+Use this skill when reviewing changes in a CodeMap-indexed repository.
+
+## Process
+
+1. Start with `diff(mode="working")` or `diff(mode="refs")`.
+2. For changed symbols, use `symbol` instead of full-file reads.
+3. Use `symbol` for risky public API, shared behavior, or call-flow changes.
+4. Lead with concrete findings ordered by severity.
+5. Mention test gaps and residual risk.
+
+## Rule
+
+Review behavior, integration risks, and missing verification. Avoid summarizing broad context unless it supports a finding.

package/agent-pack/skills/verification-before-completion/SKILL.md

@@ -0,0 +1,25 @@
+# Verification Before Completion
+
+Use this skill after any task that changed files. It is the final gate before telling the user the work is done.
+
+## Checklist
+
+1. **Inspect changes**
+   - Call `diff(mode="working")`.
+   - Confirm only intended files changed.
+   - Mention unrelated dirty files if present.
+
+2. **Run checks**
+   - Run the smallest sufficient build or test command.
+   - For shared package changes, build shared before dependents.
+   - If a check cannot run, explain why and what risk remains.
+
+3. **Refresh indexes**
+   - Call `refresh_local_index` after local code edits.
+   - Use `reimport` and `reimport(wait=true)` only when cloud graph, web insights, or paid workspace cloud indexing should update.
+
+4. **Final response**
+   - Summarize changed behavior.
+   - List verification results.
+   - Call out skipped checks, blockers, or residual risk.
+

package/agent-pack/skills/writing-plans/SKILL.md

@@ -0,0 +1,32 @@
+# Writing Plans
+
+Use this skill after a design is approved and before implementation begins. The goal is a decision-complete plan that another agent can execute without guessing.
+
+## Hard Gate
+
+Do not edit production files while writing the plan. Implementation starts only after the plan is accepted or the user explicitly asks to execute it.
+
+## Process
+
+1. **Re-ground in CodeMap context**
+   - Use the narrowest CodeMap context tool to confirm affected files, symbols, and risks.
+   - Inspect only the outlines or symbols needed to make implementation decisions.
+
+2. **Write a concrete implementation plan**
+   - Use `codemap://agent-pack/templates/implementation-plan`.
+   - Include exact files or modules to touch when they are known.
+   - Include ordered steps, interfaces, edge cases, and verification commands.
+   - State assumptions clearly instead of leaving choices for the implementer.
+
+3. **Check execution safety**
+   - Confirm no unrelated refactors are included.
+   - Confirm how to preserve user changes in a dirty worktree.
+   - Confirm the smallest sufficient test/build command.
+
+4. **Wait for approval when required**
+   - New features and high-risk changes require user approval before implementation.
+   - Low-risk fixes may proceed after a lightweight plan if the user has already asked for execution.
+
+## Output
+
+Return a concise plan with: summary, key edits, verification, and assumptions.

package/agent-pack/templates/AGENTS.md

@@ -0,0 +1,21 @@
+# AGENTS.md
+
+Use CodeMap MCP before raw file reads or grep.
+
+- Start with `get_project`.
+- Broad implementation/debug/review/refactor/test/research tasks with unclear files: `explore_task`.
+- Follow relevant skills, hard gates, artifact templates, and verification checklist.
+- Related files: `find_related_files`.
+- Known symbols/files: `search_codebase`.
+- Several candidates: `get_file`.
+- Exact body: `symbol`.
+- Impact analysis: `symbol`.
+- Read MCP output by summary, ranking reasons, next steps, and resource URIs before expanding context.
+- After edits: build/test, inspect diff, then reimport when needed.
+
+Installed CodeMap skills live under `.codex/skills/codemap-*`:
+- `codemap-brainstorming` — design-first workflow with hard gate before implementation
+- `codemap-writing-plans` — decision-complete plan after approved design
+- `codemap-executing-plans` — execute approved plans in scoped steps
+- `codemap-test-driven-development` — RED → GREEN → REFACTOR using CodeMap tools
+- `codemap-verification-before-completion` — final diff/build/index/reimport gate

package/agent-pack/templates/CLAUDE.md

@@ -0,0 +1,19 @@
+# CLAUDE.md
+
+Use CodeMap MCP-first workflow for this repository.
+
+For broad implementation/debug/review/refactor/test/research tasks, use CodeMap MCP tools to gather repo context before editing. Start with `explore_task` when files are unclear, or inspect exact files/symbols directly when the user already named them.
+
+Must read:
+
+- `.claude/rules/codemap-mcp-first.md`
+- `.claude/rules/codemap-task-lifecycle.md`
+
+Relevant skills live under `.claude/skills/codemap-*`:
+- `codemap-brainstorming` — design-first workflow with hard gate before implementation
+- `codemap-writing-plans` — decision-complete plan after approved design
+- `codemap-executing-plans` — execute approved plans in scoped steps
+- `codemap-test-driven-development` — RED → GREEN → REFACTOR using CodeMap tools
+- `codemap-verification-before-completion` — final diff/build/index/reimport gate
+
+When a CodeMap MCP tool returns ranked files, symbol context, or next steps, read the summary and ranking signals before opening raw files.