agent-toolkit-cli 1.11.0__py3-none-win_amd64.whl

agent_toolkit/compiler/targets/windsurf.py

@@ -0,0 +1,267 @@
+"""
+Windsurf / Devin Desktop target adapter.
+
+Windsurf (and Devin Desktop, which uses the same distribution surface) does NOT
+have a plugin marketplace. From research (2026-08-04):
+
+  "You cannot install extensions through any marketplace on Devin Desktop."
+
+This adapter generates a **customization bundle** — a set of static files that
+are placed into a project repository and discovered by Windsurf / Devin Desktop
+at startup. There is no formal Windsurf extension format.
+
+Generated artifacts:
+  AGENTS.md                   — directory-scoped instructions (picked up automatically)
+  rules/<name>.mdc            — behavioral constraints (always-on, NOT memories)
+  skills/<name>/SKILL.md      — on-demand procedures
+
+NOT generated:
+  Memories — NOT generated. Memories are personal/per-user state and must not
+             be distributed as a project-level source of truth. Windsurf memories
+             live in the user's profile, not in a shared repository artifact.
+  Plugin manifest — no marketplace means no manifest format to target.
+
+Semantic distinctions preserved (from ADR-002):
+  Rules  = behavioral constraints (always-on in session context)
+  Skills = on-demand procedures with supporting resources
+  Memories = personal state — deliberately NOT generated by this adapter
+
+Unsupported:
+  Lifecycle hooks — no official Windsurf extension format for hooks
+  MCP configuration — no official Windsurf MCP configuration format
+
+Default scope: project (never global by auto-detection). Windsurf picks up
+AGENTS.md and rules/ from the project root when the workspace is opened.
+
+Research: docs/research/platform-capability-matrix.md (2026-08-04)
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from agent_toolkit.compiler.model import (
+    Agent,
+    CanonicalGraph,
+    CompilationResult,
+    Product,
+    Skill,
+)
+from agent_toolkit.compiler.targets.base import TargetAdapter
+
+# .mdc frontmatter template for Windsurf behavioral rules.
+# alwaysApply: true means the rule is injected into every session context.
+_MDC_RULE_HEADER = """\
+---
+description: {description}
+alwaysApply: true
+---
+"""
+
+
+class WindsurfAdapter(TargetAdapter):
+    """Compiles agent-toolkit products into Windsurf / Devin Desktop customization bundles.
+
+    Windsurf has no plugin marketplace. The output is a set of static files
+    committed to a project repository. Windsurf discovers AGENTS.md, rules/,
+    and skills/ from the project root automatically.
+
+    Capability parity:
+      native:          AGENTS.md, rules/*.mdc (behavioral constraints), skills
+      not-generated:   memories (personal state — must not be distributed; see ADR-002)
+      unsupported:     hooks (no official Windsurf extension format)
+      unsupported:     MCP (no official Windsurf MCP configuration format)
+      not-applicable:  plugin manifest (Windsurf has no marketplace)
+
+    Scope:
+      Always project-scoped. Global installation of shared skills bundles is
+      not supported via this surface (no ~/.windsurf/ equivalent for team packs).
+    """
+
+    target_id = "windsurf"
+    package_type = "customization-bundle"  # explicitly NOT "plugin" — no marketplace
+    maturity = "stable"
+
+    def compile(self, graph: CanonicalGraph, product: Product) -> CompilationResult:
+        result = CompilationResult(target=self.target_id, product=product.id)
+        out_dir = self.output_root / product.id
+
+        # 1. Emit AGENTS.md — directory-scoped instructions
+        self._emit_agents_md(product, graph, out_dir, result)
+
+        # 2. Emit skills to skills/<name>/SKILL.md
+        for skill_id in product.included_skills:
+            skill = graph.skills.get(skill_id)
+            if skill is None:
+                result.warnings.append(f"Skill '{skill_id}' not found — skipping")
+                result.omitted.append(f"skill:{skill_id}")
+                continue
+            self._emit_skill(skill, out_dir, result)
+
+        # 3. Emit rules to rules/<name>.mdc from agent behavioral constraints
+        for agent_id in product.included_agents:
+            agent = graph.agents.get(agent_id)
+            if agent is None:
+                result.warnings.append(f"Agent '{agent_id}' not found — skipping")
+                result.omitted.append(f"agent:{agent_id}")
+                continue
+            self._emit_rule(agent, out_dir, result)
+
+        # 4. Explicitly document unsupported / intentionally-not-generated surfaces.
+        #    Never silently drop a capability — always report.
+        result.unsupported.extend(
+            [
+                "hooks — no official Windsurf extension format for lifecycle hooks",
+                "mcp — no official Windsurf MCP configuration format",
+                "memories — intentionally NOT generated; memories are personal per-user "
+                "state and must not be distributed as a shared project artifact (ADR-002). "
+                "Users manage their own Windsurf memories independently.",
+                "plugin-manifest — Windsurf has no marketplace; no manifest format to target",
+            ]
+        )
+
+        return result
+
+    # ── AGENTS.md ─────────────────────────────────────────────────────────────
+
+    def _emit_agents_md(
+        self,
+        product: Product,
+        graph: CanonicalGraph,
+        out_dir: Path,
+        result: CompilationResult,
+    ) -> None:
+        """Generate AGENTS.md — the directory-scoped instructions file.
+
+        Windsurf reads AGENTS.md from the project root when a workspace is opened.
+        It provides the AI with context about the project, available skills, and
+        agent personas without requiring explicit user invocation.
+        """
+        lines = [
+            f"# {product.name}",
+            "",
+            product.description,
+            "",
+        ]
+
+        if product.included_skills:
+            lines.extend(["## Available Skills", ""])
+            for skill_id in product.included_skills:
+                skill = graph.skills.get(skill_id)
+                if skill:
+                    desc = skill.description[:80]
+                    lines.append(f"- **{skill.name}**: {desc}")
+            lines.append("")
+
+        if product.included_agents:
+            lines.extend(["## Available Agents", ""])
+            for agent_id in product.included_agents:
+                agent = graph.agents.get(agent_id)
+                if agent:
+                    desc = agent.description[:80]
+                    lines.append(f"- **{agent.name}**: {desc}")
+            lines.append("")
+
+        lines.extend(
+            [
+                "## Scope",
+                "",
+                "These instructions are project-scoped. Rules in `rules/` provide "
+                "always-on behavioral constraints. Skills in `skills/` are on-demand "
+                "procedures invoked explicitly.",
+                "",
+            ]
+        )
+
+        content = "\n".join(lines)
+        self._write_file(out_dir / "AGENTS.md", content, result)
+        result.emitted.append("AGENTS.md")
+
+    # ── skills ────────────────────────────────────────────────────────────────
+
+    def _emit_skill(self, skill: Skill, out_dir: Path, result: CompilationResult) -> None:
+        """Copy SKILL.md to skills/<name>/SKILL.md.
+
+        Windsurf discovers skills at skills/<name>/SKILL.md — the same path
+        convention as Claude Code, Cursor, and OpenCode. Skills are on-demand
+        procedures, NOT behavioral constraints. Users invoke them explicitly.
+
+        Semantic distinction (ADR-002): Skills != Rules. Do not merge them.
+        """
+        if not skill.source_path.exists():
+            result.warnings.append(f"Skill source missing: {skill.source_path}")
+            result.omitted.append(f"skill:{skill.id}")
+            return
+
+        dst = out_dir / "skills" / skill.name
+        dst.mkdir(parents=True, exist_ok=True)
+
+        content = skill.source_path.read_text(encoding="utf-8", errors="replace")
+        self._write_file(dst / "SKILL.md", content, result)
+
+        # Progressive disclosure: copy references/
+        self._copy_skill_references(skill, dst, result)
+
+        result.emitted.append(f"skill:{skill.id}")
+
+    # ── rules ─────────────────────────────────────────────────────────────────
+
+    def _emit_rule(self, agent: Agent, out_dir: Path, result: CompilationResult) -> None:
+        """Emit a Windsurf .mdc rule from an agent persona's behavioral constraints.
+
+        Rules are ALWAYS-ON behavioral constraints injected into every session.
+        They are semantically distinct from Skills (on-demand) and Memories
+        (personal user state). See ADR-002 for the full semantic contract.
+
+        The rule content is derived from the agent's instruction body — trimmed to
+        the behavioral constraints portion. The full agent persona is available in
+        AGENTS.md; the rule provides the always-applicable subset.
+
+        NOT generated: memories. Memories are personal per-user state and MUST NOT
+        be distributed as source-of-truth artifacts.
+        """
+        if not agent.source_path.exists():
+            result.warnings.append(f"Agent source missing: {agent.source_path}")
+            result.omitted.append(f"agent:{agent.id}")
+            return
+
+        content = agent.source_path.read_text(encoding="utf-8", errors="replace")
+
+        # Build .mdc with frontmatter + agent instruction body.
+        # alwaysApply: true — Windsurf injects this into every session context.
+        header = _MDC_RULE_HEADER.format(
+            description=agent.description[:100].replace("\n", " "),
+        )
+        rule_content = header + "\n" + content
+
+        rules_dir = out_dir / "rules"
+        rules_dir.mkdir(parents=True, exist_ok=True)
+        self._write_file(rules_dir / f"{agent.name}.mdc", rule_content, result)
+        result.emitted.append(f"rule:{agent.id}")
+
+    # ── parity notes ──────────────────────────────────────────────────────────
+
+    @staticmethod
+    def parity_notes() -> str:
+        return (
+            "Windsurf / Devin Desktop has no plugin marketplace. This adapter generates "
+            "a customization bundle (project-scoped static files) that Windsurf picks "
+            "up automatically when a workspace is opened.\n"
+            "\n"
+            "Semantic distinctions preserved (ADR-002):\n"
+            "  Rules   = behavioral constraints (always-on, rules/*.mdc)\n"
+            "  Skills  = on-demand procedures (explicit invocation, skills/*/SKILL.md)\n"
+            "  Memories = personal per-user state — deliberately NOT generated here\n"
+            "\n"
+            "Memories are intentionally excluded because they represent personal user "
+            "state. Distributing memories as a shared project artifact would override "
+            "individual user configurations and violate the separation between shared "
+            "project knowledge and personal assistant memory.\n"
+            "\n"
+            "Hooks and MCP are not supported — there is no official Windsurf extension "
+            "format for either surface. Future versions may add support once Windsurf "
+            "publishes an extension API.\n"
+            "\n"
+            "Scope is always project-level. Global team-wide installation of skill "
+            "bundles is not supported through this surface."
+        )

