Read the contents of a file at the given path.

Write content to a file, creating it if it doesn't exist.

Edit a file by replacing an exact string with a new string. Use this for targeted code changes instead of rewriting the whole file.

Delete a file or an empty directory.

Recursively delete a file or directory tree. Use with caution.

List files and directories inside a given directory.

Find files matching a glob pattern (e.g. '/*.ts', 'src//*.py').

Create one or more directories (like mkdir -p).

Search for a text pattern across files in the project using ripgrep-like search.

Run a shell command and return its output. Always set a reasonable timeout. Avoid destructive commands (rm -rf, etc.).

Show the working tree status (git status).

Show staged and unstaged changes (git diff).

Show recent commit history (git log).

List local branches (git branch).

Stage file(s) for commit (git add).

Commit staged changes with a message (git commit).

Create and switch to a new git branch (git checkout -b).

Initialize or auto-detect project context. Scans project files to detect tech stack, languages, and frameworks.

Get the full project context as formatted text. Optionally filter by dot path (e.g. 'tech_stack.languages').

Update a specific field in the project context using dot notation (e.g. 'project.description', 'conventions.code_style').

Add an item to a list field in the context (e.g. tech_stack.languages, key_files, active_tasks, goals).

Register a key file with its purpose in the project context.

Add an active task to the project context.

Log an architecture decision record (ADR) in the project context.

Export the project context as a Markdown document for sharing with other LLMs and AI tools.

Remove an item from a list in the project context by index.

Reset the project context to default values (clears all data).

Get information about the current project environment.

Retrieve a PRD document (PRD, VISION, SCOPE, REQUIREMENTS). Returns the content of the specified document.

Create or update a PRD document (PRD, VISION, SCOPE, REQUIREMENTS).

Summarize key requirements from PRD documents into a concise bullet list.

Compare current project context and tasks against PRD requirements to check alignment.

Get the current active phase and its status.

Set the current active development phase. Only tasks in this phase are considered 'in scope'.

Mark the current phase as completed and optionally advance to the next phase.

Mark current phase as complete and advance to the next phase in sequence.

List all phases and their status (completed, active, pending).

Define a milestone with a target date and associated features.

Show all milestones and their status.

Create a new task with phase, priority, dependencies, and description.

Update a task's status, priority, or description by ID.

Mark a task as completed with optional notes.

Get the highest-priority task that is ready to work on (dependencies met, current phase).

List all tasks that are blocked, either by dependencies or explicitly.

List all active tasks, optionally filtered by phase or status.

Generate a session summary capturing what was done, what's next, and current project state for handoff to another AI.

Retrieve the most recent AI handoff document so a new AI session has full context.

List all AI session handoffs with dates.

Generate a complete aggregated Project Brain dashboard showing current status, phase, active/blocked tasks, recent changes, and recommendations.

Intelligently calculate and recommend the next best task to work on based on phase, priority, dependencies, and file hints.

Start a development session. Loads state, PRD, active tasks, and latest handoff to generate a detailed Session Brief for the AI.

End the current session, update progress, and generate a handoff file (does not auto-commit changes).

Analyze modified workspace files and generate a suggested conventional git commit message and summary for approval.

Stage all workspace changes and commit them to Git with the approved commit message.

Scan the codebase and validate imports/technologies against the project's architectural guidelines and forbidden tools.

Scan files and construct a complete mapping of dependencies and references in the project.

Calculate direct and transitive downstream files affected if a given file is modified.

Scan the physical workspace (Git diff, new files, current branch, commits) and compare to the Todo plan to auto-detect finished work.

Perform deep sanity, test, git diff, and architecture checks against a task to output a reality verification dossier.

Generate a unified Project Manager Dashboard combining phase state, todo progress, git status, architecture violations, and a project health score.

Parse PRD markdown files to extract structured requirements and save them into requirements.json.

Scan codebase to map requirement keywords and verify their implementation status and feature coverage.

Perform outcome audits verifying user flows, business goals, and objective completion based on target tasks.

Scan the workspace and evaluate its onboarding readiness score (0-100%) against required Project Brain documents.

Generate a formatted Markdown project readiness report showing missing files, scoring audit, and recommended actions.

Auto-generate template files and directories (PRD, milestones, active tasks, config yaml) to instantly onboard an unknown repository.

Scan an existing legacy codebase (directories, package lists, readmes) and generate context, PRDs, milestones, and audit tasks.

Check the diagnostic health and configuration integrity of the Project Brain and MCP server.

Wipe all Project Brain configuration, tasks, and context metadata inside the selected project. Leaves git and source code untouched.

Archive current Project Brain settings and context files to .project_brain_archive/ before a reset or pivot, preserving history.

Create a new isolated project workspace directory, initialize git, bootstrap the project context/brain, and set up first milestone.