# Kawa Code (npm · @kawacode/mcp)

Team-aware memory: intent, decisions, real-time conflicts for AI coding assistants.

- Trust score: 65/100 (medium)
- Change this week: +33
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-08-03

## Components

- npm · `@kawacode/mcp`: 65/100 (this document), [markdown](https://verifymcp.io/servers/ai-kawacode-mcp/kawacode-mcp.md), [page](https://verifymcp.io/servers/ai-kawacode-mcp/kawacode-mcp)

## Channel facts

- Registry: `npm`
- Package: `@kawacode/mcp`
- Version: `6.9.4`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-08-03.

- **Supply Chain Security**: 87/100
  - No malware found by supply-chain analysis.
  - Only part of the dependency tree could be resolved (95 of 99), so this covers what we could see, not the whole tree.
  - No install/post-install scripts declared.
  - Only part of the dependency tree could be resolved (95 of 99), so this covers what we could see, not the whole tree.
- **Provenance & Transparency**: 32/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - License check failed: the license (SEE LICENSE IN LICENSE) isn't a recognized OSI-approved license.
  - Actively maintained (last published 9 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 69/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 9507 tokens (~352/item across 27 items; 26 tools + 1 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 27/100
  - Stability observed for 8 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### Claude

```bash
claude mcp add ai-kawacode-mcp -- npx -y @kawacode/mcp
```

### Codex

```bash
codex mcp add ai-kawacode-mcp -- npx -y @kawacode/mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "ai-kawacode-mcp": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "@kawacode/mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add ai-kawacode-mcp --command npx --arg -y --arg @kawacode/mcp
```

### Hermes

```yaml
mcp_servers:
  ai-kawacode-mcp:
    command: "npx"
    args: ["-y", "@kawacode/mcp"]
```

### Other

```json
{
  "mcpServers": {
    "ai-kawacode-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "@kawacode/mcp"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-08-02 (score 65, +31)

- [security regression] Provenance: unverified → fail
- [security improvement] Known CVEs: unverified → partial
- [security improvement] Install scripts: unverified → pass
- [security improvement] Malware scan: unverified → pass
- [functional regression] License: unverified → fail
- [functional improvement] Maintenance: unverified → pass
- [functional improvement] Dependency health: unverified → partial
- [functional improvement] Stability: unverified → 0.23
- [functional] Licence: SEE LICENSE IN LICENSE

### 2026-08-01 (score 34, +28)

- [security] Stability: Stability not yet verified: not enough scan history yet (needs a 30-day window).
- [functional regression] Security disclosure: unverified → fail
- [functional regression] Dependency health: partial → unverified
- [functional improvement] MCP protocol: unverified → pass
- [functional improvement] Schema quality: unverified → 100
- [functional improvement] Tool coverage: unverified → 100

### 2026-07-31 (score 6, −39)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-30 (score 45, −12)

- [security regression] Known CVEs: partial → unverified
- [functional regression] Dependency health: partial → unverified

### 2026-07-29 (score 57, +49)

- [security regression] Provenance: unverified → fail
- [security improvement] Known CVEs: unverified → partial
- [security improvement] Install scripts: unverified → pass
- [functional regression] License: unverified → fail
- [functional improvement] Schema quality: unverified → good
- [functional improvement] Maintenance: unverified → pass
- [functional improvement] Schema quality: unverified → 100
- [functional improvement] Tool coverage: unverified → 100
- [functional] Licence: SEE LICENSE IN LICENSE

### 2026-07-28 (score 8, −24)

- [functional regression] Schema quality: 100 → unverified
- [functional regression] Tool coverage: 100 → unverified
- [functional improvement] Dependency health: unverified → partial

### 2026-07-27 (score 32)

First indexed and scored.

## MCP tools (26)

### `get_relevant_context` (~444 tokens)

Find past intents and decisions relevant to the current user request.

When to use:
\- After you have done a quick initial exploration of the user's request and know which files are involved. Calling earlier with only a vague prompt gives weak results.
\- To pull task-specific context instead of dumping all recent activity — preferred for large projects.

Inputs of note:
\- `prompt`: the user request, in their words or your paraphrase.
\- `activeFiles` (recommended): files you have identified as relevant to the request. Significantly improves relevance.
\- `maxIntents`, `maxDecisions`, `minRelevance`: result-shaping caps and threshold.

Returns:
\- `relevantIntents`: past work units (intents) related to the task, scored by relevance.
\- `relevantDecisions`: prior decisions related to the task — both intent-scoped and repo-scoped. Summary-only (no inline rationale, to keep context lean); call `get_decision_detail(decisionId)` for the full rationale/context/consequences of any decision you want to open.

Recommended sequence:
1\. `check_active_intent` at session start to resume any existing work.
2\. Briefly explore the user's request to identify involved files.
3\. `get_relevant_context` with the prompt and `activeFiles` to inform the approach.

Input parameters:

- `activeFiles` (array): Files currently being discussed or recently opened
- `forkAuthor` (object): Fork attribution; usually resolved by Muninn automatically — pass only for override / testing.
- `maxDecisions` (number): Maximum number of decisions to return
- `maxIntents` (number): Maximum number of intents to return
- `minRelevance` (number): Minimum relevance score (0-1)
- `prompt` (string, required): The user request to find relevant context for
- `repoOrigin` (string): Git remote origin URL. Auto-detected from repoPath via git if not provided.
- `repoPath` (string, required): Local path to the repository root
- `workspaceId` (string): Workspace identifier; usually resolved by Muninn automatically — pass only for override / testing.

### `check_active_intent` (~336 tokens)

REQUIRED: Call this tool BEFORE writing any code.

Returns THIS session's current intent (`intent` / `hasActiveIntent`) if one is
set. If not, ask the user to confirm intent details and then call
create_and_activate_intent.

Multi-active model: the active intent is PER SESSION. Many intents can be active
on a repo at once — your current is independent of other sessions'/teammates'.
The response also includes `activeIntents`: the repo's full active set (every
session's current intent, with id/title/status/createdBy/author) for awareness
and orchestration. `hasActiveIntent` reflects only YOUR session; `activeIntents`
may be non-empty even when you have no current.

An active intent tracks what the user is working on, enabling:
\- Better code context for AI-generated changes
\- Conflict detection with team members
\- Automatic assignment of code blocks to the intent

Status semantics:
\- "active" — normal, in-progress. A stale intent simply stays "active"; the
  sweeper preserves its work without any status transition.
\- terminal states — committed / pushed / done / abandoned / superseded.

Input parameters:

- `forkAuthor` (object): Fork attribution; usually resolved by Muninn automatically — pass only for override / testing.
- `repoOrigin` (string): Git remote origin URL. Auto-detected from repoPath via git if not provided.
- `repoPath` (string, required): Local path to the repository root
- `workspaceId` (string): Workspace identifier; usually resolved by Muninn automatically — pass only for override / testing.

### `create_and_activate_intent` (~375 tokens)

Create a new intent from the user's request and mark it as active for THIS session.

Call this when check_active_intent returns no active intent for your session. Before calling:
1\. Summarize what the user is asking for
2\. Ask the user to confirm the intent details (title, description, type)
3\. Then call this tool with the confirmed details

This ensures all AI-generated code gets properly tracked and attributed.

Multi-active model: many intents can be active on a repo at once (one per
session/teammate). Creating + activating one only sets YOUR session's current
focus — it never blocks or displaces another session's active intent, so there
is no lock conflict to resolve.

If the tool returns conflicts (action="conflict"), it found an existing
team-member intent that overlaps semantically or in files. Present the conflict
details to the user and ask whether to proceed. If yes, retry with force=true to
bypass conflict detection.

Input parameters:

- `constraints` (array): Requirements or constraints for this work
- `description` (string, required): What this intent accomplishes
- `force` (boolean): Bypass conflict detection. Set to true after the user has reviewed detected conflicts and chosen to proceed anyway.
- `forkAuthor` (object): Fork attribution; usually resolved by Muninn automatically — pass only for override / testing.
- `repoOrigin` (string): Git remote origin URL. Auto-detected from repoPath via git if not provided.
- `repoPath` (string, required): Local path to the repository root
- `templateType` (string): Type of work
- `title` (string, required): Short, descriptive title for the intent
- `workspaceId` (string): Workspace identifier; usually resolved by Muninn automatically — pass only for override / testing.

### `activate_intent` (~360 tokens)

Activate an existing intent by ID — sets it as THIS session's current focus.

Use this to:
\- Switch your current focus to a different intent found via list_team_intents or get_relevant_context
\- Re-activate an intent that was deactivated (e.g., to complete it)
\- Resume work on a previously created intent
\- Resume an "abandoned" intent (see below)

Accepts both cloud IDs (from get_relevant_context / API) and local UUIDs (from list_team_intents).

Multi-active model: activating an intent only moves YOUR session's current
pointer. Many intents can be active on a repo at once (one current per
session/teammate), so this never blocks on or displaces another session's
active intent — there is no lock to take over.

Resuming abandoned intents:
\- Abandoned intents have their decisions soft-deleted (invisible to recall and
  get_relevant_context). Activating one transparently restores them — single-intent
  decisions for this intent get their soft-delete cleared so the prior reasoning
  becomes visible again. Multi-intent decisions stay visible throughout (they were
  never soft-deleted).

Input parameters:

- `forkAuthor` (object): Fork attribution; usually resolved by Muninn automatically — pass only for override / testing.
- `intentId` (string, required): The cloud ID (preferred) or local UUID of the existing intent to activate.
- `repoOrigin` (string): Git remote origin URL. Auto-detected from repoPath via git if not provided.
- `repoPath` (string, required): Local path to the repository root
- `workspaceId` (string): Workspace identifier; usually resolved by Muninn automatically — pass only for override / testing.

### `resume_intent` (~352 tokens)

Resume an existing intent by ID in one call — activate it AND load its recorded decisions.

Use this to pick up a handoff. When a prompt says "follow up on intent <id>" (or you otherwise want to continue a specific existing intent), call resume_intent(<id>) instead of creating a new one. It:
\- activates the intent as THIS session's current focus (multi-active — never displaces a teammate's active intent), and
\- returns the intent's title/description/status plus its recorded decisions (summary-only; call get_decision_detail(id) for full rationale on any one).

This is the fast path for cross-developer handoff without a session or transcript export: the reasoning lives in Kawa Code, so a teammate resumes the thread from just the intent id. For the code itself, the intent's owner should have committed or pushed first (a prompt carries reasoning, not an uncommitted working tree).

Returns { resumed, intentId, intent?, decisions[], count, message }. resumed=false with a message when the id can't be activated.

Input parameters:

- `forkAuthor` (object): Fork attribution; usually resolved by Muninn automatically — pass only for override / testing.
- `intentId` (string, required): The cloud ID (preferred) or local UUID of the intent to resume — e.g. the id from a "follow up on intent <id>" handoff.
- `repoOrigin` (string): Git remote origin URL. Auto-detected from repoPath via git if not provided.
- `repoPath` (string, required): Local path to the repository root
- `workspaceId` (string): Workspace identifier; usually resolved by Muninn automatically — pass only for override / testing.

### `get_intents_for_file` (~172 tokens)

Get all intents that have code blocks in this file.

Use this before modifying a file to:
\- See what work is already in progress
\- Identify potential conflicts with team members
\- Understand the context of existing code changes

Returns intent details including author, status, and specific line ranges.

Input parameters:

- `filePath` (string, required): Path to the file (relative to repo root)
- `forkAuthor` (object): Fork attribution; usually resolved by Muninn automatically — pass only for override / testing.
- `repoOrigin` (string): Git remote origin URL. Auto-detected from repoPath via git if not provided.
- `repoPath` (string, required): Local path to the repository root
- `workspaceId` (string): Workspace identifier; usually resolved by Muninn automatically — pass only for override / testing.

### `get_intents_for_lines` (~208 tokens)

Get intents covering a specific line range.

Use this before modifying specific lines to check for conflicts:
\- Warns if the lines overlap with another team member's active intent
\- Shows the exact overlap range
\- Helps avoid merge conflicts and duplicate work

Returns overlap details so you can work around or coordinate with team members.

Input parameters:

- `endLine` (number, required): End line number (1-based, inclusive)
- `filePath` (string, required): Path to the file (relative to repo root)
- `forkAuthor` (object): Fork attribution; usually resolved by Muninn automatically — pass only for override / testing.
- `repoOrigin` (string): Git remote origin URL. Auto-detected from repoPath via git if not provided.
- `repoPath` (string, required): Local path to the repository root
- `startLine` (number, required): Start line number (1-based)
- `workspaceId` (string): Workspace identifier; usually resolved by Muninn automatically — pass only for override / testing.

### `list_team_intents` (~298 tokens)

List intents from team members for this repository.

Use this to:
\- See what your team is working on
\- Check for potential overlapping work before starting a new task
\- Review the status of various features/refactors in progress

Filtering (status, author, date range) and pagination are applied server-side across the full result set (default: 50 per page; use limit/offset to page). `count` is the total number of matching intents, not just the returned page.

Input parameters:

- `author` (string): Filter by author name or ID
- `forkAuthor` (object): Fork attribution; usually resolved by Muninn automatically — pass only for override / testing.
- `limit` (number): Maximum number of intents to return (default: 50)
- `offset` (number): Number of intents to skip for pagination (default: 0)
- `repoOrigin` (string): Git remote origin URL. Auto-detected from repoPath via git if not provided.
- `repoPath` (string, required): Local path to the repository root
- `since` (string): Filter intents updated after this ISO8601 date (e.g. "2026-04-01")
- `status` (string): Filter by intent status.
- `until` (string): Filter intents updated before this ISO8601 date
- `workspaceId` (string): Workspace identifier; usually resolved by Muninn automatically — pass only for override / testing.

### `get_intent_changes` (~185 tokens)

Get uncommitted changes in the repository along with the active intent info.

Use this tool before prompting the user about committing to show:
\- The active intent title and description
\- Number of modified, added, and untracked files
\- Any warnings (e.g., pre-existing changes from before intent activation)

This helps you construct an informative commit prompt like:
"You have uncommitted work on '[intent title]' (N files changed)..."

Input parameters:

- `forkAuthor` (object): Fork attribution; usually resolved by Muninn automatically — pass only for override / testing.
- `repoOrigin` (string): Git remote origin URL. Auto-detected from repoPath via git if not provided.
- `repoPath` (string, required): Local path to the repository root
- `workspaceId` (string): Workspace identifier; usually resolved by Muninn automatically — pass only for override / testing.

### `complete_intent` (~906 tokens)

Mark the active intent as completed and clear it.

Call this after a successful git commit to:
1\. Update the intent status (committed/pushed/done/abandoned)
2\. Store the commit SHA for tracking
3\. Clear the active intent so a new one can be started

Status values:
\- "committed": Code is committed locally (default)
\- "pushed": Code has been pushed to remote
\- "done": Work is fully complete
\- "abandoned": Work was discarded without committing

REQUIRED: Inspect the response after calling this tool. Three outcomes:

1\. response.success === true:
   The task is complete. Briefly acknowledge the commit and — if
   response.committedDecisionCount > 0 — mention that N distilled architectural
   decisions were recorded for the intent. Do NOT enumerate the decisions
   inline; they're visible via the orchestration panel and via
   get_intent_decisions / get_relevant_context if the user wants details.
   If response.apiSyncDeferred === true, also mention that the API sync was
   deferred; the queued writes will replay on the next sync tick.
   If response.collisions is non-empty, a live collaborator's (HAI's)
   in-progress edits overlap the work you just completed — surface it as a
   coordination heads-up (who, and which files), naming response.collisions[].label
   and the files. It's advisory, not a failure; the completion still succeeded.
   If response.deferredConflicts is non-empty, the distillation produced N
   decisions that conflict with existing standards — the completion STILL
   SUCCEEDED (the commit landed: status flipped, code blocks captured). Those
   decisions are deferred: parked for a disposition in the Orchestration panel,
   where the user picks per decision: supersede the standard, keep both (records
   a "contradicts" edge for a deliberate divergence / false positive), or reject
   the distilled decision. Tell the user "N decision(s) need a disposition in
   the panel." There is NOTHING to retry — do NOT re-run complete_intent.

2\. response.success =…

Input parameters:

- `commitSha` (string): The git commit SHA to associate with this intent (if already committed)
- `forkAuthor` (object): Fork attribution; usually resolved by Muninn automatically — pass only for override / testing.
- `humanApproved` (boolean): Set to true ONLY when the human has explicitly confirmed closing an intent created by ANOTHER team member. Required for that cross-author case; ignored for your own intents. NEVER set this on your ow…
- `intentId` (string): Target intent to complete/abandon. When omitted, completes THIS session's current intent. When provided, targets that specific intent directly — this is how you force-close an intent that is not your…
- `repoOrigin` (string): Git remote origin URL. Auto-detected from repoPath via git if not provided.
- `repoPath` (string, required): Local path to the repository root
- `status` (string): The new status for the intent. Use "committed" after git commit, "done" when work is complete, "abandoned" to discard, "superseded" when another intent replaces this one.
- `supersededBy` (string): Intent ID that supersedes this one. Required when status is "superseded".
- `workspaceId` (string): Workspace identifier; usually resolved by Muninn automatically — pass only for override / testing.

### `update_intent` (~269 tokens)

Update an active intent's title, description, scope, or constraints.

Use this to reformulate an intent as understanding evolves during work. Intents are
living documents — they should be updated to reflect what the work actually became,
not left as the initial guess. Common triggers for reformulation:
\- The real problem turned out to be different from the initial hypothesis
\- Scope expanded or narrowed during investigation
\- The approach changed after discovering constraints

If no intentId is provided, the currently active intent is updated.

Input parameters:

- `constraints` (array): Updated constraints for this work
- `description` (string): Updated description for the intent
- `forkAuthor` (object): Fork attribution; usually resolved by Muninn automatically — pass only for override / testing.
- `intentId` (string): ID of the intent to update. If omitted, updates the currently active intent.
- `repoOrigin` (string): Git remote origin URL. Auto-detected from repoPath via git if not provided.
- `repoPath` (string, required): Local path to the repository root
- `scope` (object): Updated scope for the intent
- `title` (string): Updated title for the intent
- `workspaceId` (string): Workspace identifier; usually resolved by Muninn automatically — pass only for override / testing.

### `log_work` (~183 tokens)

DEPRECATED — trivial changes (typos, one-line fixes, obvious bugs, doc updates, config changes) should skip the intent workflow entirely: just make the change and commit, no intent needed. Do not call this tool. Kept available for backwards compatibility only and will be removed in a future release.

Input parameters:

- `files` (array): File paths modified (relative to repo root)
- `forkAuthor` (object): Fork attribution; usually resolved by Muninn automatically — pass only for override / testing.
- `repoOrigin` (string): Git remote origin URL. Auto-detected from repoPath via git if not provided.
- `repoPath` (string, required): Local path to repository root
- `title` (string, required): Short description of the work done
- `workspaceId` (string): Workspace identifier; usually resolved by Muninn automatically — pass only for override / testing.

### `record_decision` (~969 tokens)

Silently record a decision point during development.

Call this tool when you:
\- Choose between multiple alternatives (type: fork)
\- Try an approach that fails or is rejected (type: abandoned)
\- Find unexpected behavior or limitations (type: discovery)
\- Identify a hard constraint that must be respected (type: constraint)
\- Make an explicit trade-off between competing concerns (type: tradeoff)
\- Select an external library or dependency (type: dependency)

Decisions can be **intent-scoped** (tied to a specific work unit) or **repo-scoped** (general knowledge like discoveries and constraints). Omit intentId for repo-scoped decisions.

Decisions are accumulated silently during the session and presented for review before commit.
This creates a "reasoning changelog" that captures not just what was done, but why.

IMPORTANT: Include constraintViolations when alternatives are rejected due to architectural constraints.

Input parameters:

- `alternatives` (array): Other options that were considered
- `appliesWhen` (string): Trigger condition / "How to apply" — populate ONLY when the decision is plainly conditional (e.g. "language is Go", "when running in production", "when working in module X", "when the error is ECONNR…
- `confidence` (string): Self-rated confidence in the decision. Meaningful only for extractor and infer_history sources — leave null for deliberate recordings.
- `consequences` (string): Downstream implications of this decision
- `constraintViolations` (array): Alternatives that were rejected due to constraint violations
- `constraintsChecked` (array): Which architectural constraints were verified before this decision
- `context` (string): What we were trying to accomplish when this decision was made
- `forkAuthor` (object): Fork attribution; usually resolved by Muninn automatically — pass only for override / testing.
- `intentId` (string): The intent ID this decision belongs to. Omit for repo-scoped decisions (discoveries, constraints) not tied to a specific work unit
- `rationale` (string, required): Why this decision was made
- `relatedFiles` (array): File paths affected by this decision
- `repoOrigin` (string): Git remote origin URL. Auto-detected from repoPath via git if not provided.
- `repoPath` (string, required): Local path to the repository root (enables offline sync)
- `resolvedCollision` (object): Layer C audit — set ONLY when this decision records how you resolved a completion-time code collision (i.e. after complete_intent returned resolution_required). Links the decision to the live peer yo…
- `source` (string): Provenance: user (human-recorded), agent (AI deliberately recorded via this tool — the default), extractor (from thought-chain extraction), infer_history (from commit-history extraction). Most caller…
- `sourceThoughtIds` (array): Thought-chain entry IDs this record was extracted from. Only set by the extractor path.
- `summary` (string, required): Brief summary of the decision (< 100 chars recommended)
- `supersedes` (array): Decision IDs that this one replaces. When a later decision supersedes an earlier one, pass the earlier decisionId(s) here so the evolve pipeline can track the lineage.
- `surface` (array): Which ceremony(ies) this decision should be surfaced at, controlling when it interrupts future work. Values: "pre-edit" (per-edit block via pre_edit_decision_check — for correctness/security constrai…
- `symptom` (string): Observable symptom that indicates this decision is relevant (e.g., error messages, runtime panics, unexpected behavior). Useful for discovery and constraint decisions.
- `type` (string, required): Type of decision: fork (chose between alternatives), abandoned (tried and rejected), discovery (found unexpected behavior), constraint (identified hard requirement), tradeoff (made explicit trade-off…
- `workspaceId` (string): Workspace identifier; usually resolved by Muninn automatically — pass only for override / testing.

### `get_session_decisions` (~205 tokens)

Get all decisions recorded in the current session for an intent.

Use this before committing to review what decisions were captured during development.
Decisions are presented for user review and can be edited or removed before being persisted.

Returns:
\- intentId: The intent these decisions belong to
\- decisions: Array of decision points (summary-only — call get_decision_detail(decisionId) for full rationale/context/consequences/alternatives)
\- count: Number of decisions recorded

Input parameters:

- `forkAuthor` (object): Fork attribution; usually resolved by Muninn automatically — pass only for override / testing.
- `intentId` (string, required): The intent ID to get decisions for
- `repoOrigin` (string): Git remote origin URL. Auto-detected from repoPath via git if not provided.
- `repoPath` (string, required): Local path to the repository root
- `workspaceId` (string): Workspace identifier; usually resolved by Muninn automatically — pass only for override / testing.

### `get_project_decisions` (~271 tokens)

Get all decisions recorded for a project across all intents.

Use this to review the project's decision history:
\- See what architectural decisions have been made
\- Understand past trade-offs and their rationale
\- Find decisions affecting specific files
\- Review constraint violations that were avoided

Returns:
\- decisions: Array of decisions with their intent context
\- count: Total number of decisions

Each decision includes (summary-only, to keep context lean — call get_decision_detail(decisionId) for full rationale/context/consequences/alternatives):
\- intentIds: The intents this decision belongs to (array — a decision can span multiple intents)
\- type: fork, abandoned, discovery, constraint, tradeoff, or dependency
\- summary: Brief description of the decision
\- relatedFiles: Files affected by this decision
\- constraintViolations: Options that were rejected due to constraints

Input parameters:

- `forkAuthor` (object): Fork attribution; usually resolved by Muninn automatically — pass only for override / testing.
- `repoOrigin` (string): Git remote origin URL. Auto-detected from repoPath via git if not provided.
- `repoPath` (string, required): Local path to the repository root
- `workspaceId` (string): Workspace identifier; usually resolved by Muninn automatically — pass only for override / testing.

### `get_decision_detail` (~259 tokens)

Expand one decision to its full detail.

Recall surfaces (get_relevant_context, get_project_decisions, get_session_decisions) return decisions summary-only to keep context lean. Use this to pull the full reasoning for a single decision you want to open — pay for detail only where you ask for it.

Inputs:
\- `decisionId`: the decision to expand (the `id` / `decisionId` from a recall result).

Returns the decision's `rationale`, `context`, `consequences`, `alternatives`, `symptom`, `appliesWhen`, `surface`, and related metadata. `found: false` when the id is unknown in this repo.

Input parameters:

- `decisionId` (string, required): The decision ID to expand (from a recall result, e.g. get_relevant_context)
- `forkAuthor` (object): Fork attribution; usually resolved by Muninn automatically — pass only for override / testing.
- `repoOrigin` (string): Git remote origin URL. Auto-detected from repoPath via git if not provided.
- `repoPath` (string, required): Local path to the repository root
- `workspaceId` (string): Workspace identifier; usually resolved by Muninn automatically — pass only for override / testing.

### `edit_session_decision` (~263 tokens)

Edit or delete a decision in the current session.

Use this when reviewing decisions before commit:
\- action: "update" - Modify the decision fields
\- action: "delete" - Remove the decision entirely

Only ephemeral (in-flight) session decisions are editable. Once a decision is
synced to Kawa Code, it is immutable — refine it instead by recording a new
decision with `supersedes: [<id>]`.

This allows users to curate their decision history before it's persisted.

Input parameters:

- `action` (string, required): Action to perform: update modifies the decision, delete removes it
- `decisionId` (string, required): The decision ID to edit or delete
- `forkAuthor` (object): Fork attribution; usually resolved by Muninn automatically — pass only for override / testing.
- `intentId` (string, required): The intent ID the decision belongs to
- `repoOrigin` (string): Git remote origin URL. Auto-detected from repoPath via git if not provided.
- `repoPath` (string, required): Local path to the repository root
- `updates` (object): Partial fields to update (only for action=update)
- `workspaceId` (string): Workspace identifier; usually resolved by Muninn automatically — pass only for override / testing.

### `detect_intent_conflicts` (~270 tokens)

Find intents from other team members that potentially conflict with the active intent.

When to use:
\- Before committing, to surface overlapping team work so the user can coordinate before merging.

Inputs of note:
\- `intentId`: the active intent to check against.
\- `minScore` (optional): minimum match score to include in results.

Returns scored conflict candidates with:
\- `score`: how strongly the candidate matches (higher = more likely conflict).
\- `overlappingFiles`: files affected by both intents.
\- `decisions`: decisions attached to the conflicting intent.
\- `author`: who is working on the conflicting intent.

The list is informational — review candidates and their decisions to decide whether coordination is needed.

Input parameters:

- `forkAuthor` (object): Fork attribution; usually resolved by Muninn automatically — pass only for override / testing.
- `intentId` (string, required): The active intent ID
- `minScore` (number): Minimum similarity score threshold (default: 0.5)
- `repoOrigin` (string): Git remote origin URL. Auto-detected from repoPath via git if not provided.
- `repoPath` (string, required): Local path to the repository root
- `workspaceId` (string): Workspace identifier; usually resolved by Muninn automatically — pass only for override / testing.

### `infer_history` (~870 tokens)

Analyze a repository's git commit history and produce structured development knowledge (intents and decisions) for the repo.

When to use:
\- To bootstrap a repository that has no recorded intents/decisions yet.
\- To extend coverage for new commits since the last run (resumes automatically when no `commits` value is provided).

Inputs of note:
\- `estimateOnly` (default true): returns a token/cost estimate without running. Call with `estimateOnly: true` first to preview cost, then re-call with `estimateOnly: false` to run.
\- `commits` (optional): how many recent commits to analyze. Omit to resume from where the last run stopped (or fall back to a sensible default on first run).
\- `commitRange` (optional): git revspec selecting a specific window — `"sha1..sha2"`, `"branch1..branch2"`, `"sha1^!"` for a single commit. Mutually exclusive with `commits`. Useful for recovering from dropped batches or backfilling specific PRs / branches without re-running the full history.
\- `contextIssues`: include PR/MR descriptions and issue discussions when an authenticated forge CLI (`gh` or `glab`) is available; auto-skipped otherwise.
\- `allowCommitSplitting`: enable when commit history is messy and a single commit may cover unrelated changes.
\- `model`, `maxStories`: Anthropic model and per-run cap.
\- `force` (default false): override the re-run guard (see Behavior).

Behavior:
\- A run is asynchronous — returns immediately with a started/pending status; progress is reported separately.
\- Results are persisted as intents and decisions for the repo on completion.
\- If interrupted, re-running resumes from where it left off.
\- Re-run guard: a clean incremental resume runs automatically. But if the repo already has intents and the run cannot cleanly resume (missing/unreachable cursor), or HEAD is not on the default branch, the call STOPS and returns `needsDecision` instead of running — re-running blind there risks duplicate intents. Present the reason to the user and, if they confirm, re…

Input parameters:

- `allowCommitSplitting` (boolean): Allow splitting a single commit into multiple stories when it contains unrelated changes (recommended for repos with messy commit history)
- `commitRange` (string): Optional git revspec to process a specific commit range instead of the N most recent (e.g. "sha1..sha2", "branch1..branch2", "sha1^!" for a single commit). Useful for recovering from dropped batches…
- `commits` (number): Number of recent commits to analyze. If omitted, the server resumes from the last commit infer_history processed for this repo (or falls back to 50 on first run). Mutually exclusive with `commitRange…
- `contextIssues` (boolean): Include context issues from commit date range (requires gh/glab CLI)
- `estimateOnly` (boolean): If true (default), only estimate token cost without running the pipeline. Set to false to run the full pipeline.
- `force` (boolean): Override the re-run guard. When the repo already has intents and infer_history cannot cleanly resume (missing/unreachable cursor), or when HEAD is not on the default branch, the run is stopped and a…
- `maxStories` (number): Maximum number of stories to analyze in this run (0 = unlimited).
- `model` (string): Anthropic model to use (default: claude-sonnet-4-20250514)
- `repoPath` (string, required): Local path to the repository root

### `evolve_decisions` (~301 tokens)

Curate a set of previously extracted stories so that only the decisions still worth keeping are persisted.

When to use:
\- After running `infer_history` in story-only mode (rare — `infer_history` already chains this step automatically).
\- When you have a pre-existing set of stories you want to re-curate without re-running history extraction.

Inputs:
\- `stories`: array of story objects from a previous `infer_history` run.
\- `repoPath` (optional): when provided, curated results are persisted as intents and decisions for the repo after curation finishes.
\- `model` (optional): Anthropic model used for the curation pass.

Behavior:
\- Runs asynchronously — returns immediately with a started/pending status while progress is reported separately.

Input parameters:

- `forkAuthor` (object): Fork attribution; usually resolved by Muninn automatically — pass only for override / testing.
- `model` (string): Anthropic model used for the curation pass (default: claude-haiku-4-5-20251001).
- `repoOrigin` (string): Git remote origin URL (auto-detected from repoPath if not provided)
- `repoPath` (string): Local path to the repository root (required for auto-persist after evolution)
- `stories` (array, required): Array of story objects from a previous infer_history run
- `workspaceId` (string): Workspace identifier; usually resolved by Muninn automatically — pass only for override / testing.

### `update_features` (~168 tokens)

Update the project's feature catalog from its recorded intents.

Additively groups any intents that are not yet assigned to a feature into the running catalog (an incremental "extend"), without disturbing existing features. The feature catalog is the high-level "what does this project actually do?" view, derived from the repo's intents.

When to use:
\- After recording or completing intents, to keep the feature list current.
\- On demand, when you want the catalog refreshed with recent work.

Behavior:
\- Additive only — never deletes or re-derives existing features.
\- Intents already assigned to a feature are skipped; only unassigned ones are processed.
\- Runs in the Kawa Code desktop app and returns the resulting feature count.

Input parameters:

- `repoPath` (string, required): Local path to the repository root

### `pre_edit_decision_check` (~479 tokens)

Check whether the line range about to be edited has prior recorded reasoning attached.

Call this BEFORE editing code in a kawa-indexed repo. Surfaces:
\- Tier 1a — overlapping intents whose blocks cover these lines (line-precise team coordination + intent-scoped decisions)
\- Tier 1b — repo decisions whose relatedFiles include this file (file-coarse, catches infer_history-extracted constraints)

(Live-collaborator code-collision awareness is no longer reported here — it now arrives once per turn at the Stop hook. This tool is purely the semantic, decision-based check.)

Decisions already overridden via record_decision(supersedes=...) are filtered out automatically.

Recommendation maps to action:
\- "proceed" — nothing relevant; safe to edit
\- "review" — surfaced context worth inspecting before editing
\- "investigate-upstream" — prior constraint or abandoned approach matches; don't proceed without reading the rationale and either revising the change or recording a new fork decision that supersedes the old one

Also returns the smallest enclosing function/method symbol via tree-sitter (Rust/TS/JS/Python only; null for other languages) for warning readability.

Input parameters:

- `endLine` (number, required): End line of the touched range (1-based, inclusive)
- `filePath` (string, required): Path to the file being edited (relative to repoPath)
- `forkAuthor` (object): Fork attribution; usually resolved by Muninn automatically — pass only for override / testing.
- `intentId` (string): Active intent ID for supersedes scoping. Auto-detected by Muninn when omitted.
- `repoOrigin` (string): Git remote origin URL. Auto-detected from repoPath via git if not provided.
- `repoPath` (string, required): Local path to the repository root (also used to read the file for AST symbol detection)
- `sessionToken` (string): Session scope for the force-override cache. Defaults to the MCP server's SESSION_ID; PreToolUse hook callers should pass Claude Code's session_id so writes from one process are visible to the other.
- `startLine` (number, required): Start line of the touched range (1-based, inclusive)
- `workspaceId` (string): Workspace identifier; usually resolved by Muninn automatically — pass only for override / testing.

### `pre_edit_acknowledge` (~294 tokens)

Acknowledge pre-edit decisions so they stop blocking your edits for the rest of this session.

When a pre_edit_decision_check block fires and you judge the surfaced reasoning does NOT apply to your edit, call this with the surfaced decision IDs, then retry the edit — those decisions won't re-block this session. The acknowledgment is recorded by this call itself appearing in the session transcript, which the pre-edit hook reads; it needs no session token and is not affected by restarts.

For a PERSISTENT override across sessions (the reasoning is actually wrong or replaced), record a fork instead: `record_decision(type: "fork", supersedes: [<id>])`.

Returns:
\- acknowledged: number of decision IDs acknowledged

Input parameters:

- `decisionIds` (array, required): Decision IDs to acknowledge (suppress from pre-edit blocks for the rest of this session)
- `forkAuthor` (object): Fork attribution; usually resolved by Muninn automatically — pass only for override / testing.
- `repoOrigin` (string): Git remote origin URL. Auto-detected from repoPath via git if not provided. Used only to attribute the acted-on value-metric to a repo.
- `repoPath` (string): Local path to the repository root. Enables repo attribution of the acted-on value-metric.
- `workspaceId` (string): Workspace identifier; usually resolved by Muninn automatically — pass only for override / testing.

### `get_resolution_context` (~451 tokens)

Resolve a live code collision with a peer BEFORE you write (Layer C resolution handoff).

Call this when the Stop hook's collision report (or complete_intent's resolution_required gate) surfaced a live peer (a teammate or AI agent editing the same lines). Pass that collision's uid as peerUid and its overlapping ranges. You get back:
\- peerSnippet — the peer's actual (decrypted) code at the overlapping lines, so you can see what they wrote.
\- decisions — recorded reasoning attached to this file (region context).
\- guardrail — the policy you must follow when resolving:
  • Never overwrite a peer's COMMITTED work — yield or merge. Only override an uncommitted live diff, and only with a recorded rationale.
  • Your resolution is an ordinary git edit (revert/diff is the undo) — stay in your own working tree; build no bespoke undo.
  • Before completing, record_decision(type=fork|tradeoff, …) explaining how you resolved (and supersedes the peer's decision if you overrode it).
  • Choose or synthesize ONE coherent result — never blindly interleave both diffs.

This is advisory and proactive (no lock). Use it to adapt your edit and avoid the conflict.

Input parameters:

- `filePath` (string, required): Path to the file being edited (relative to repoPath)
- `forkAuthor` (object): Fork attribution; usually resolved by Muninn automatically — pass only for override / testing.
- `intentId` (string): Active intent ID (advisory). Auto-detected by Kawa Code when omitted.
- `peerUid` (string, required): The peer HAI whose live edits overlap — the `uid` of a collision from the Stop hook collision report.
- `ranges` (array, required): Overlapping [start, end] line ranges (from the collision) to fetch the peer code for.
- `repoOrigin` (string): Git remote origin URL. Auto-detected from repoPath via git if not provided.
- `repoPath` (string, required): Local path to the repository root
- `workspaceId` (string): Workspace identifier; usually resolved by Muninn automatically — pass only for override / testing.

### `arbiter_resolve` (~294 tokens)

Get Kawa Code's AI verdict for live code overlaps with peers — SUGGEST-ONLY, never writes. For each overlap ({peerUid, filePath, ranges} from the Stop collision report), Kawa decrypts the peer's version locally (zero-knowledge) and judges it compatible / auto_resolvable / conflict, with confidence, a perf/security risk read, and a tier (0 no-op · 1 trivially auto-appliable · 2 draft-and-confirm · 3 conflict). Use it to understand a forming conflict before acting. For a surfaced tier-2/3 overlap, call get_resolution_context to read the peer's actual code. To actually apply the safe tier, use arbiter_apply.

Input parameters:

- `forkAuthor` (object): Fork attribution; usually resolved by Muninn automatically — pass only for override / testing.
- `intentId` (string): Active intent ID (advisory). Auto-detected by Kawa Code when omitted.
- `overlaps` (array, required): The overlaps to judge — each { peerUid, filePath, ranges } from the Stop collision report.
- `repoOrigin` (string): Git remote origin URL. Auto-detected from repoPath via git if not provided.
- `repoPath` (string, required): Local path to the repository root
- `workspaceId` (string): Workspace identifier; usually resolved by Muninn automatically — pass only for override / testing.

### `arbiter_apply` (~311 tokens)

Resolve live code overlaps and AUTO-APPLY the safe tier. Kawa judges → adversarially verifies → and, for the trivial tier only (high-confidence single-range merge that passes verify), writes the merge to your worktree, records a decision, and republishes. Writes happen ONLY in an agent-owned worktree (a linked git worktree); on a human checkout — or when a peer holds the file-set lock — it behaves like arbiter_resolve (suggest-only, no writes). Returns per-overlap outcomes { tier, applied, announcement, verifyIssue?, verdict }. Call it when you are ready to incorporate the result, then RE-READ any file it applied to (it changed on disk). For surfaced (not-applied) overlaps, use get_resolution_context to see the peer code and resolve manually.

Input parameters:

- `forkAuthor` (object): Fork attribution; usually resolved by Muninn automatically — pass only for override / testing.
- `intentId` (string): Active intent ID (advisory; the auto-resolution decision is recorded under it).
- `overlaps` (array, required): The overlaps to resolve — each { peerUid, filePath, ranges } from the Stop collision report.
- `repoOrigin` (string): Git remote origin URL. Auto-detected from repoPath via git if not provided.
- `repoPath` (string, required): Local path to the repository root
- `workspaceId` (string): Workspace identifier; usually resolved by Muninn automatically — pass only for override / testing.

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/ai-kawacode-mcp/kawacode-mcp#diagnostics

## Score history

- 2026-08-03: 65
- 2026-08-02: 65
- 2026-08-01: 34
- 2026-07-31: 6
- 2026-07-30: 45
- 2026-07-29: 57
- 2026-07-28: 8
- 2026-07-27: 32

## Links

- npm package: https://www.npmjs.com/package/@kawacode/mcp
- Socket report: https://socket.dev/npm/package/@kawacode/mcp
- Repository: https://github.com/kawacode-ai/kawa.mcp
- Website: https://kawacode.ai/
- Changelog RSS feed: https://verifymcp.io/servers/ai-kawacode-mcp/kawacode-mcp/changelog.xml
- Changelog JSON feed: https://verifymcp.io/servers/ai-kawacode-mcp/kawacode-mcp/changelog.json
- HTML version of this page: https://verifymcp.io/servers/ai-kawacode-mcp/kawacode-mcp