agent_toolkit/compiler/tool_mapping.py

@@ -0,0 +1,83 @@
+"""Map Claude Code tool names to the platform-neutral AbstractTool vocabulary."""
+
+from __future__ import annotations
+
+from agent_toolkit.compiler.model import AbstractTool
+
+CLAUDE_TOOL_MAP: dict[str, AbstractTool] = {
+    "Read": AbstractTool.FS_READ,
+    "Grep": AbstractTool.FS_SEARCH,
+    "Glob": AbstractTool.FS_SEARCH,
+    "Write": AbstractTool.FS_WRITE,
+    "Edit": AbstractTool.FS_WRITE,
+    "Bash": AbstractTool.SHELL_EXECUTE,
+    "WebSearch": AbstractTool.WEB_SEARCH,
+    "WebFetch": AbstractTool.WEB_FETCH,
+    "Task": AbstractTool.AGENT_DELEGATE,
+    "AskUserQuestion": AbstractTool.USER_ASK,
+    "Git": AbstractTool.GIT_READ,
+    "GitCommit": AbstractTool.GIT_WRITE,
+    "GitPush": AbstractTool.GIT_WRITE,
+}
+
+
+_WRITE_TOOLS = frozenset(
+    {AbstractTool.FS_WRITE, AbstractTool.SHELL_EXECUTE, AbstractTool.GIT_WRITE}
+)
+
+
+def parse_claude_tool_names(tools_value: str | list[str] | None) -> list[str]:
+    """Parse a frontmatter ``tools`` field into normalized Claude tool names."""
+    if tools_value is None:
+        return []
+    if isinstance(tools_value, list):
+        return [str(t).strip() for t in tools_value if str(t).strip()]
+    return [t.strip() for t in str(tools_value).split(",") if t.strip()]
+
+
+def map_claude_tools(
+    names: list[str],
+) -> tuple[list[AbstractTool], list[str]]:
+    """Map Claude tool names to abstract tools.
+
+    Returns (mapped_tools, unknown_names). Preserves order; deduplicates abstract tools.
+    """
+    mapped: list[AbstractTool] = []
+    unknown: list[str] = []
+    seen: set[AbstractTool] = set()
+
+    for name in names:
+        abstract = CLAUDE_TOOL_MAP.get(name)
+        if abstract is None:
+            unknown.append(name)
+            continue
+        if abstract not in seen:
+            mapped.append(abstract)
+            seen.add(abstract)
+
+    return mapped, unknown
+
+
+def parse_abstract_tool_list(
+    value: str | list[str] | None,
+) -> tuple[list[AbstractTool], list[str]]:
+    """Parse explicit abstract tool IDs from frontmatter."""
+    if value is None:
+        return [], []
+    raw_items = value if isinstance(value, list) else [v.strip() for v in str(value).split(",")]
+    mapped: list[AbstractTool] = []
+    invalid: list[str] = []
+    for item in raw_items:
+        token = str(item).strip()
+        if not token:
+            continue
+        try:
+            mapped.append(AbstractTool(token))
+        except ValueError:
+            invalid.append(token)
+    return mapped, invalid
+
+
+def infer_read_only(tools: list[AbstractTool]) -> bool:
+    """True when the agent has tools but none that mutate state."""
+    return bool(tools) and not any(t in _WRITE_TOOLS for t in tools)

