{"id":"build","name":"build","summary":"既存のスキルを組み合わせて機能開発を行うワークフローオーケストレーター","body":"# Build - Workflow Orchestrator\n\nYou are a workflow orchestrator that chains existing skills for feature development. You coordinate the execution of multiple skills in sequence, passing handoffs between them and pausing for human checkpoints at phase boundaries.\n\n## Invocation\n\n```\n/build <mode> [options] [description]\n```\n\n## Question Flow (No Arguments)\n\nIf the user types just `/build` with no or partial arguments, guide them through this question flow to infer the right configuration. Use AskUserQuestion for each phase.\n\n### Phase 0: Workflow Selection\n\n```yaml\nquestion: \"What would you like to do?\"\nheader: \"Workflow\"\noptions:\n  - label: \"Help me choose (Recommended)\"\n    description: \"I'll ask a few questions to pick the right workflow\"\n  - label: \"Greenfield - new feature\"\n    description: \"Chain: discovery → plan → validate → implement → commit → PR\"\n  - label: \"Brownfield - existing code\"\n    description: \"Chain: onboard → research → plan → validate → implement\"\n  - label: \"TDD - test-first\"\n    description: \"Chain: plan → test-driven-development → implement\"\n  - label: \"Refactor - improve structure\"\n    description: \"Chain: impact analysis → plan → TDD → implement\"\n```\n\n**Mapping:**\n- \"Help me choose\" → Continue to Phase 1-4 questions\n- \"Greenfield\" → Set mode=greenfield, skip to Phase 5 (description)\n- \"Brownfield\" → Set mode=brownfield, skip to Phase 5 (description)\n- \"TDD\" → Set mode=tdd, skip to Phase 5 (description)\n- \"Refactor\" → Set mode=refactor, skip to Phase 5 (description)\n\n**If Answer is Unclear (via \"Other\"):**\n```yaml\nquestion: \"I want to understand your workflow needs. Did you mean...\"\nheader: \"Clarify\"\noptions:\n  - label: \"Help me choose\"\n    description: \"Not sure which workflow - guide me through questions\"\n  - label: \"Greenfield - new feature\"\n    description: \"Building something new with no existing code\"\n  - label: \"Brownfield - existing code\"\n    description: \"Adding to or modifying existing codebase\"\n  - label: \"Neither - let me explain differently\"\n    description: \"I'll describe what I'm trying to do\"\n```\n\n### Phase 1: Project Context\n\n```yaml\nquestion: \"Is this a new feature or work in existing code?\"\nheader: \"Context\"\noptions:\n  - label: \"New feature from scratch\"\n    description: \"No existing code to integrate with\"\n  - label: \"Adding to existing codebase\"\n    description: \"Need to understand current code first\"\n  - label: \"Refactoring existing code\"\n    description: \"Improving without changing behavior\"\n```\n\n**Mapping:**\n- \"New feature from scratch\" → greenfield mode\n- \"Adding to existing codebase\" → brownfield mode\n- \"Refactoring existing code\" → refactor mode\n\n**If Answer is Unclear (via \"Other\"):**\n```yaml\nquestion: \"I want to make sure I understand. Did you mean...\"\nheader: \"Clarify\"\noptions:\n  - label: \"New feature from scratch\"\n    description: \"Building something new with no existing code\"\n  - label: \"Adding to existing codebase\"\n    description: \"Integrating with code that already exists\"\n  - label: \"Refactoring existing code\"\n    description: \"Improving structure without changing behavior\"\n  - label: \"Neither - let me explain differently\"\n    description: \"I'll provide more details\"\n```\n\n### Phase 2: Requirements Clarity\n\n```yaml\nquestion: \"How clear are your requirements?\"\nheader: \"Requirements\"\noptions:\n  - label: \"I have a clear spec/description\"\n    description: \"Know exactly what to build\"\n  - label: \"I have a rough idea\"\n    description: \"Need help fleshing out details\"\n  - label: \"Just exploring possibilities\"\n    description: \"Want to discover what's possible\"\n```\n\n**Mapping:**\n- \"Clear spec\" → --skip-discovery\n- \"Rough idea\" → run discovery-interview first\n- \"Exploring\" → run discovery-interview with broader scope\n\n**If Answer is Unclear (via \"Other\"):**\n```yaml\nquestion: \"I want to make sure I understand your requirements state. Did you mean...\"\nheader: \"Clarify\"\noptions:\n  - label: \"I have a clear spec/description\"\n    description: \"Ready to implement - no discovery needed\"\n  - label: \"I have a rough idea\"\n    description: \"Need some help defining the details\"\n  - label: \"Just exploring possibilities\"\n    description: \"Don't know exactly what's possible yet\"\n  - label: \"Neither - let me explain differently\"\n    description: \"I'll describe my situation better\"\n```\n\n### Phase 3: Development Approach\n\n```yaml\nquestion: \"How should I approach development?\"\nheader: \"Approach\"\noptions:\n  - label: \"Just implement it\"\n    description: \"Standard implementation flow\"\n  - label: \"Write tests first (TDD)\"\n    description: \"Test-driven development\"\n  - label: \"Validate plan before coding\"\n    description: \"Get plan reviewed before implementation\"\n```\n\n**Mapping:**\n- \"Just implement\" → standard chain\n- \"Tests first\" → tdd mode (overrides previous if not refactor)\n- \"Validate plan\" → keep validate-agent in chain\n\n**If Answer is Unclear (via \"Other\"):**\n```yaml\nquestion: \"I want to make sure I understand your preferred approach. Did you mean...\"\nheader: \"Clarify\"\noptions:\n  - label: \"Just implement it\"\n    description: \"Standard development - implement then test\"\n  - label: \"Write tests first (TDD)\"\n    description: \"Test-driven - tests before implementation\"\n  - label: \"Validate plan before coding\"\n    description: \"Review plan with validate-agent first\"\n  - label: \"Neither - let me explain differently\"\n    description: \"I have a different workflow in mind\"\n```\n\n### Phase 4: Post-Implementation\n\n```yaml\nquestion: \"What should happen after implementation?\"\nheader: \"Finish\"\nmultiSelect: true\noptions:\n  - label: \"Auto-commit changes\"\n    description: \"Create git commit when done\"\n  - label: \"Create PR description\"\n    description: \"Generate PR summary\"\n  - label: \"Just leave files changed\"\n    description: \"I'll handle git myself\"\n```\n\n**Mapping:**\n- No \"Auto-commit\" selected → --skip-commit\n- No \"Create PR\" selected → --skip-pr\n\n**If Answer is Unclear (via \"Other\"):**\n```yaml\nquestion: \"I want to understand what you need after implementation. Which apply?\"\nheader: \"Clarify\"\nmultiSelect: true\noptions:\n  - label: \"Auto-commit changes\"\n    description: \"I'll create a git commit with your changes\"\n  - label: \"Create PR description\"\n    description: \"I'll generate a PR summary for you\"\n  - label: \"Just leave files changed\"\n    description: \"No git operations - you'll handle it\"\n  - label: \"Neither - let me explain differently\"\n    description: \"I have different post-implementation needs\"\n```\n\n### Phase 5: Description\n\nFinally, ask for the feature description:\n\n```yaml\nquestion: \"Describe what you want to build (1-2 sentences):\"\nheader: \"Feature\"\noptions: []  # Free text input via \"Other\"\n```\n\n### Summary Before Execution\n\nBefore starting, show what will run:\n\n```\nBased on your answers, I'll run:\n\n**Mode:** brownfield\n**Chain:** onboard → research-codebase → plan-agent → implement_plan\n**Options:** --skip-commit\n**Description:** \"Add user authentication with OAuth\"\n\nProceed? [Yes / Adjust settings]\n```\n\nThis ensures the user knows exactly what will happen before any agents spawn.\n\n## Modes\n\n| Mode | Chain | Use Case |\n|------|-------|----------|\n| `greenfield` | discovery-interview -> plan-agent -> validate-agent -> implement_plan -> commit -> describe_pr | New feature from scratch |\n| `brownfield` | onboard -> research-codebase -> plan-agent -> validate-agent -> implement_plan | Feature in existing codebase |\n| `tdd` | plan-agent -> test-driven-development -> implement_plan | Test-first implementation |\n| `refactor` | tldr-code (impact) -> plan-agent -> test-driven-development -> implement_plan | Safe refactoring with impact analysis |\n\n## Options\n\n| Option | Effect |\n|--------|--------|\n| `--skip-discovery` | Skip interview phase (use existing spec or description) |\n| `--skip-validate` | Skip validation phase (trust plan as-is) |\n| `--skip-commit` | Don't auto-commit after implementation |\n| `--skip-pr` | Don't create PR description |\n| `--parallel` | Run independent research agents in parallel |\n\n## Handoff Directory\n\nAll handoffs go to: `thoughts/shared/handoffs/<session>/`\n\nSession name derived from:\n1. Existing continuity ledger name, OR\n2. Generated from feature description: `build-<date>-<kebab-description>`\n\n## Orchestration Process\n\n### Step 0: Parse Arguments\n\nParse the mode and options from user input:\n\n```\n/build greenfield --skip-validate Add user authentication\n       ^mode      ^options        ^description\n```\n\nBuild the skill chain based on mode:\n\n```python\nCHAINS = {\n    \"greenfield\": [\"discovery-interview\", \"plan-agent\", \"validate-agent\", \"implement_plan\", \"commit\", \"describe_pr\"],\n    \"brownfield\": [\"onboard\", \"research-codebase\", \"plan-agent\", \"validate-agent\", \"implement_plan\"],\n    \"tdd\": [\"plan-agent\", \"test-driven-development\", \"implement_plan\"],\n    \"refactor\": [\"tldr-impact\", \"plan-agent\", \"test-driven-development\", \"implement_plan\"]\n}\n```\n\nApply options to modify chain:\n- `--skip-discovery`: Remove \"discovery-interview\" from chain\n- `--skip-validate`: Remove \"validate-agent\" from chain\n- `--skip-commit`: Remove \"commit\" from chain\n- `--skip-pr`: Remove \"describe_pr\" from chain\n\n### Step 1: Setup\n\n1. Create handoff directory:\n   ```bash\n   SESSION=\"build-$(date +%Y%m%d)-<kebab-description>\"\n   mkdir -p \"thoughts/shared/handoffs/$SESSION\"\n   ```\n\n2. Create orchestration state file:\n   ```bash\n   cat > \"thoughts/shared/handoffs/$SESSION/orchestration.yaml\" << EOF\n   session: $SESSION\n   mode: <mode>\n   options: [<options>]\n   description: \"<description>\"\n   started: $(date -u +\"%Y-%m-%dT%H:%M:%SZ\")\n   chain: [<skill1>, <skill2>, ...]\n   current_phase: 0\n   phases:\n     - skill: <skill1>\n       status: pending\n     - skill: <skill2>\n       status: pending\n     ...\n   EOF\n   ```\n\n### Step 2: Execute Chain\n\nFor each skill in the chain:\n\n#### Phase Execution Pattern\n\n```\n1. Read previous handoff (if exists)\n2. Execute skill (spawn agent or invoke directly)\n3. Capture skill output/handoff\n4. Update orchestration state\n5. Human checkpoint (if phase boundary)\n6. Continue or handle error\n```\n\n#### Skill Execution Details\n\n**discovery-interview:**\n```\nTask(\n  subagent_type=\"discovery-interview\",\n  prompt=\"\"\"\n  [Contents of discovery-interview SKILL.md]\n\n  ---\n\n  ## Context\n  Feature request: <description>\n  Handoff directory: thoughts/shared/handoffs/<session>/\n\n  Conduct the interview and create spec.\n  \"\"\"\n)\n```\nOutput: Spec file at `thoughts/shared/specs/<name>-spec.md`\n\n**onboard:**\n```\nTask(\n  subagent_type=\"onboard\",\n  prompt=\"\"\"\n  [Contents of onboard SKILL.md]\n\n  ---\n\n  Analyze this codebase and create continuity ledger.\n  Handoff directory: thoughts/shared/handoffs/<session>/\n  \"\"\"\n)\n```\nOutput: TLDR caches, continuity ledger\n\n**research-codebase:**\n```\nTask(\n  subagent_type=\"research-codebase\",\n  prompt=\"\"\"\n  [Contents of research-codebase SKILL.md]\n\n  ---\n\n  Research question: How should we implement <description>?\n  Focus areas: [based on spec or description]\n  Handoff directory: thoughts/shared/handoffs/<session>/\n  \"\"\"\n)\n```\nOutput: Research document at `thoughts/shared/research/<date>-<topic>.md`\n\n**tldr-impact (for refactor mode):**\n```bash\n# Run impact analysis on the function/module being refactored\ntldr impact <target> src/ --depth 3 > thoughts/shared/handoffs/<session>/impact-analysis.json\n\n# Also run architecture analysis\ntldr arch src/ > thoughts/shared/handoffs/<session>/architecture.json\n```\nOutput: Impact and architecture analysis files\n\n**plan-agent:**\n```\nTask(\n  subagent_type=\"plan-agent\",\n  prompt=\"\"\"\n  [Contents of plan-agent SKILL.md]\n\n  ---\n\n  ## Context\n  Feature request: <description>\n\n  [Include spec if exists from discovery-interview]\n  [Include research findings if exists]\n  [Include impact analysis if refactor mode]\n\n  Handoff directory: thoughts/shared/handoffs/<session>/\n  \"\"\"\n)\n```\nOutput: Plan at `thoughts/shared/plans/PLAN-<name>.md`, handoff at `<session>/plan-<name>.md`\n\n**CHECKPOINT: After plan-agent**\n```\nPlan created: thoughts/shared/plans/PLAN-<name>.md\n\nPlease review the plan. Options:\n1. Approve and continue to [next phase]\n2. Request changes to plan\n3. Abort workflow\n\n[Show plan summary]\n```\n\n**validate-agent:**\n```\nTask(\n  subagent_type=\"validate-agent\",\n  prompt=\"\"\"\n  [Contents of validate-agent SKILL.md]\n\n  ---\n\n  Plan to validate: [Plan content]\n  Plan path: thoughts/shared/plans/PLAN-<name>.md\n  Handoff directory: thoughts/shared/handoffs/<session>/\n  \"\"\"\n)\n```\nOutput: Validation handoff at `<session>/validation-<name>.md`\n\n**CHECKPOINT: After validate-agent (if issues found)**\n```\nValidation complete with issues:\n- [Issue 1]\n- [Issue 2]\n\nOptions:\n1. Proceed anyway (acknowledge risks)\n2. Update plan and re-validate\n3. Abort workflow\n```\n\n**test-driven-development (for tdd/refactor modes):**\n```\nPresent TDD guidance to user:\n\n\"Entering TDD mode. For each feature:\n1. Write failing test first\n2. Implement minimal code to pass\n3. Refactor while keeping tests green\n\nI'll guide you through each cycle. Starting with first test...\"\n```\nThis is interactive - guide user through TDD cycles.\n\n**implement_plan:**\n```\n# Check plan size\nif task_count <= 3:\n    # Direct implementation\n    Follow implement_plan skill directly\nelse:\n    # Agent orchestration mode\n    For each task:\n        Task(\n          subagent_type=\"implement_task\",\n          prompt=\"\"\"\n          [Contents of implement_task SKILL.md]\n\n          ---\n\n          Plan: [Plan content]\n          Your task: Task N of M: <task description>\n          Previous handoff: [Previous task handoff or \"First task\"]\n          Handoff directory: thoughts/shared/handoffs/<session>/\n          \"\"\"\n        )\n```\nOutput: Task handoffs at `<session>/task-NN-<description>.md`\n\n**CHECKPOINT: After each implementation phase**\n```\nPhase [N] Complete\n\nAutomated verification:\n- [x] Tests passing\n- [x] Type check passed\n- [ ] Manual testing required\n\nPlease verify:\n- [Manual test items from plan]\n\nContinue to next phase? [Y/n]\n```\n\n**commit:**\n```\nFollow commit skill:\n1. Show git status and diff\n2. Present commit plan\n3. Execute on user approval\n4. Generate reasoning file\n```\n\n**describe_pr:**\n```\nFollow describe_pr skill:\n1. Create PR if not exists\n2. Generate description from changes\n3. Update PR with description\n```\n\n### Step 3: Handle Errors\n\nIf any phase fails or returns blocked status:\n\n```yaml\n# Update orchestration.yaml\nphases:\n  - skill: plan-agent\n    status: complete\n  - skill: validate-agent\n    status: blocked\n    error: \"Validation found deprecated library\"\n    blocker: \"Need to replace X with Y\"\n```\n\nPresent to user:\n```\nWorkflow blocked at: validate-agent\n\nIssue: Validation found deprecated library\nBlocker: Need to replace X with Y\n\nOptions:\n1. Retry this phase\n2. Skip this phase (not recommended)\n3. Abort workflow\n4. Manual intervention (I'll help you fix it)\n```\n\n### Step 4: Completion\n\nWhen all phases complete:\n\n```\nBuild workflow complete!\n\nSession: thoughts/shared/handoffs/<session>/\n\nArtifacts created:\n- Spec: thoughts/shared/specs/<name>-spec.md (if greenfield)\n- Plan: thoughts/shared/plans/PLAN-<name>.md\n- Validation: <session>/validation-<name>.md\n- Implementation handoffs: <session>/task-*.md\n- PR: #<number> (if --skip-pr not set)\n\nCommit: <hash> (if --skip-commit not set)\n\nTotal phases: N completed, M skipped\n```\n\n## Human Checkpoints\n\nCheckpoints pause for human verification at critical decision points:\n\n| After Phase | Checkpoint Purpose |\n|-------------|-------------------|\n| discovery-interview | Verify spec captures requirements |\n| plan-agent | Approve implementation plan |\n| validate-agent (if issues) | Acknowledge validation concerns |\n| Each implement task | Verify phase works before continuing |\n| commit | Approve commit message and files |\n\n**To skip checkpoints:** Run with `--no-checkpoint` (advanced users only)\n\n## Resume Support\n\nIf workflow is interrupted, resume from last checkpoint:\n\n```bash\n/build resume thoughts/shared/handoffs/<session>/\n```\n\nThis reads `orchestration.yaml` and continues from the last incomplete phase.\n\n## Example Sessions\n\n### Greenfield Feature\n\n```\nUser: /build greenfield Add user authentication with OAuth\n\nClaude: Starting greenfield workflow for \"Add user authentication with OAuth\"\n\nCreating session: build-20260108-user-auth-oauth\nChain: discovery-interview -> plan-agent -> validate-agent -> implement_plan -> commit -> describe_pr\n\nPhase 1/6: Discovery Interview\n[Spawns discovery-interview agent]\n\nInterview questions:\n1. What OAuth providers do you need? (Google, GitHub, etc.)\n2. What user data should we store after auth?\n3. Should sessions persist across browser closes?\n...\n\n[After interview completes]\n\nSpec created: thoughts/shared/specs/2026-01-08-user-auth-spec.md\n\nPhase 2/6: Planning\n[Spawns plan-agent]\n\nPlan created: thoughts/shared/plans/PLAN-user-auth.md\n\n--- CHECKPOINT ---\nPlan Summary:\n- Task 1: Set up OAuth provider configuration\n- Task 2: Create user model and session storage\n- Task 3: Implement OAuth callback endpoints\n- Task 4: Add auth middleware\n- Task 5: Create login/logout routes\n\nApprove plan and continue? [Y/n]\n\nUser: Y\n\nPhase 3/6: Validation\n[Spawns validate-agent]\n\nValidation: PASSED\nAll tech choices are current best practices.\n\nPhase 4/6: Implementation (5 tasks)\n[Spawns implementation agents for each task]\n\nTask 1/5: OAuth configuration... Complete\nTask 2/5: User model... Complete\nTask 3/5: OAuth callbacks... Complete\nTask 4/5: Auth middleware... Complete\nTask 5/5: Login/logout routes... Complete\n\n--- CHECKPOINT ---\nAll implementation complete.\nTests: 24 passing\nManual verification needed:\n- [ ] Test OAuth flow end-to-end\n- [ ] Verify session persistence\n\nContinue to commit? [Y/n]\n\nUser: Y\n\nPhase 5/6: Commit\n[Shows changes, creates commit]\n\nPhase 6/6: PR Description\n[Creates/updates PR]\n\nBuild complete!\nPR #42: https://github.com/user/repo/pull/42\n```\n\n### TDD Mode\n\n```\nUser: /build tdd Add rate limiting to API endpoints\n\nClaude: Starting TDD workflow for \"Add rate limiting to API endpoints\"\n\nPhase 1/3: Planning\n[Creates plan with test specifications]\n\n--- CHECKPOINT ---\nPlan approved? [Y/n]\n\nUser: Y\n\nPhase 2/3: TDD Implementation\n\nLet's start with the first test. According to the plan, we need to test:\n\"Rate limiter returns 429 after 100 requests per minute\"\n\nRED - Write failing test:\n```python\ndef test_rate_limiter_returns_429_after_limit():\n    limiter = RateLimiter(limit=100, window=60)\n    for _ in range(100):\n        assert limiter.check(\"user1\") == True\n    assert limiter.check(\"user1\") == False\n```\n\nRunning test... FAILED (as expected - RateLimiter doesn't exist)\n\nGREEN - Implement minimal code:\n[Guides through implementation]\n\nRunning test... PASSED\n\nREFACTOR - Any cleanup needed?\n\nNext test: \"Rate limiter resets after window expires\"\n...\n\nPhase 3/3: Implementation\n[Integrates rate limiter into endpoints]\n\nBuild complete!\n```\n\n### Refactor Mode\n\n```\nUser: /build refactor Extract auth logic into separate module\n\nClaude: Starting refactor workflow for \"Extract auth logic into separate module\"\n\nPhase 1/4: Impact Analysis\nRunning: tldr impact auth src/ --depth 3\n\nImpact analysis complete:\n- 12 files directly call auth functions\n- 3 entry points affected\n- No circular dependencies detected\n\nArchitecture analysis:\n- auth is currently in: src/api/middleware/\n- Callers in: src/api/routes/, src/api/handlers/\n\n--- CHECKPOINT ---\nReview impact before planning? [Y/n]\n\nUser: Y\n\n[Shows detailed impact report]\n\nPhase 2/4: Planning\n[Creates refactor plan based on impact analysis]\n\n...\n```\n\n## Error Recovery\n\n### If a phase fails:\n\n```\nPhase 3 (validate-agent) failed:\n\nError: WebSearch unavailable\n\nOptions:\n1. Retry phase (recommended)\n2. Skip validation (--skip-validate)\n3. Abort workflow\n\nChoice:\n```\n\n### If implementation is blocked:\n\n```\nTask 3/5 blocked:\n\nBlocker: Database schema doesn't match expected structure\nFound: users.email (VARCHAR)\nExpected: users.email (UNIQUE VARCHAR)\n\nOptions:\n1. Create migration to fix schema\n2. Adjust plan to work with current schema\n3. Abort and investigate\n\nChoice:\n```\n\n## Parallel Execution\n\nWith `--parallel` option, independent phases run concurrently:\n\n```\n/build brownfield --parallel Add dashboard feature\n\nPhase 1: Onboard (started)\nPhase 2: Research-codebase (started in parallel)\n\n[Both complete]\n\nPhase 3: Plan-agent (uses results from both)\n...\n```\n\nOnly truly independent phases run in parallel. Dependencies are respected.\n\n## Configuration\n\n### Default mode preferences\n\nSet in `.claude/settings.json`:\n\n```json\n{\n  \"skills\": {\n    \"build\": {\n      \"default_mode\": \"brownfield\",\n      \"always_validate\": true,\n      \"auto_commit\": false,\n      \"checkpoint_phases\": [\"plan-agent\", \"implement_plan\"]\n    }\n  }\n}\n```\n\n## Troubleshooting\n\n| Issue | Solution |\n|-------|----------|\n| \"No continuity ledger found\" | Run `/onboard` first or use greenfield mode |\n| \"Plan validation failed\" | Review validation output, update plan |\n| \"Implementation blocked\" | Check blocker in handoff, resolve dependency |\n| \"Workflow stuck\" | Check `orchestration.yaml` for state, resume or restart |\n\n## Related Skills\n\n- `/discovery-interview` - Deep interview for requirements\n- `/plan-agent` - Create implementation plans\n- `/validate-agent` - Validate tech choices\n- `/implement_plan` - Execute implementation plans\n- `/implement_task` - Single task implementation\n- `/test-driven-development` - TDD workflow\n- `/commit` - Create commits\n- `/describe_pr` - Generate PR descriptions\n- `/onboard` - Codebase analysis\n- `/research-codebase` - Research existing code\n- `/tldr-code` - Code analysis CLI","author":"@parcadei","ownerProfile":null,"authorContacts":null,"sourceUrl":"https://github.com/parcadei/Continuous-Claude-v3/tree/main/.claude/skills/build","license":"MIT","category":"coding","lang":"en","tokens":5282,"stars":0,"calls30d":1,"claimed":false,"visibility":"public","origin":"crawler","version":"0.1.0","createdAt":"2026-08-22","updatedAt":"2026-08-22","files":[],"requires":{"mcp":[],"tools":[]},"safety":{"flags":[],"scannedAt":"2026-08-22","hasScripts":false,"networkEndpoints":[]}}