{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github-maxritter--pilot-shell","slug":"maxritter--pilot-shell","name":"pilot-shell","type":"agent","url":"https://pilot-shell.com","page_url":"https://unfragile.ai/maxritter--pilot-shell","categories":["code-review-security","deployment-infra","testing-quality"],"tags":["ai-agents","ai-assistant","ai-coding","ai-coding-tools","ai-engineering","ai-tools","anthropic","anthropic-claude","claude","claude-ai","claude-code","claude-context","claude-skills","claudecode","model-context-protocol","spec-driven-development"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github-maxritter--pilot-shell__cap_0","uri":"capability://planning.reasoning.spec.driven.task.planning.with.feature.bugfix.auto.detection","name":"spec-driven task planning with feature/bugfix auto-detection","description":"Analyzes user intent via the /spec command, automatically classifies tasks as features or bugfixes, and generates structured implementation plans using a state machine dispatcher that routes to feature or bugfix workflows. The planning phase uses Claude to decompose requirements into atomic steps with estimated complexity, then presents a human-reviewable plan before implementation begins. This enforces upfront design thinking and prevents Claude Code from diverging into ad-hoc implementations.","intents":["I want Claude to plan a feature before coding so I can review and approve the approach","I need to ensure bugfixes are scoped correctly and don't introduce regressions","I want to enforce TDD discipline by requiring test plans before implementation"],"best_for":["teams building production codebases with Claude Code","developers who want structured planning gates before AI-driven implementation","projects requiring audit trails of design decisions"],"limitations":["Requires explicit /spec invocation — does not auto-trigger on unstructured requests","Plan approval is synchronous and blocks implementation until human review","Feature vs bugfix classification relies on Claude's semantic understanding and may misclassify ambiguous tasks"],"requires":["Claude Code (Sonnet 4.6 or Opus 4.6)","Pilot Shell installed globally at ~/.pilot/","Active project directory with git repository"],"input_types":["natural language task description","existing codebase context (automatically loaded)"],"output_types":["structured plan JSON with steps, complexity estimates, and test requirements","human-readable markdown plan for review"],"categories":["planning-reasoning","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-maxritter--pilot-shell__cap_1","uri":"capability://code.generation.editing.test.driven.development.enforcement.with.pre.implementation.test.generation","name":"test-driven development enforcement with pre-implementation test generation","description":"During the implementation phase of /spec workflows, generates test cases before code is written, then validates that all generated code passes those tests before marking tasks complete. The system uses a verification agent that runs test suites and blocks code merges if coverage or assertions are insufficient. This is enforced via hooks that intercept code changes and validate test presence before allowing commits.","intents":["I want Claude to write tests first, then implementation (TDD discipline)","I need to ensure every code change has corresponding test coverage","I want automated verification that tests actually pass before code is committed"],"best_for":["teams with strict TDD requirements or regulatory compliance needs","projects where test coverage is a non-negotiable quality metric","developers who want to prevent untested code from entering the codebase"],"limitations":["Test generation quality depends on Claude's understanding of requirements — may generate incomplete or redundant tests","Requires test framework setup in the project (Jest, pytest, etc.) — does not work with projects lacking test infrastructure","Test execution adds latency to the implementation phase (typically 30-60 seconds per test suite run)","Cannot validate test quality beyond pass/fail — does not measure semantic coverage or edge case handling"],"requires":["Test framework installed and configured (Jest, pytest, Vitest, etc.)","Test runner accessible from project root","Claude Code (Sonnet 4.6 or Opus 4.6)"],"input_types":["feature/bugfix specification from /spec planning phase","existing test files and patterns in the codebase"],"output_types":["generated test files (e.g., .test.ts, .test.py)","implementation code that passes all tests","test execution logs and coverage reports"],"categories":["code-generation-editing","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-maxritter--pilot-shell__cap_10","uri":"capability://memory.knowledge.codebase.aware.context.injection.with.selective.token.budgeting","name":"codebase-aware context injection with selective token budgeting","description":"Pilot Shell injects project-specific context into Claude's system prompt at session start, including extracted conventions, relevant code patterns, and project rules from the semantic index. The context injection is selective and respects Claude's token budget — only the most relevant patterns are injected based on the current task, preventing context window overflow. The system uses a context monitor to track which files are most relevant to the current task and prioritizes injection of related patterns.","intents":["I want Claude to understand project conventions without manually explaining them","I need Claude to have access to relevant code patterns without exceeding token limits","I want to ensure Claude uses the right patterns and conventions for the current task"],"best_for":["large codebases with strong architectural patterns","projects with non-obvious conventions or custom tooling","teams wanting to minimize context setup overhead"],"limitations":["Context injection is selective and may miss relevant patterns if the context monitor misidentifies task scope","Token budgeting is heuristic-based and may be overly conservative or aggressive","Injected context is static at session start — does not update if task scope changes mid-session","Context injection adds ~500ms to session startup time"],"requires":["Semantic index built via /sync command","Project rules and conventions extracted and stored"],"input_types":["semantic index from /sync","current task description","project configuration"],"output_types":["context injection payload (text)","injected into Claude's system prompt"],"categories":["memory-knowledge","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-maxritter--pilot-shell__cap_11","uri":"capability://safety.moderation.automated.code.review.and.style.enforcement","name":"automated code review and style enforcement","description":"The verification phase includes an automated code review agent that checks for style violations, architectural inconsistencies, and deviations from project conventions. The agent uses the extracted project rules and conventions to validate that generated code follows established patterns. Code that violates style or architectural rules is flagged and can block merges, providing automated enforcement of code quality standards without requiring manual review.","intents":["I want to ensure generated code follows project style and architectural conventions","I need automated detection of code quality issues before human review","I want to prevent architectural drift as the codebase evolves"],"best_for":["teams with strict code style and architectural standards","large codebases where architectural consistency is critical","projects where manual code review is a bottleneck"],"limitations":["Code review agent quality depends on the completeness of extracted project rules — incomplete rules lead to weak reviews","Architectural violations are detected heuristically and may have false positives or false negatives","Code review adds latency to the verification phase (typically 30-60 seconds)","Agent cannot understand business logic or functional correctness — only style and architectural patterns"],"requires":["Project rules and conventions extracted via /sync or /learn","Code style configuration (eslint, black, etc.)"],"input_types":["generated code","project rules and conventions","code style configuration"],"output_types":["code review report with violations and suggestions","pass/fail decision for merge"],"categories":["safety-moderation","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-maxritter--pilot-shell__cap_12","uri":"capability://automation.workflow.session.state.persistence.and.recovery","name":"session state persistence and recovery","description":"Pilot Shell persists session state (current task, implementation progress, test results, verification status) to disk, enabling recovery if a session crashes or is interrupted. The worker service maintains a session state file that tracks the current /spec task, implementation phase, and verification results. If a session is interrupted, the next session can resume from the last checkpoint, preventing loss of work and enabling recovery from failures.","intents":["I want to resume a /spec task if my session crashes","I need to track progress across multiple sessions on the same task","I want to avoid losing work if my machine crashes or connection drops"],"best_for":["developers working on long-running /spec tasks","teams in unreliable network environments","projects where task interruption is common"],"limitations":["Session recovery is best-effort — some state may be lost if the crash is severe","Persisted state is local to the machine — does not sync across team members","Session state files can accumulate and require periodic cleanup","Recovery may fail if the codebase has changed significantly since the session was interrupted"],"requires":["Pilot Shell worker service running","Write access to ~/.pilot/sessions/ directory"],"input_types":["session state (task, progress, results)"],"output_types":["persisted session state file","recovered session state on resume"],"categories":["automation-workflow","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-maxritter--pilot-shell__cap_2","uri":"capability://memory.knowledge.persistent.session.memory.with.semantic.codebase.indexing","name":"persistent session memory with semantic codebase indexing","description":"The /sync command builds a semantic search index of the entire codebase using embeddings, then stores project-specific context (architecture patterns, naming conventions, dependencies, test patterns) in a persistent memory store that survives across sessions. This context is automatically injected into Claude's context window at the start of each session, enabling Claude to understand project conventions without requiring manual context setup. The context monitor continuously tracks changes to key files and updates the index incrementally.","intents":["I want Claude to remember project conventions and architecture patterns across multiple sessions","I need Claude to understand the codebase structure without manually explaining it each time","I want to avoid repeating context setup when resuming work on a project"],"best_for":["teams working on large, complex codebases with strong architectural patterns","projects with non-obvious conventions or custom tooling that Claude needs to learn","developers who want to minimize context-window overhead by pre-indexing the codebase"],"limitations":["Initial /sync indexing can take 2-5 minutes on large codebases (10k+ files)","Semantic index requires embedding generation, which adds ~500ms per file on first run","Index becomes stale if codebase changes significantly between sessions — requires manual /sync refresh","Memory store is local to the machine; not automatically synced across team members (requires /vault for sharing)"],"requires":["Pilot Shell installed with memory subsystem enabled","Git repository with accessible .git directory","Sufficient disk space for semantic index (~100MB per 10k files)"],"input_types":["entire codebase (files, directory structure, git history)","project configuration files (package.json, pyproject.toml, etc.)"],"output_types":["semantic vector index stored in ~/.pilot/memory/","extracted project rules and conventions in JSON format","context injection payload for Claude's system prompt"],"categories":["memory-knowledge","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-maxritter--pilot-shell__cap_3","uri":"capability://memory.knowledge.project.specific.rules.and.conventions.extraction.via.learn","name":"project-specific rules and conventions extraction via /learn","description":"The /learn command captures non-obvious discoveries from the current session (e.g., 'this project uses a custom logger instead of console.log', 'all async functions must have timeout handling') and converts them into reusable skill files stored in ~/.pilot/skills/. These skills are automatically loaded into Claude's context for future sessions on the same project, and can be shared across teams via the /vault command. The system uses Claude to extract generalizable patterns from session interactions and format them as structured rules.","intents":["I want to capture lessons learned during a session so Claude remembers them next time","I need to document project-specific patterns that aren't in the codebase (e.g., error handling conventions)","I want to share discovered patterns with my team without manual documentation"],"best_for":["teams with implicit or undocumented project conventions","projects where knowledge is scattered across team members' heads","developers who want to build up a library of reusable project patterns over time"],"limitations":["Skill extraction quality depends on Claude's ability to generalize from examples — may capture overly specific or incorrect patterns","Skills are not automatically validated; incorrect rules can persist and mislead future sessions","Requires manual /learn invocation — does not auto-capture patterns without explicit user action","Skills are stored as text files and have no versioning or conflict resolution mechanism"],"requires":["Pilot Shell installed with skills subsystem","Active session with Claude Code","Write access to ~/.pilot/skills/ directory"],"input_types":["natural language description of discovered pattern or convention","code examples demonstrating the pattern"],"output_types":["skill file (YAML or JSON) stored in ~/.pilot/skills/","structured rule with examples and applicability conditions"],"categories":["memory-knowledge","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-maxritter--pilot-shell__cap_4","uri":"capability://memory.knowledge.team.knowledge.sharing.via.vault.with.git.backed.persistence","name":"team knowledge sharing via /vault with git-backed persistence","description":"The /vault command shares rules, commands, skills, hooks, and agents across a team by syncing them to a private Git repository. Each team member's local ~/.pilot/ and ~/.claude/ directories can be configured to pull from a shared vault repository, enabling centralized management of project conventions, custom hooks, and reusable agents. The system uses Git as the backing store and provides conflict resolution via simple merge strategies (last-write-wins or manual resolution).","intents":["I want to share project rules and conventions with my entire team","I need to ensure all team members use the same custom hooks and quality gates","I want to build a library of reusable agents and skills that the team can leverage"],"best_for":["teams with 3+ developers working on the same codebase","organizations wanting to enforce consistent quality standards across projects","teams building a library of reusable Pilot Shell extensions"],"limitations":["Requires a private Git repository (GitHub, GitLab, etc.) — adds operational overhead","Vault sync is manual (via /vault command) — does not auto-sync on every session","Merge conflicts in vault files require manual resolution — no built-in conflict resolution UI","Vault contents are not encrypted at rest — requires private repository access controls"],"requires":["Private Git repository (GitHub, GitLab, Gitea, etc.)","Git credentials configured on all team machines","Write access to the vault repository for all team members"],"input_types":["local rules, skills, hooks, and agents from ~/.pilot/","vault repository URL and credentials"],"output_types":["synced rules, skills, hooks, and agents in shared Git repository","updated local ~/.pilot/ directory with vault contents"],"categories":["memory-knowledge","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-maxritter--pilot-shell__cap_5","uri":"capability://automation.workflow.hooks.based.quality.enforcement.pipeline","name":"hooks-based quality enforcement pipeline","description":"A pre-commit and post-change hooks pipeline that intercepts code modifications and enforces quality standards before code can be committed or merged. The pipeline includes a file checker hook (validates syntax, linting, formatting), a context monitor hook (tracks changes to key files), and a tool redirect hook (intercepts Claude's tool calls and validates them against project rules). Hooks are defined in project-specific or team-wide configuration and are automatically applied to all code changes, making quality enforcement non-optional.","intents":["I want to prevent code that fails linting or formatting from being committed","I need to ensure Claude follows project-specific tool usage rules (e.g., only use approved APIs)","I want to track changes to critical files and trigger alerts or reviews when they change"],"best_for":["teams with strict code quality standards","projects where certain files (config, security, database schema) require special handling","developers who want to prevent Claude from using unapproved tools or APIs"],"limitations":["Hooks add latency to code changes (typically 500ms-2s per hook execution)","Hook failures block code commits — can be frustrating if hooks are overly strict","Hooks are project-specific and must be configured per project — no global defaults","Tool redirect hook only works with Claude Code's tool-calling interface — does not cover manual code edits"],"requires":["Pilot Shell installed with hooks subsystem","Hook configuration file in project root or ~/.pilot/hooks/","Linting/formatting tools installed (eslint, prettier, black, etc.)"],"input_types":["code changes (files, diffs)","Claude's tool calls (for tool redirect hook)","hook configuration (YAML or JSON)"],"output_types":["pass/fail validation results","linting and formatting errors","tool call validation results"],"categories":["automation-workflow","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-maxritter--pilot-shell__cap_6","uri":"capability://automation.workflow.worktree.based.isolated.task.execution","name":"worktree-based isolated task execution","description":"Each /spec task executes in an isolated Git worktree (a separate working directory linked to the same repository), preventing concurrent tasks from interfering with each other and enabling safe rollback if a task fails. The worktree is created at task start, code changes are made in isolation, and the worktree is merged back to the main branch only after verification passes. This architectural pattern enables safe parallel task execution and provides a natural rollback mechanism if verification fails.","intents":["I want to run multiple /spec tasks in parallel without them interfering with each other","I need a safe way to rollback a task if verification fails","I want to prevent accidental commits of incomplete or broken code"],"best_for":["teams running multiple Claude Code sessions in parallel","projects where task isolation is critical for safety","developers who want automatic rollback on verification failure"],"limitations":["Worktree creation adds ~1-2 seconds of overhead per task","Worktree merging can fail if there are conflicts with the main branch — requires manual conflict resolution","Worktrees consume disk space (one copy of the codebase per active task)","Worktree cleanup is manual if a task crashes — orphaned worktrees can accumulate"],"requires":["Git 2.7+ (worktree support)","Sufficient disk space for multiple worktree copies","Pilot Shell installed with worktree integration"],"input_types":["task specification from /spec command","main branch state"],"output_types":["isolated worktree with task-specific changes","merged changes back to main branch (on verification success)"],"categories":["automation-workflow","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-maxritter--pilot-shell__cap_7","uri":"capability://planning.reasoning.verification.and.regression.testing.agent","name":"verification and regression testing agent","description":"After implementation completes, a verification agent runs the full test suite, checks for regressions, and validates that the implementation meets the original specification. For bugfixes, the agent specifically checks that the bug is fixed and no new bugs are introduced. For features, the agent validates that all acceptance criteria are met. The agent can block code merges if verification fails, providing a quality gate before code reaches the main branch.","intents":["I want to ensure implemented code actually solves the original problem","I need to verify that bugfixes don't introduce new regressions","I want automated validation that feature implementations meet acceptance criteria"],"best_for":["teams with strict quality requirements","projects where regressions are costly or dangerous","developers who want automated validation before code merges"],"limitations":["Verification quality depends on test suite completeness — cannot catch bugs not covered by tests","Regression testing requires a comprehensive test suite — projects with poor test coverage will have weak verification","Verification adds latency to the /spec workflow (typically 1-3 minutes per task)","Acceptance criteria must be explicitly defined in the /spec plan — vague requirements lead to weak verification"],"requires":["Comprehensive test suite covering the feature or bugfix","Acceptance criteria explicitly defined in the /spec plan","Test runner accessible from project root"],"input_types":["implementation code from the implementation phase","test suite","original specification and acceptance criteria"],"output_types":["test execution results (pass/fail)","regression test results","verification report with pass/fail decision"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-maxritter--pilot-shell__cap_8","uri":"capability://tool.use.integration.mcp.server.integration.for.claude.code.tool.calling","name":"mcp server integration for claude code tool calling","description":"Pilot Shell exposes a Model Context Protocol (MCP) server that provides Claude Code with access to Pilot Shell commands (/spec, /sync, /learn, /vault) and project-specific tools via a standardized function-calling interface. The MCP server runs as a background service and handles tool schema registration, argument validation, and execution. This enables Claude Code to invoke Pilot Shell workflows programmatically rather than requiring manual slash command invocation.","intents":["I want Claude to automatically invoke /spec workflows without manual command entry","I need Claude to call project-specific tools and APIs through a standardized interface","I want to extend Claude's capabilities with custom tools defined in my project"],"best_for":["teams using Claude Code with Pilot Shell integration","projects with custom tools or APIs that Claude needs to call","developers who want Claude to autonomously invoke Pilot Shell workflows"],"limitations":["MCP server adds ~200ms latency per tool call (network overhead)","Tool schemas must be explicitly defined — no automatic schema generation from code","MCP server is single-threaded — concurrent tool calls are serialized","Tool execution errors are not automatically retried — requires Claude to handle failures"],"requires":["Claude Code (Sonnet 4.6 or Opus 4.6) with MCP support","Pilot Shell MCP server running (started automatically by pilot binary)","Tool schemas defined in project configuration"],"input_types":["tool call requests from Claude Code","tool arguments (JSON)"],"output_types":["tool execution results (JSON)","error messages on tool call failure"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-maxritter--pilot-shell__cap_9","uri":"capability://automation.workflow.quick.mode.for.low.complexity.tasks.without.planning.gates","name":"quick mode for low-complexity tasks without planning gates","description":"For tasks classified as low-complexity, Pilot Shell automatically activates Quick Mode, which bypasses the planning phase and approval gate, allowing direct implementation with quality hooks and TDD enforcement still active. Quick Mode is triggered automatically based on task complexity heuristics (e.g., single-file changes, simple bug fixes) and can be manually invoked with /spec --quick. This provides a fast path for simple tasks while maintaining quality standards.","intents":["I want to handle simple tasks quickly without waiting for plan approval","I need fast iteration on low-risk changes while still enforcing quality standards","I want to avoid planning overhead for trivial changes"],"best_for":["teams with a mix of simple and complex tasks","developers who want fast iteration on low-risk changes","projects where planning overhead is significant relative to task complexity"],"limitations":["Quick Mode complexity heuristics may misclassify tasks — simple-looking tasks can have hidden complexity","Bypassing planning can lead to missed edge cases or architectural issues","Quick Mode is not suitable for tasks affecting critical systems or security-sensitive code","No human review of the approach before implementation — relies entirely on verification to catch issues"],"requires":["Pilot Shell installed with Quick Mode support","Quality hooks and TDD enforcement configured"],"input_types":["task description","codebase context"],"output_types":["implemented code with tests","verification results"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":48,"verified":false,"data_access_risk":"high","permissions":["Claude Code (Sonnet 4.6 or Opus 4.6)","Pilot Shell installed globally at ~/.pilot/","Active project directory with git repository","Test framework installed and configured (Jest, pytest, Vitest, etc.)","Test runner accessible from project root","Semantic index built via /sync command","Project rules and conventions extracted and stored","Project rules and conventions extracted via /sync or /learn","Code style configuration (eslint, black, etc.)","Pilot Shell worker service running"],"failure_modes":["Requires explicit /spec invocation — does not auto-trigger on unstructured requests","Plan approval is synchronous and blocks implementation until human review","Feature vs bugfix classification relies on Claude's semantic understanding and may misclassify ambiguous tasks","Test generation quality depends on Claude's understanding of requirements — may generate incomplete or redundant tests","Requires test framework setup in the project (Jest, pytest, etc.) — does not work with projects lacking test infrastructure","Test execution adds latency to the implementation phase (typically 30-60 seconds per test suite run)","Cannot validate test quality beyond pass/fail — does not measure semantic coverage or edge case handling","Context injection is selective and may miss relevant patterns if the context monitor misidentifies task scope","Token budgeting is heuristic-based and may be overly conservative or aggressive","Injected context is static at session start — does not update if task scope changes mid-session","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.4708152499681965,"quality":0.5,"ecosystem":0.8,"match_graph":0.25,"freshness":0.75,"weights":{"adoption":0.25,"quality":0.25,"ecosystem":0.1,"match_graph":0.28,"freshness":0.12}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-05-24T12:16:22.062Z","last_scraped_at":"2026-05-03T13:56:59.049Z","last_commit":"2026-04-30T08:40:08Z"},"community":{"stars":1677,"forks":141,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=maxritter--pilot-shell","compare_url":"https://unfragile.ai/compare?artifact=maxritter--pilot-shell"}},"signature":"NKHDf4MVSvmOze1HiO5E8QzGAvbx1OJY8iC2uZHv42hT117atzwvt3oAZGSM4UkXZeGEjaYyjSqlIe6uildhAg==","signedAt":"2026-06-19T21:30:41.451Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/maxritter--pilot-shell","artifact":"https://unfragile.ai/maxritter--pilot-shell","verify":"https://unfragile.ai/api/v1/verify?slug=maxritter--pilot-shell","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}