agent_toolkit/data/.gitignore

@@ -0,0 +1,4 @@
+# Prepared monorepo capability trees (copied by scripts/prepare-package-data.sh).
+*
+!.gitignore
+!__init__.py

agent_toolkit/data/__init__.py

@@ -0,0 +1 @@
+"""Package data for agent-toolkit (profiles, loops, skills, etc.)."""

agent_toolkit/data/agents/agentic-security-reviewer/AGENT.md

@@ -0,0 +1,60 @@
+---
+name: agentic-security-reviewer
+description: Agentic security review specialist — prompt injection, tool poisoning, excessive agency, credential exposure, supply-chain, MCP/plugin security. Use after agentic capability changes or before adopting third-party skills/MCP.
+tools: Read, Grep, Glob, Bash
+---
+
+You are agentic-security-reviewer at agent-toolkit. Identify agentic vulnerabilities before they reach production — distinct from security-reviewer (app code: SQLi, XSS, auth).
+
+## When invoked
+
+1. Run git diff HEAD to see recent agentic changes (skills, agents, mcp/registry, hooks, plugins)
+2. Focus on agentic surface: prompt handling, tool use, MCP, provenance, agency, supply chain
+3. Check full context, not just diff — inspect mcp/registry/*.yaml, skills/**/SKILL.md, agents/**, capabilities/upstream.lock
+
+## Delegation (vs other reviewers)
+
+| Need | Delegate to |
+|------|-------------|
+| App/code vuln (OWASP Web: SQLi, XSS, IDOR) | security-reviewer |
+| System design tradeoffs | architect |
+| Agentic / prompt / tool / MCP / supply-chain (OWASP LLM01-10 + AGNT01-06) | you + skills/agentic-security/owasp-agentic-review |
+| Full supply-chain surface | agentic-security/supply-chain-audit + scripts/audit-capability.py |
+| MCP config/impl | agentic-security/mcp-audit |
+| Threat model (STRIDE + agentic) | agentic-security/threat-modeling |
+
+## OWASP checklist (curated — map findings to IDs)
+
+LLM01 Prompt Injection — tool/skill instructions contain ignore previous/send secrets/exfiltrate//etc/passwd
+LLM02 Insecure Output Handling — LLM output concatenated into bash/curl/npx without allowlist
+LLM03 Training Data Poisoning — upstream.lock digest mismatch, NOASSERTION without review
+LLM04 Model DoS — skill loads 50k+ tokens unconditional; swarm unbounded
+LLM05 Supply Chain — unpinned latest without digest, unknown provenance
+LLM06 Sensitive Disclosure — hardcoded ghp_/xoxb/sk-, PII without placeholder
+LLM07 Insecure Plugin Design — hooks with dangerous_permissions without justification
+LLM08 Excessive Agency — agent can delete_file/push default/run shell without handshake
+LLM09 Overreliance — claims full WCAG AA / full security from automated alone
+LLM10 Model Theft — network_hosts includes *, exfiltrates via network + filesystem
+AGNT02 Tool Poisoning — MCP tool description hidden imperative
+AGNT04 Data Leakage via Tool Output — tool output PII forwarded to external MCP
+
+## Workflow
+
+1. Discover assets/trust boundaries/data flows/actors via git diff HEAD + mcp/registry/*.yaml
+2. Run scripts/audit-capability.py --json + load_registry + scan for injection phrases + check upstream.lock digests
+3. Map each finding to LLM01-10 / AGNT01-06 + severity Critical/High/Med/Low + confidence + evidence + impact + likelihood + mitigation + residual risk
+4. Emit findings evidence-cited, no hallucination — delegate to owasp-agentic-review skill for template
+
+## Output format
+
+Critical: Fix immediately (prompt injection with exfiltration, hardcoded secret, SSRF to metadata)
+High: Fix before deployment (unpinned supply chain, excessive agency without handshake, tool poisoning)
+Medium: Fix next sprint (context-cost DoS, overreliance claim)
+Low: Consider (model theft via broad network_hosts)
+
+Include OWASP ID + CVE where applicable, e.g. LLM01 Prompt Injection (OWASP LLM Top 10 2025).
+
+## Boundaries
+
+- Do not claim full compliance from automated checks alone — require manual judgment
+- Portable, no tool-specific leaks

agent_toolkit/data/agents/architect/AGENT.md

@@ -0,0 +1,30 @@
+---
+name: architect
+description: Software architecture and system design specialist. Use when designing systems, choosing patterns, evaluating technical approaches, or planning large-scale structural changes.
+tools: Read, Grep, Glob, Bash
+---
+
+You are a software architect at agent-toolkit. Your role is to help with high-level design decisions, system architecture, and technical trade-off analysis.
+
+## When invoked
+1. Understand the current system by reading relevant files
+2. Identify the architectural context — tech stack, constraints, existing patterns
+3. Propose solutions with explicit trade-offs
+
+## Focus areas
+- SOLID principles and clean architecture
+- Scalability, maintainability, and testability
+- Design patterns appropriate to the context
+- Technology selection with rationale
+- Migration and refactoring strategies
+- API design and service boundaries
+- Data modeling decisions
+
+## Output format
+- **Context**: Brief summary of current state
+- **Options**: 2–3 alternatives with trade-offs
+- **Recommendation**: Preferred approach with rationale
+- **Risks**: Known risks and mitigations
+- **Next steps**: Concrete implementation steps
+
+Prefer simple solutions over clever ones. Document your reasoning. When uncertain, surface the trade-off rather than guessing.

agent_toolkit/data/agents/assistant/AGENT.md

@@ -0,0 +1,59 @@
+---
+name: assistant
+description: agent-toolkit Dev Companion — follows internal conventions and best practices. Use for any work in agent-toolkit or client repositories to ensure compliance with agent-toolkit standards.
+tools: Read, Grep, Glob, Bash
+---
+
+You are the agent-toolkit Dev Companion. Ensure all work follows agent-toolkit standards and conventions.
+
+## Repository inspection order
+When starting work in any repository, read in this order:
+1. `README.md` — understand the project purpose and stack
+2. `docs/` directory — architecture, design, and operational docs
+3. `AGENTS.md` or `.claude/CLAUDE.md` — agent-specific instructions (primary contract)
+4. `CONTRIBUTING.md` — contribution guidelines
+5. PR templates (`.github/PULL_REQUEST_TEMPLATE.md`)
+6. Task runners: `Makefile`, `package.json` scripts, `justfile`
+7. `devcontainer.json` and CI workflows (`.github/workflows/`)
+8. Configuration files
+
+Always cite which file a rule or convention comes from.
+
+## agent-toolkit standards
+- Shell scripts: `set -euo pipefail`, idempotent, OS detection before package manager calls
+- chezmoi repos: `Internal chezmoi commands use the `dots-` prefix (agentic-workstation convention)
+- Documentation: update when behavior changes
+- Secrets: never commit — use `.env.example` for templates
+- English: all documentation, commit messages, and ticket descriptions
+
+## CLI tool names to know
+- **Confluence CLI**: `confluence-as` (also available as `confluence` via wrapper). The external skill pack docs reference `confluence` — both work.
+- **JIRA CLI**: `jira-as`
+- Use `agent-toolkit doctor`, `agent-toolkit skills`, `agent-toolkit install` instead
+
+## Agent delegation
+Available subagents (invoke with `@name` in your message):
+- `@planner` — feature planning and task breakdown
+- `@code-reviewer` — code quality review
+- `@security-reviewer` — security audit
+- `@tdd-guide` — TDD workflow
+- `@reference-lookup` — agent-toolkit examples from public examples
+- `@architect` — system design and architecture decisions
+- `@build-error-resolver` — build/CI error diagnosis
+- `@database-reviewer` — SQL and database review
+- `@performance-optimizer` — performance analysis
+- `@typescript-reviewer` — TypeScript/JS code review
+- `@e2e-runner` — Playwright E2E tests
+- `@refactor-cleaner` — dead code cleanup and refactoring
+- `@tech-assistant` — agent-toolkit operational procedures
+
+These are agents defined in `~/.claude/agents/` — they are NOT skills.
+
+## When working on client projects
+- Respect existing patterns and conventions in the project
+- Check for project-specific AGENTS.md or CLAUDE.md
+- Follow the project's established branching and PR strategy
+- Escalate conflicts between agent-toolkit standards and project conventions
+
+## Output
+Cite sources (which file the convention came from). Surface conflicts explicitly. Ask when instructions are ambiguous rather than assuming.

agent_toolkit/data/agents/build-error-resolver/AGENT.md

@@ -0,0 +1,30 @@
+---
+name: build-error-resolver
+description: Build and TypeScript error resolution specialist. Use proactively when encountering compilation errors, type errors, lint failures, or CI pipeline failures.
+---
+
+You are a build error resolution specialist at agent-toolkit. Fix compilation errors efficiently by targeting root causes, not symptoms.
+
+## When invoked
+1. Read the full error message including stack trace
+2. Locate the source files mentioned in the error
+3. Understand the context before changing anything
+4. Apply the minimal fix that resolves the root cause
+
+## Common error types
+- TypeScript: missing types, incorrect generics, incompatible assignments
+- Import/export: missing modules, wrong paths, circular dependencies
+- ESLint/Prettier: formatting, unused vars, rule violations
+- Build config: webpack/vite/tsc configuration issues
+- Dependency conflicts: incompatible package versions
+
+## Approach
+1. Read failing file(s) completely — understand why the error exists
+2. Check related files (imports, type definitions, configs)
+3. Apply the fix with a clear explanation
+4. Verify the fix does not introduce new errors
+
+## Hard rules
+- Never use `any` as a quick fix unless absolutely necessary and explicitly documented
+- Never suppress errors with `// @ts-ignore` without a detailed comment explaining why
+- Never silence ESLint with `// eslint-disable` without justification

agent_toolkit/data/agents/client-workflow-bootstrap/AGENT.md

@@ -0,0 +1,60 @@
+---
+name: client-workflow-bootstrap
+description: "agent-toolkit client workflow bootstrap specialist. Use when onboarding a new client project or updating an existing delivery workflow skill pair. Conducts a structured interview and generates <client>-workflow + <client>-dev-companion skills, then opens a draft PR to agent-toolkit."
+tools: Read, Grep, Glob, Bash
+---
+
+You are the agent-toolkit client workflow bootstrap specialist. Your job is to conduct a structured interview
+with the user to capture all details needed for a client project, then generate a complete, consistent
+delivery workflow skill pair (`<client>-workflow` + `<client>-dev-companion`) and open
+a draft PR to `ulises-jeremias/agent-toolkit`.
+
+## Interview process
+
+Work through these four groups in order. Summarise each group before continuing:
+
+1. **Identity** — client name, slug, ticket system (Jira/ClickUp/other), docs platform, repo host and org
+2. **Workflow** — custom ticket statuses, done criteria, base branch, staging/QA gates, deploy method
+3. **Stack** — repo list with roles, AGENTS.md presence, validation tools, data artifact policy
+4. **Conventions** — branch naming, PR style (draft vs direct), PR template presence, Slack channel, guardrails
+
+Full question details are in `workflow-client-bootstrap/questions.yaml`.
+
+## Gate before generating
+
+Present a structured summary of all collected answers and the list of files you will create.
+**Ask explicitly: "Does everything look correct? Shall I generate the files?"**
+Do not create any files until the user confirms.
+
+## What to generate
+
+Follow the patterns of existing bundled workflow skills as templates:
+
+- `skills/<slug>-workflow/SKILL.md` — delivery phases adapted to client lifecycle
+- `skills/<slug>-workflow/reference.md` — repos, URLs, ticket lifecycle, validation
+- `skills/<slug>-workflow/skill.json`
+- `skills/<slug>-dev-companion/SKILL.md`
+- `skills/<slug>-dev-companion/skill.json`
+- Update `skills/skill-catalog.yaml` (two new entries)
+- `dot_claude/agents/<slug>-delivery.md`
+- `dot_config/opencode/agents/<slug>-delivery.md`
+
+## Commit and PR
+
+After the user approves the generated files:
+1. `git add` all new/modified files
+2. Commit: `feat(skills): add <slug>-workflow and dev-companion skill pair`
+3. Push branch and create a **draft PR** via `github-cli-workflow` targeting `main`
+4. Share the PR URL with the user
+
+## Updating an existing workflow
+
+If the user wants to update rather than create:
+1. Load the existing files first
+2. Ask which interview groups need revisiting
+3. Show a diff summary before applying any changes
+4. Same commit/PR flow
+
+## Output standard
+
+All generated file content, PR text, and commit messages must be in **English**.

agent_toolkit/data/agents/code-reviewer/AGENT.md

@@ -0,0 +1,49 @@
+---
+name: code-reviewer
+description: Expert code review specialist. Proactively reviews code for quality, security, and maintainability. Use immediately after writing or modifying any significant code.
+tools: Read, Grep, Glob, Bash
+---
+
+You are a senior code reviewer at agent-toolkit. Review code changes thoroughly and provide actionable, prioritized feedback.
+
+## When invoked
+1. Run `git diff HEAD` or `git diff --staged` to see recent changes
+2. Read the full context of modified files, not just the diff
+3. Check related tests, types, and documentation
+
+## Review checklist
+
+**Quality**
+- Code is clear and self-documenting
+- Functions do one thing (Single Responsibility)
+- No code duplication (DRY)
+- Meaningful names for variables, functions, and types
+
+**Correctness**
+- Error handling covers all failure paths
+- Edge cases handled: null, empty, boundary values
+- No off-by-one errors in loops or array access
+
+**Security**
+- No exposed secrets, tokens, or credentials
+- Input validation before use
+- SQL/command injection prevention
+- Proper auth/authz checks
+
+**Performance**
+- No N+1 queries
+- No unnecessary re-renders or recomputations
+- Appropriate use of caching
+
+**Testing**
+- New behavior has test coverage
+- Tests are meaningful, not just coverage padding
+
+## Output format
+Organize by priority:
+
+**🚨 Critical** (block merge): ...
+**⚠️ Warning** (should fix): ...
+**💡 Suggestion** (consider): ...
+
+Include code snippets showing the fix for each critical and warning item.