team-shinchan

Analyze work tracker events for observability insights

Deep analysis with Hiroshi(Oracle)

Autonomous execution from idea to working code

Backend development with Bunta (API, database, server logic)

Large-scale project orchestration with Himawari (Atlas)

Structured problem exploration before requirements (Problem Reframe, Alternatives, Recommendation)

View and manage workflow turn budgets

Expert agents debate to find optimal solutions

Deep codebase exploration with Shiro(Explorer)

Compare design mockups against implementation to detect UI mismatches (colors, layout, typography)

DevOps and infrastructure with Masao (CI/CD, Docker, cloud)

View agent evaluations and detect regressions

Delete specific memories

Frontend development with Aichan (UI, React, CSS, accessibility)

Guide for using Team-Shinchan plugin

Analyze cascade impact of changing a component using the ontology dependency graph

Quick code implementation with Bo (features, bug fixes, utilities)

Add new learning to memory

Run plugin consistency checks (agent, structure, drift)

Analyze changed files and ensure verify-* skill coverage integrity

View and manage learned memories

Micro-task execution with per-task two-stage review (spec compliance + code quality)

Query, manage, and visualize the project-level ontology

Explicitly invoke Shinnosuke to orchestrate through the integrated workflow

Create systematic work plans with Nene(Planner)

Persistently loops until task is fully complete

Automate version bump across plugin.json, marketplace.json, README.md, and CHANGELOG.md

Hidden requirements analysis with Misae (risks, edge cases, implicit needs)

Research and documentation with Masumi (Librarian)

Resume an interrupted workflow from where it left off

Code review and verification with Action Kamen (correctness, security, quality)

Generate session summary from Work Tracker logs

Configure Claude Code's statusLine to display the Team-Shinchan HUD

First-time setup and health check for Team-Shinchan plugin

Start a new task with the integrated workflow

Show current workflow status

4-phase systematic debugging with root-cause analysis

Enforce TDD RED-GREEN-REFACTOR cycle during implementation

Maximum parallel execution mode

Block completion claims without fresh verification evidence

Validate agent schema compliance and shared reference integrity

Validate token budget compliance for all configuration files

Validate cross-references, stage matrix, and debate configuration consistency

Run all verify-* skills sequentially for comprehensive validation

Validate memory system configuration and file structure

Validate skill schema, format compliance, and input validation rules

Validate workflow state schema, error handling, part numbering, and quick-fix paths

Image and PDF analysis with Ume (screenshots, mockups, diagrams)

Query work tracker JSONL events

All execution agents follow these four principles before writing a single line of code.

> **Note**: This file is a **reference template** shipped with the plugin.

- **Category**: architecture

- **Category**: performance

- **Category**: security

- **Category**: sparse

- **Category**: tech-selection

> Used by micro-execute skill AFTER spec compliance passes. Verifies the code is well-built.

> Used by micro-execute skill to dispatch implementation subagents per micro-task.

> Used by micro-execute skill to verify each micro-task matches its specification exactly.

| Emoji | Agent | Role |

<!-- Quality Gate — Guardrails & Quality Gates -->

You are **Action Kamen**. You verify and approve all work before completion.

You are **Aichan**. You specialize in frontend development and UI/UX.

You are **Bo**. You are the Execution PO — you receive Phases from Shinnosuke, route sub-tasks to domain specialists, and implement general coding tasks directly.

You are **Bunta**. You specialize in backend development, APIs, and databases.

You are **Himawari**. You manage large-scale, complex projects that require coordination across multiple domains.

You are **Hiroshi**. You provide high-level strategic advice and help with complex debugging.

You are **Kazama**. You handle complex tasks that require extended focus and minimal supervision.

You are **Masao**. You specialize in infrastructure, CI/CD, and deployment.

You are **Masumi**. You find and organize documentation and information.

Midori orchestrates structured discussions among expert agents to reach optimal decisions. 🌻 [Midori]

You are **Misae**. You own Stage 1 (Requirements) — interviewing users, collecting requirements, analyzing risks, and producing REQUESTS.md.

```

You are enhanced with **Team-Shinchan**. **You are Shinnosuke, the CONDUCTOR.**

You are **Shiro**. You quickly explore and navigate codebases.

You are **Ume**. You analyze visual content like images, screenshots, and PDFs.

Use when you need to analyze work tracker data for agent metrics or session stats.

Use when you need deep analysis of code, bugs, performance, or architecture issues.

Use when you want autonomous completion from requirements to verification without intervention.

Use when you need backend development for APIs, databases, servers, or endpoints.

Use when you have a large-scale, multi-phase project requiring orchestrated execution.

Use when you need structured problem exploration before writing requirements.

Use when you need to view or manage workflow turn budgets and limits.

Use when you want multiple agents to debate and find optimal solutions.

Use when you need deep codebase exploration to find code, patterns, or references.

Use when you need to compare design mockups against implementation for UI fidelity.

Use when you need DevOps work like CI/CD, Docker, deployment, or pipelines.

Use when you need to view agent evaluation history or detect performance regressions.

Use when you need to delete specific outdated or incorrect memories.

Use when you need frontend development for UI components, React, CSS, or styling.

Use when you need guidance on Team-Shinchan agents, skills, or memory system.

Use when you need to analyze cascade impact of changing a component.

Use when you need quick code implementation for features, bug fixes, or utilities.

Use when you want to manually add new learnings or rules to memory.

Use when you need to run plugin consistency checks or drift detection.

Use when you need to analyze changes and ensure verify-* skill coverage.

Use when you need to view or manage learned memories and preferences.

Use when you need micro-task execution with per-task two-stage review.

Use when you need to query, manage, or visualize the project-level ontology.

Use when you want to orchestrate through the full integrated workflow stages.

Use when you need to create systematic work plans or design solutions.

Use when you need persistent looping until a task is fully complete.

Use when you need to automate version bumps across all required files.

Use when you need to discover hidden requirements, risks, or edge cases.

Use when you need web research, documentation lookup, or knowledge gathering.

Use when you need to resume an interrupted workflow from where it left off.

Use when you need code review, verification, or quality checks on your work.

Use when you need to generate or view a session summary from work tracker logs.

Use when you need to install or remove the Team-Shinchan HUD statusline.

Use when you need first-time installation onboarding or a plugin health check.

Use when you want to start a new task with the integrated workflow.

Use when you need to check current workflow status, stage, or pending items.

Use when a test fails, a bug is reported, or unexpected behavior occurs. 4-phase root-cause process.

Use when writing new code or fixing bugs during Stage 3 execution. Enforces RED-GREEN-REFACTOR cycle.

Use when you need to complete tasks quickly with parallel agent execution.

Use when claiming a task is complete, before commits, or before PR creation.

Use when you need to validate agent schema compliance and reference integrity.

Use when you need to validate token budget compliance for configuration files.

Use when you need to validate cross-references, stage matrix, or debate consistency.

Use when you need to execute all verify-* skills for an integrated validation report.

Use when you need to validate memory system configuration and file structure.

Use when you need to validate skill schema, format, or input validation rules.

Use when you need to validate workflow state schema or error handling.

Use when you need to analyze images, PDFs, screenshots, or mockups.

Use when you need to query work tracker events by recency, agent, or session.

Use when creating or improving a skill using TDD process with trigger scenarios and pressure validation.

30 hooks across 9 events