[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M786BJF6QEDNFEWZFR0EEH3K":3,"skill-same:01M786BJF6QEDNFEWZFR0EEH3K":59},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":19,"linkOnly":20,"markdownContent":21,"markdownBody":22,"frontMatter":23,"refName":30,"commitSha":31,"skillDirectory":32,"forksCount":14,"repositoryHtmlUrl":33,"repositoryHomepageUrl":6,"ownerHtmlUrl":34,"ownerBlogUrl":6,"ownerDescription":6,"updatedAt":35,"install":36,"resources":48},"01M786BJF6QEDNFEWZFR0EEH3K","sp-implement-teams",null,"Execute implementation through Claude Code Agent Teams when you explicitly want durable team execution.","chenziyang110\u002Flaunchdeck","chenziyang110","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F43693913?v=4","01M7863EBWK1D0P6A29YGEMAS4","Robin11","01M7863ECM1VB6RXDMHTW90D2T",0,"MIT","https:\u002F\u002Fgithub.com\u002Fchenziyang110\u002Flaunchdeck\u002Fblob\u002Fmain\u002F.claude\u002Fskills\u002Fsp-implement-teams\u002FSKILL.md",[],[],"2026-11-15 14:19:17",false,"---\nname: \"sp-implement-teams\"\ndescription: \"Execute implementation through Claude Code Agent Teams when you explicitly want durable team execution.\"\nargument-hint: \"Optional implementation scope or coordination guidance for the Agent Teams run\"\ncompatibility: \"Requires spec-kit project structure with .specify\u002F directory\"\nmetadata:\n  author: \"github-spec-kit\"\n  source: \"src\u002Fspecify_cli\u002Fintegrations\u002Fclaude\u002Ftemplates\u002Fimplement-teams.md\"\nuser-invocable: true\n---\n\n\n# Claude Code Agent Teams\n\nUser-facing workflow skill:\n\n```text\n\u002Fsp-implement-teams\n```\n\n[AGENT] For project-cognition-backed semantic intake, routing, audit, resume, or final-claim gates, read `references\u002Fsemantic-work-contract.md`.\n\n## Detailed References\n\nRead [Reference index](references\u002FINDEX.md) before applying shared semantic contracts.\n\n- [semantic work contract](references\u002Fsemantic-work-contract.md)\n\n## Team Bootstrap Gate\n\nThis gate is mandatory and precedes all broad implementation-context recovery.\n\n1. After `.specify\u002Fscripts\u002Fpowershell\u002Fcheck-prerequisites.ps1 -Json -RequireTasks -IncludeTasks` resolves `FEATURE_DIR` and confirms `tasks.md` exists, the first non-prerequisite action is creating or resuming the Claude Agent Team.\n2. Do not read `plan.md`, `tasks.md` beyond the minimum existence\u002Fstatus check, project cognition runtime files, compatibility\u002Fexport files such as `PROJECT-HANDBOOK.md`, implementation files, or test files before this gate passes.\n3. Do not run validation, edit files, or inspect broad implementation context before this gate passes.\n4. If a Claude Agent Team for the same feature slug already exists, resume that team and inspect only its ledger and shared task list until the leader has confirmed the team state.\n5. If `TeamCreate`, team resume, shared task records, or native teammate launch is unavailable, stop and report that Claude Agent Teams is unavailable for this `\u002Fsp-implement-teams` run.\n6. Do not fall back to `\u002Fsp-implement`, ordinary subagents, ordinary `Agent` tool calls, or leader-inline implementation from this gate.\n\n## Boundary\n\n1. Claude-only\n2. Implementation-phase entry point only; use it after `tasks.md` is ready\n3. Use Claude Code's built-in Agent Teams surface, not the Codex runtime surface\n4. Keep `sp-teams` and Codex extension commands out of Claude guidance\n5. The ordinary `Agent` tool must not be used as a teammate substitute. `\u002Fsp-implement-teams` requires team-managed teammates that join the shared Agent Teams ledger.\n\n## When To Use\n\nUse this when:\n\n1. `\u002Fsp-implement` would otherwise run a `leader-inline-fallback` or native subagent flow\n2. you want durable coordinated execution with a shared task list and explicit teammate messaging\n3. the implementation work is already decomposed into task-ready execution slices\n\n\n## Shared Contract With `\u002Fsp-implement`\n\n`\u002Fsp-implement` remains the canonical implementation workflow. `\u002Fsp-implement-teams` is the same execution contract with the concrete team-managed work pinned to Claude Code Agent Teams.\n\nWhen you use `\u002Fsp-implement-teams`, keep the same leader-owned execution semantics that `\u002Fsp-implement` requires:\n\n1. keep canonical task status, compact execution state, and one lifecycle record per executed task aligned\n2. compile and validate a `WorkerTaskPacket` just in time before assigning each team-managed execution task\n3. for implementation-oriented teams flows, preserve the user-visible fields `execution_model`, `dispatch_shape`, and `execution_surface`\n4. preserve explicit join behavior, blocker\u002Frecovery reporting, event-triggered review, and completion checks\n5. preserve the team result contract and canonical result file handoff path\n6. preserve final-completion truthfulness: do not describe `core implementation complete`, `implementation complete`, or `ready for integration testing` as overall feature completion while required E2E, Polish, documentation, quickstart, or validation work remains\n\nEvery team-managed task in the teams-backed flow must still behave like an explicit execution packet, not a chat-only summary. Preserve these fields whenever the backend exposes task records, mailbox messages, or equivalent runtime-managed assignments:\n\n1. task id and subject\n2. write set and shared surfaces\n3. required references and forbidden drift\n4. explicit verification command or acceptance check\n5. canonical result handoff path or runtime-managed result channel expectation\n6. completion-handoff protocol covering start, blocker, and final completion evidence\n7. platform guardrails such as supported platforms, conditional compilation requirements, or other environment-sensitive constraints\n\nBefore Claude Code Agent Teams starts concrete work, ensure the current ready batch is prepared the same way `\u002Fsp-implement` would prepare it:\n\n1. the current batch is recorded in canonical task and compact execution state\n2. each team-managed task has a validated `WorkerTaskPacket`\n3. join point expectations and result handoff expectations are explicit\n4. the team-managed lane cannot be treated as complete from a status flip alone; the leader still needs the promised completion handoff or result evidence\n\nBefore assigning team-managed work, preserve the same project cognition compass contract that `sp-implement` uses:\n\n1. run `project-cognition compass --intent implement --query=\"$ARGUMENTS\" --format json` and include the compass packet in the execution context bundle\n2. Read and carry `epistemic_contract`; require `graph_role=route_candidate_only`, `fact_source_of_truth=live_repository`, `live_verification_required=true`, `graph_only_claims_allowed=false`, and `unverified_claim_action=withhold`. The contract cannot authorize source changes and cannot prove current behavior; contradictory live evidence overrides the route candidate. Graph claims are indexed assertions; even `verified_in_graph_generation` is only an active graph-generation state, not current repository truth. Graph claims cannot authorize source changes and cannot set workflow `claim_ready=true`; bounded live evidence and the separate workflow final-claim gate remain required. Carry `epistemic_contract` in every teammate context packet.\n3. read top-level `minimal_live_reads` first, then use lane-level `first_pass_paths` reasons, evidence hints, `verification_hints`, `followup_surfaces`, and `before_fix_claim` checks\n4. preserve `coverage_diagnostics` as confidence and closeout signals, not route candidates\n5. treat `expansion_ref` as a normal continuation path and run `project-cognition expand --id \u003Cid> --section \u003Csection> --format json` only when coverage state or live evidence requires more map detail\n6. do not infer final edit scope from `minimal_live_reads` or `first_pass_paths`; carry them as advisory first-pass evidence routes in every teammate context packet\n7. use the advanced `lexicon -> semantic_intake -> query` path only when explicit concept decisions are needed or coverage cannot be resolved from the default compass packet\n8. in that precision escalation, normalize user input and write a `semantic_intake` object with `workflow_intent`, `normalized_query`, `intent_facets`, `negative_constraints`, `alias_interpretations`, and `open_semantic_questions`\n9. treat `agent_normalization.required=true` as a non-intelligent CLI reminder to write `semantic_intake` from the alias catalog (raw lexicon ranking is only a bootstrap; action: write_semantic_intake_from_alias_catalog); if `agent_normalization` is omitted, treat it as `required=false`, not as proof that raw lexical ranking is authoritative\n10. keep CJK or mixed CJK\u002FASCII input in agent-owned normalization even when positive raw lexical matches exist because embedded project tokens do not translate the surrounding user language; the agent still owns translation and `agent_normalization` is advisory guidance, not a route decision\n11. keep `alias_interpretations` object-shaped, for example `{\"alias\": \"\u003Cuser term>\", \"meaning\": \"\u003Cproject term>\", \"confidence\": \"medium\"}`, never as a string array\n12. build a `query_plan` with `selected_concepts`, `rejected_concepts`, `concept_decisions`, `covered_facets`, `missing_facets`, `match_sources`, `lexicon_generation_id`, `expanded_queries`, `repository_search_terms`, and justified `paths`\n13. derive project-language search terms from the alias catalog before source search; do not search only the raw user words; include component names, state names, file names, command names, UI labels, and route names from candidates, aliases, matched terms, returned paths, `normalized_query`, and `expanded_queries`\n14. run `project-cognition query --intent implement --query-plan \"\u003Cquery_plan_json>\" --format json` only for that precision escalation, and preserve returned readiness, `minimal_live_reads`, `first_pass_paths`, and the task-local bundle in every teammate context packet\n15. if the query reports diagnostics, preserve `warnings`, `repair_hints`, normalized `query_plan`, structured `errors`, and `expected_shape` so the leader can repair the plan instead of losing the diagnostics in team chat\n\nThe only intended difference is the dispatch path:\n\n1. `\u002Fsp-implement` may route the current ready batch through subagents first\n2. `\u002Fsp-implement-teams` forces the concrete team-managed execution through Claude Code Agent Teams for the same batch and join-point semantics\n3. Claude Code Agent Teams must not weaken the tracker, packet, validation, or completion contract\n\n## Execution Contract\n\n1. Run `.specify\u002Fscripts\u002Fpowershell\u002Fcheck-prerequisites.ps1 -Json -RequireTasks -IncludeTasks` from repo root and parse `FEATURE_DIR` and `AVAILABLE_DOCS` list. All paths must be absolute.\n2. If the prerequisites output does not resolve a `FEATURE_DIR` with `tasks.md`, stop and run `\u002Fsp-tasks` first instead of guessing from chat state.\n3. Confirm the current project is using the Claude integration and that `tasks.md` is ready.\n4. Confirm Claude Agent Teams is actually enabled before you try to use it:\n   - confirm the current Claude Code configuration enables Agent Teams, whether that configuration lives in `settings.json` or the environment\n   - treat `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS` as the canonical Claude Code setting\u002Fenv key for that feature gate when you need to name the switch explicitly\n   - if the Agent Teams surface is unavailable, or if the first `TeamCreate` \u002F Agent Teams call fails as though the feature is disabled, stop and explicitly remind the user to enable Agent Teams in Claude Code settings or environment instead of continuing with a broken team setup\n   - treat this as a hard prerequisite for `\u002Fsp-implement-teams`, not as an optional hint\n5. Create or resume a Claude Agent Team for the feature:\n   - if a team for the same feature slug is already active, reuse or resume it instead of creating a second parallel team for the same feature\n   - if the first `TeamCreate` call fails because you are already leading the team, treat that as a recoverable resume signal rather than a terminal failure\n   - inspect the existing team ledger, shared task list, and pending work first, then continue from the recorded ready batch\n   - do not create a second parallel team for the same feature just to get unstuck\n\n```text\nTeamCreate({\n  team_name: \"\u003Cfeature-slug>\",\n  description: \"Implementing \u003Cfeature>\",\n  agent_type: \"researcher\"\n})\n```\n\n6. Treat the team ledger as shared state:\n   - team membership lives in `~\u002F.claude\u002Fteams\u002F{team-name}\u002Fconfig.json`\n   - shared tasks live under `~\u002F.claude\u002Ftasks\u002F{team-name}\u002F`\n7. Before the first `TaskCreate`, compile an execution context bundle for the current batch:\n   - run `C:\\Users\\11034\\.specify\\bin\\project-cognition.exe compass --intent implement --query=\\\"$ARGUMENTS\\\" --format json` first and include the compass packet in teammate context\n   - read top-level `minimal_live_reads` first, then use lane-level `first_pass_paths` reasons, evidence hints, `verification_hints`, `followup_surfaces`, and `before_fix_claim` checks\n   - carry `coverage_diagnostics` as confidence and closeout signals, not route candidates\n   - treat `expansion_ref` as a normal continuation path and run `project-cognition expand --id \u003Cid> --section \u003Csection> --format json` only when coverage state or live evidence requires more map detail\n   - do not infer final edit scope from `minimal_live_reads` or `first_pass_paths`; carry them as advisory first-pass evidence routes in every teammate context packet\n   - preserve advanced `lexicon -> semantic_intake -> query` \u002F `project-cognition query --query-plan` only as conditional precision escalation when explicit concept decisions are needed or coverage cannot be resolved from the default compass packet\n   - in that precision escalation, derive project-language search terms from the alias catalog before source search; do not search only the raw user words\n   - candidate selection in the precision escalation must satisfy facet coverage through `covered_facets`, `missing_facets`, and `match_sources`; do not trust top similarity alone\n   - run `C:\\Users\\11034\\.specify\\bin\\project-cognition.exe query --intent implement --query-plan \\\"\u003Cquery_plan_json>\\\" --format json` only for that precision escalation\n   - if the precision escalation runs, include returned readiness, the task-local bundle, and only the returned `minimal_live_reads` needed for the lane\n   - include `.specify\u002Fproject-cognition\u002Fstatus.json` and `.specify\u002Fproject-cognition\u002Fproject-cognition.db` as the runtime freshness\u002Fstore boundary when the teammate must acknowledge the underlying cognition runtime\n   - include compatibility\u002Fexport files such as `PROJECT-HANDBOOK.md` only when the task explicitly depends on handbook\u002Fexport parity, downstream compatibility, or exported handbook wording\n   - for each bundled item, preserve the path or query source, why it matters, and a read order so the teammate knows which query results are primary and which compatibility\u002Fexport artifacts are supplementary\n8. Convert the ready implementation slices into explicit shared tasks with `TaskCreate`.\n   - every shared task must carry the execution context bundle, not just the task summary\n   - the task body must tell the teammate which context items are required, what each item is for, and which ones must be read before work starts\n   - create the full task set before wiring `blockedBy` \u002F `blocks` dependencies; do not point one task at another task record that does not exist yet\n   - every shared task must preserve an explicit execution packet shape, not just prose:\n     - task id and subject\n     - write set and shared surfaces\n     - required references and forbidden drift\n     - deliverables\n     - explicit verification command or acceptance check\n     - canonical result handoff path when the leader expects a file handoff\n     - completion protocol covering start, blocker, and final completion evidence\n     - platform guardrails such as supported platforms or required conditional compilation for platform-specific code\n   - use a standardized task body shape such as:\n\n```text\nTask ID: T001\nSubject: Protocol update for foreground process payload\nWrite Set:\n- apps\u002Flocal-agent\u002Fsrc\u002Fprotocol.rs\n- apps\u002Frelay-server\u002Fsrc\u002Fprotocol.rs\nRequired References:\n- .specify\u002Fproject-cognition\u002Fstatus.json\n- project-cognition compass intake packet with top-level `minimal_live_reads` and lane-level `first_pass_paths`\n- PROJECT-HANDBOOK.md (only when compatibility\u002Fexport parity matters)\nDeliverables:\n- matching protocol definitions on both sides\n- focused tests updated\nVerification:\n- cargo test -p local-agent\nResult Handoff:\n- write the normalized result envelope to FEATURE_DIR\u002Fworker-results\u002FT001.json when the leader requests a file handoff\nCompletion Protocol:\n1. SendMessage({ type: \"task_started\", task_id: \"T001\" })\n2. run the required verification\n3. TaskUpdate({ taskId: \"T001\", status: \"completed\" })\n4. SendMessage({ type: \"task_completed\", task_id: \"T001\", summary: \"...\", verification: \"...\", files_changed: [...] })\nPlatform Guardrails:\n- supported_platforms: windows, linux\n- use conditional compilation for platform-specific code instead of assuming unix-only APIs are always available\nJoin Point:\n- Join Point 1.1\n```\n8b. Team Wave Protocol: plan the team wave before launching teammates.\n   - Each execution wave must identify:\n     - implementation teammate ownership for concrete write tasks\n     - review teammate ownership for shared surfaces, schema\u002FAPI changes, risky refactors, or cross-module changes\n     - verification teammate ownership for test execution, E2E checks, build checks, or scripted validation\n     - leader integration responsibility for final synthesis and next-wave planning\n   - A wave may omit a review teammate or verification teammate only when the leader records why the batch is low risk and what validation evidence will replace that role.\n   - Treat the team wave as a collaboration protocol, not just parallel task dispatch.\n   - Require these team messages when applicable:\n     - `interface_change` before a teammate changes a shared API, schema, protocol, config surface, or boundary contract\n     - `review_requested` when an implementation teammate finishes a risky or shared-surface task\n     - `verification_started` before a verification teammate begins the validation lane\n     - `team_synthesis` from the leader after every join point, summarizing completed work, open blockers, interface changes, verification evidence, and the next ready wave\n9. Encode dependencies and ownership with `TaskUpdate`:\n   - use `blockedBy` \u002F `blocks` for ordering\n   - use `owner` to assign each task to a named teammate\n   - finish all `TaskCreate` calls for the current ready batch first, then wire dependency edges and ownership in a second pass so dependency references never point at missing task records\n10. Inherit Claude Code's configured subagent model behavior before teammate creation:\n   - rely on Claude Code's current subagent configuration instead of resolving teammate model choice manually for this workflow\n   - if `CLAUDE_CODE_SUBAGENT_MODEL` is configured in the environment, treat it as the active subagent model hint for this run\n   - when subagent model behavior is configured through Claude Code settings, trust that configuration instead of re-deriving or copying model values into teammate setup\n   - do not derive teammate model from `ANTHROPIC_MODEL`\n   - do not ask the user for an explicit teammate model just to launch the team\n   - do not require local `.claude\u002Fagents\u002F\u003Cteam-name>-\u003Crole>.md` teammate definitions solely to force a model choice\n11. Create the teammates on the native Agent Teams surface:\n   - this step requires the current Claude Code Agent Teams teammate launch surface, not the ordinary `Agent` tool\n   - the ordinary `Agent` tool must not be used as a teammate substitute, even if it can read or update shared tasks\n   - if no native Agent Teams teammate launch surface is available, stop instead of falling back to ordinary subagents and report that Agent Teams is unavailable for this run\n   - reference a generated teammate definition name when the current Claude build supports it and you genuinely need reusable teammate packaging\n   - prompt-only specialization is acceptable when you do not need a persisted custom teammate definition\n   - use read-only style teammate definitions for analysis or planning lanes and implementation-oriented teammate definitions for write lanes\n   - set `team_name` so every teammate joins the same shared ledger\n   - prefer `run_in_background: true` for long-running execution\n   - use `isolation: \"worktree\"` when the lane needs isolated edits\n12. Verify the launched teammate instead of assuming startup succeeded:\n   - inspect the team ledger and shared task state after teammate creation and confirm the teammate joined the intended team\n   - if the runtime cannot use the chosen teammate configuration, simplify the launch path instead of forcing an explicit model override\n   - if the teammate enters `idle` without consuming its first probe message, treat startup as failed rather than successful\n   - use a minimal readiness probe message before task assignment so an idle lane is detected early and does not silently absorb a real task\n   - the readiness probe must confirm the teammate consumed the execution context bundle and can echo a `context_ack` containing the required paths or read-order items before any real work is assigned\n13. Tell every teammate to call `TaskList`, claim or inspect its assigned work, and use `SendMessage` for coordination instead of silent progress.\n   - ack the context bundle before claiming work; a teammate must not claim work until it has confirmed the required paths\n   - after claiming work, the teammate must emit an explicit `task_started` message before settling into background execution so the leader can distinguish real execution from a silent idle lane\n   - implementation teammates must announce `interface_change` before changing shared contracts\n   - review teammates must use `review_requested` \u002F `review_completed` messages instead of relying on task status alone\n   - verification teammates must send `verification_started` and `verification_completed` with commands, exit status, and evidence paths\n14. Track progress through the shared task list:\n   - `TaskUpdate({ taskId, status: \"in_progress\" })`\n   - `TaskUpdate({ taskId, status: \"completed\" })`\n   - `TaskList()` and `TaskGet(taskId: \"...\")` to inspect team state\n   - treat `TaskUpdate({ status: \"completed\" })` as necessary but not sufficient when the task promised a completion handoff, verification summary, or result file\n15. Use `SendMessage` for handoffs, blockers, dependency releases, and context acknowledgement receipts. Approve structured messages such as `context_ack`, `shutdown_request`, or `plan_approval_request` when they arrive.\n   - when execution actually begins, prefer `task_started` messages with the task id and a short execution note\n   - when blocked, require a `task_blocked` message naming the blocker, failed assumption, and smallest safe recovery step\n   - when complete, require a `task_completed` message that includes task id, summary, verification run, files changed, and any residual concern even if the task status is already marked `completed`\n   - when a result handoff path was promised, the teammate must write that result before entering `idle`; a completion message without the promised handoff is incomplete\n16. Keep the same completion discipline as `\u002Fsp-implement`: do not cross the join point or declare completion until structured handoffs are consumed, the tracker\u002Fresult state is updated, and every teammate has confirmed the required context bundle for its lane.\n    - after each completed join point or ready batch, immediately re-read the shared task ledger, select the next ready batch and continue automatically\n    - stop only when no ready work remains, a real blocker stops progress, or an explicit human approval gate is reached\n    - planned validation tasks are still ready work; if the remaining tasks are executable tests, E2E checks, security verification, quickstart validation, or other scripted validation work already present in `tasks.md`, continue automatically instead of asking whether validation should start\n    - do not stop to ask whether validation should start unless a manual-only check or approval step is explicitly recorded in the tracker or task plan\n    - do not stop after a single completed batch just because the current assignee went idle\n17. Only after the shared completion contract is fully satisfied may you request shutdown for each teammate, then clean up the team with `TeamDelete()`.\n   - if the team has only finished core implementation or is merely ready for integration testing while required E2E, Polish, documentation, or validation tasks remain, report partial progress and keep the remaining work explicit instead of declaring overall feature completion\n   - a `shutdown_response` or other approval signal means the teammate accepted shutdown, not that it already left the team; confirm active membership before treating cleanup as complete\n\n## Output Expectations\n\nSuccessful runs should leave the user with:\n\n1. a Claude-native team config under `~\u002F.claude\u002Fteams\u002F{team-name}\u002Fconfig.json`\n2. a shared task ledger under `~\u002F.claude\u002Ftasks\u002F{team-name}\u002F`\n3. explicit teammate ownership, status transitions, and dependency tracking\n4. the same implementation lifecycle semantics as `\u002Fsp-implement`, including tracker continuity, join point visibility, and result handoff discipline\n5. implementation framed as Claude Code Agent Teams execution, not as Codex runtime or extension plumbing\n6. explicit evidence that teammates inherited Claude Code's configured subagent model behavior when applicable, without ad hoc model-guessing or forced local teammate model files\n\n## Claude Agent Teams Teammate Result Contract\n\n- Preferred result contract: WorkerTaskResult contract with status, changed files, validation evidence, blockers, failed assumptions, and recovery guidance.\n- Result file handoff path: FEATURE_DIR\u002Fworker-results\u002F\u003Ctask-id>.json\n- For filesystem handoffs, use `specify result path` with the concrete workflow identifiers such as `--feature-dir`\u002F`--task-id`, `--workspace`\u002F`--lane-id`, or `--session-slug`\u002F`--lane-id`.\n- `specify result path` emits JSON and does not accept `--format`; do not append `--format`.\n- Normalize teammate-reported statuses like `DONE`, `DONE_WITH_CONCERNS`, `BLOCKED`, and `NEEDS_CONTEXT` into the shared `WorkerTaskResult` contract before the leader accepts the handoff.\n- Keep `reported_status` when normalization occurs so the leader can distinguish raw teammate language from canonical orchestration state.\n- Wait for every Agent Teams teammate's structured handoff before accepting the join point, closing the team wave, or declaring completion.\n- Do not treat an idle teammate as done work; idle without a consumed handoff means the team result channel is still unresolved.\n- Do not interrupt or shut down teammate work before the handoff has been written or explicitly reported as `BLOCKED` or `NEEDS_CONTEXT`.\n- Treat `DONE_WITH_CONCERNS` as completed work plus follow-up concerns, not as silent success.\n- Treat `NEEDS_CONTEXT` as a blocked handoff that must carry the missing context or failed assumption explicitly.\n","# Claude Code Agent Teams\n\nUser-facing workflow skill:\n\n```text\n\u002Fsp-implement-teams\n```\n\n[AGENT] For project-cognition-backed semantic intake, routing, audit, resume, or final-claim gates, read `references\u002Fsemantic-work-contract.md`.\n\n## Detailed References\n\nRead [Reference index](references\u002FINDEX.md) before applying shared semantic contracts.\n\n- [semantic work contract](references\u002Fsemantic-work-contract.md)\n\n## Team Bootstrap Gate\n\nThis gate is mandatory and precedes all broad implementation-context recovery.\n\n1. After `.specify\u002Fscripts\u002Fpowershell\u002Fcheck-prerequisites.ps1 -Json -RequireTasks -IncludeTasks` resolves `FEATURE_DIR` and confirms `tasks.md` exists, the first non-prerequisite action is creating or resuming the Claude Agent Team.\n2. Do not read `plan.md`, `tasks.md` beyond the minimum existence\u002Fstatus check, project cognition runtime files, compatibility\u002Fexport files such as `PROJECT-HANDBOOK.md`, implementation files, or test files before this gate passes.\n3. Do not run validation, edit files, or inspect broad implementation context before this gate passes.\n4. If a Claude Agent Team for the same feature slug already exists, resume that team and inspect only its ledger and shared task list until the leader has confirmed the team state.\n5. If `TeamCreate`, team resume, shared task records, or native teammate launch is unavailable, stop and report that Claude Agent Teams is unavailable for this `\u002Fsp-implement-teams` run.\n6. Do not fall back to `\u002Fsp-implement`, ordinary subagents, ordinary `Agent` tool calls, or leader-inline implementation from this gate.\n\n## Boundary\n\n1. Claude-only\n2. Implementation-phase entry point only; use it after `tasks.md` is ready\n3. Use Claude Code's built-in Agent Teams surface, not the Codex runtime surface\n4. Keep `sp-teams` and Codex extension commands out of Claude guidance\n5. The ordinary `Agent` tool must not be used as a teammate substitute. `\u002Fsp-implement-teams` requires team-managed teammates that join the shared Agent Teams ledger.\n\n## When To Use\n\nUse this when:\n\n1. `\u002Fsp-implement` would otherwise run a `leader-inline-fallback` or native subagent flow\n2. you want durable coordinated execution with a shared task list and explicit teammate messaging\n3. the implementation work is already decomposed into task-ready execution slices\n\n\n## Shared Contract With `\u002Fsp-implement`\n\n`\u002Fsp-implement` remains the canonical implementation workflow. `\u002Fsp-implement-teams` is the same execution contract with the concrete team-managed work pinned to Claude Code Agent Teams.\n\nWhen you use `\u002Fsp-implement-teams`, keep the same leader-owned execution semantics that `\u002Fsp-implement` requires:\n\n1. keep canonical task status, compact execution state, and one lifecycle record per executed task aligned\n2. compile and validate a `WorkerTaskPacket` just in time before assigning each team-managed execution task\n3. for implementation-oriented teams flows, preserve the user-visible fields `execution_model`, `dispatch_shape`, and `execution_surface`\n4. preserve explicit join behavior, blocker\u002Frecovery reporting, event-triggered review, and completion checks\n5. preserve the team result contract and canonical result file handoff path\n6. preserve final-completion truthfulness: do not describe `core implementation complete`, `implementation complete`, or `ready for integration testing` as overall feature completion while required E2E, Polish, documentation, quickstart, or validation work remains\n\nEvery team-managed task in the teams-backed flow must still behave like an explicit execution packet, not a chat-only summary. Preserve these fields whenever the backend exposes task records, mailbox messages, or equivalent runtime-managed assignments:\n\n1. task id and subject\n2. write set and shared surfaces\n3. required references and forbidden drift\n4. explicit verification command or acceptance check\n5. canonical result handoff path or runtime-managed result channel expectation\n6. completion-handoff protocol covering start, blocker, and final completion evidence\n7. platform guardrails such as supported platforms, conditional compilation requirements, or other environment-sensitive constraints\n\nBefore Claude Code Agent Teams starts concrete work, ensure the current ready batch is prepared the same way `\u002Fsp-implement` would prepare it:\n\n1. the current batch is recorded in canonical task and compact execution state\n2. each team-managed task has a validated `WorkerTaskPacket`\n3. join point expectations and result handoff expectations are explicit\n4. the team-managed lane cannot be treated as complete from a status flip alone; the leader still needs the promised completion handoff or result evidence\n\nBefore assigning team-managed work, preserve the same project cognition compass contract that `sp-implement` uses:\n\n1. run `project-cognition compass --intent implement --query=\"$ARGUMENTS\" --format json` and include the compass packet in the execution context bundle\n2. Read and carry `epistemic_contract`; require `graph_role=route_candidate_only`, `fact_source_of_truth=live_repository`, `live_verification_required=true`, `graph_only_claims_allowed=false`, and `unverified_claim_action=withhold`. The contract cannot authorize source changes and cannot prove current behavior; contradictory live evidence overrides the route candidate. Graph claims are indexed assertions; even `verified_in_graph_generation` is only an active graph-generation state, not current repository truth. Graph claims cannot authorize source changes and cannot set workflow `claim_ready=true`; bounded live evidence and the separate workflow final-claim gate remain required. Carry `epistemic_contract` in every teammate context packet.\n3. read top-level `minimal_live_reads` first, then use lane-level `first_pass_paths` reasons, evidence hints, `verification_hints`, `followup_surfaces`, and `before_fix_claim` checks\n4. preserve `coverage_diagnostics` as confidence and closeout signals, not route candidates\n5. treat `expansion_ref` as a normal continuation path and run `project-cognition expand --id \u003Cid> --section \u003Csection> --format json` only when coverage state or live evidence requires more map detail\n6. do not infer final edit scope from `minimal_live_reads` or `first_pass_paths`; carry them as advisory first-pass evidence routes in every teammate context packet\n7. use the advanced `lexicon -> semantic_intake -> query` path only when explicit concept decisions are needed or coverage cannot be resolved from the default compass packet\n8. in that precision escalation, normalize user input and write a `semantic_intake` object with `workflow_intent`, `normalized_query`, `intent_facets`, `negative_constraints`, `alias_interpretations`, and `open_semantic_questions`\n9. treat `agent_normalization.required=true` as a non-intelligent CLI reminder to write `semantic_intake` from the alias catalog (raw lexicon ranking is only a bootstrap; action: write_semantic_intake_from_alias_catalog); if `agent_normalization` is omitted, treat it as `required=false`, not as proof that raw lexical ranking is authoritative\n10. keep CJK or mixed CJK\u002FASCII input in agent-owned normalization even when positive raw lexical matches exist because embedded project tokens do not translate the surrounding user language; the agent still owns translation and `agent_normalization` is advisory guidance, not a route decision\n11. keep `alias_interpretations` object-shaped, for example `{\"alias\": \"\u003Cuser term>\", \"meaning\": \"\u003Cproject term>\", \"confidence\": \"medium\"}`, never as a string array\n12. build a `query_plan` with `selected_concepts`, `rejected_concepts`, `concept_decisions`, `covered_facets`, `missing_facets`, `match_sources`, `lexicon_generation_id`, `expanded_queries`, `repository_search_terms`, and justified `paths`\n13. derive project-language search terms from the alias catalog before source search; do not search only the raw user words; include component names, state names, file names, command names, UI labels, and route names from candidates, aliases, matched terms, returned paths, `normalized_query`, and `expanded_queries`\n14. run `project-cognition query --intent implement --query-plan \"\u003Cquery_plan_json>\" --format json` only for that precision escalation, and preserve returned readiness, `minimal_live_reads`, `first_pass_paths`, and the task-local bundle in every teammate context packet\n15. if the query reports diagnostics, preserve `warnings`, `repair_hints`, normalized `query_plan`, structured `errors`, and `expected_shape` so the leader can repair the plan instead of losing the diagnostics in team chat\n\nThe only intended difference is the dispatch path:\n\n1. `\u002Fsp-implement` may route the current ready batch through subagents first\n2. `\u002Fsp-implement-teams` forces the concrete team-managed execution through Claude Code Agent Teams for the same batch and join-point semantics\n3. Claude Code Agent Teams must not weaken the tracker, packet, validation, or completion contract\n\n## Execution Contract\n\n1. Run `.specify\u002Fscripts\u002Fpowershell\u002Fcheck-prerequisites.ps1 -Json -RequireTasks -IncludeTasks` from repo root and parse `FEATURE_DIR` and `AVAILABLE_DOCS` list. All paths must be absolute.\n2. If the prerequisites output does not resolve a `FEATURE_DIR` with `tasks.md`, stop and run `\u002Fsp-tasks` first instead of guessing from chat state.\n3. Confirm the current project is using the Claude integration and that `tasks.md` is ready.\n4. Confirm Claude Agent Teams is actually enabled before you try to use it:\n   - confirm the current Claude Code configuration enables Agent Teams, whether that configuration lives in `settings.json` or the environment\n   - treat `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS` as the canonical Claude Code setting\u002Fenv key for that feature gate when you need to name the switch explicitly\n   - if the Agent Teams surface is unavailable, or if the first `TeamCreate` \u002F Agent Teams call fails as though the feature is disabled, stop and explicitly remind the user to enable Agent Teams in Claude Code settings or environment instead of continuing with a broken team setup\n   - treat this as a hard prerequisite for `\u002Fsp-implement-teams`, not as an optional hint\n5. Create or resume a Claude Agent Team for the feature:\n   - if a team for the same feature slug is already active, reuse or resume it instead of creating a second parallel team for the same feature\n   - if the first `TeamCreate` call fails because you are already leading the team, treat that as a recoverable resume signal rather than a terminal failure\n   - inspect the existing team ledger, shared task list, and pending work first, then continue from the recorded ready batch\n   - do not create a second parallel team for the same feature just to get unstuck\n\n```text\nTeamCreate({\n  team_name: \"\u003Cfeature-slug>\",\n  description: \"Implementing \u003Cfeature>\",\n  agent_type: \"researcher\"\n})\n```\n\n6. Treat the team ledger as shared state:\n   - team membership lives in `~\u002F.claude\u002Fteams\u002F{team-name}\u002Fconfig.json`\n   - shared tasks live under `~\u002F.claude\u002Ftasks\u002F{team-name}\u002F`\n7. Before the first `TaskCreate`, compile an execution context bundle for the current batch:\n   - run `C:\\Users\\11034\\.specify\\bin\\project-cognition.exe compass --intent implement --query=\\\"$ARGUMENTS\\\" --format json` first and include the compass packet in teammate context\n   - read top-level `minimal_live_reads` first, then use lane-level `first_pass_paths` reasons, evidence hints, `verification_hints`, `followup_surfaces`, and `before_fix_claim` checks\n   - carry `coverage_diagnostics` as confidence and closeout signals, not route candidates\n   - treat `expansion_ref` as a normal continuation path and run `project-cognition expand --id \u003Cid> --section \u003Csection> --format json` only when coverage state or live evidence requires more map detail\n   - do not infer final edit scope from `minimal_live_reads` or `first_pass_paths`; carry them as advisory first-pass evidence routes in every teammate context packet\n   - preserve advanced `lexicon -> semantic_intake -> query` \u002F `project-cognition query --query-plan` only as conditional precision escalation when explicit concept decisions are needed or coverage cannot be resolved from the default compass packet\n   - in that precision escalation, derive project-language search terms from the alias catalog before source search; do not search only the raw user words\n   - candidate selection in the precision escalation must satisfy facet coverage through `covered_facets`, `missing_facets`, and `match_sources`; do not trust top similarity alone\n   - run `C:\\Users\\11034\\.specify\\bin\\project-cognition.exe query --intent implement --query-plan \\\"\u003Cquery_plan_json>\\\" --format json` only for that precision escalation\n   - if the precision escalation runs, include returned readiness, the task-local bundle, and only the returned `minimal_live_reads` needed for the lane\n   - include `.specify\u002Fproject-cognition\u002Fstatus.json` and `.specify\u002Fproject-cognition\u002Fproject-cognition.db` as the runtime freshness\u002Fstore boundary when the teammate must acknowledge the underlying cognition runtime\n   - include compatibility\u002Fexport files such as `PROJECT-HANDBOOK.md` only when the task explicitly depends on handbook\u002Fexport parity, downstream compatibility, or exported handbook wording\n   - for each bundled item, preserve the path or query source, why it matters, and a read order so the teammate knows which query results are primary and which compatibility\u002Fexport artifacts are supplementary\n8. Convert the ready implementation slices into explicit shared tasks with `TaskCreate`.\n   - every shared task must carry the execution context bundle, not just the task summary\n   - the task body must tell the teammate which context items are required, what each item is for, and which ones must be read before work starts\n   - create the full task set before wiring `blockedBy` \u002F `blocks` dependencies; do not point one task at another task record that does not exist yet\n   - every shared task must preserve an explicit execution packet shape, not just prose:\n     - task id and subject\n     - write set and shared surfaces\n     - required references and forbidden drift\n     - deliverables\n     - explicit verification command or acceptance check\n     - canonical result handoff path when the leader expects a file handoff\n     - completion protocol covering start, blocker, and final completion evidence\n     - platform guardrails such as supported platforms or required conditional compilation for platform-specific code\n   - use a standardized task body shape such as:\n\n```text\nTask ID: T001\nSubject: Protocol update for foreground process payload\nWrite Set:\n- apps\u002Flocal-agent\u002Fsrc\u002Fprotocol.rs\n- apps\u002Frelay-server\u002Fsrc\u002Fprotocol.rs\nRequired References:\n- .specify\u002Fproject-cognition\u002Fstatus.json\n- project-cognition compass intake packet with top-level `minimal_live_reads` and lane-level `first_pass_paths`\n- PROJECT-HANDBOOK.md (only when compatibility\u002Fexport parity matters)\nDeliverables:\n- matching protocol definitions on both sides\n- focused tests updated\nVerification:\n- cargo test -p local-agent\nResult Handoff:\n- write the normalized result envelope to FEATURE_DIR\u002Fworker-results\u002FT001.json when the leader requests a file handoff\nCompletion Protocol:\n1. SendMessage({ type: \"task_started\", task_id: \"T001\" })\n2. run the required verification\n3. TaskUpdate({ taskId: \"T001\", status: \"completed\" })\n4. SendMessage({ type: \"task_completed\", task_id: \"T001\", summary: \"...\", verification: \"...\", files_changed: [...] })\nPlatform Guardrails:\n- supported_platforms: windows, linux\n- use conditional compilation for platform-specific code instead of assuming unix-only APIs are always available\nJoin Point:\n- Join Point 1.1\n```\n8b. Team Wave Protocol: plan the team wave before launching teammates.\n   - Each execution wave must identify:\n     - implementation teammate ownership for concrete write tasks\n     - review teammate ownership for shared surfaces, schema\u002FAPI changes, risky refactors, or cross-module changes\n     - verification teammate ownership for test execution, E2E checks, build checks, or scripted validation\n     - leader integration responsibility for final synthesis and next-wave planning\n   - A wave may omit a review teammate or verification teammate only when the leader records why the batch is low risk and what validation evidence will replace that role.\n   - Treat the team wave as a collaboration protocol, not just parallel task dispatch.\n   - Require these team messages when applicable:\n     - `interface_change` before a teammate changes a shared API, schema, protocol, config surface, or boundary contract\n     - `review_requested` when an implementation teammate finishes a risky or shared-surface task\n     - `verification_started` before a verification teammate begins the validation lane\n     - `team_synthesis` from the leader after every join point, summarizing completed work, open blockers, interface changes, verification evidence, and the next ready wave\n9. Encode dependencies and ownership with `TaskUpdate`:\n   - use `blockedBy` \u002F `blocks` for ordering\n   - use `owner` to assign each task to a named teammate\n   - finish all `TaskCreate` calls for the current ready batch first, then wire dependency edges and ownership in a second pass so dependency references never point at missing task records\n10. Inherit Claude Code's configured subagent model behavior before teammate creation:\n   - rely on Claude Code's current subagent configuration instead of resolving teammate model choice manually for this workflow\n   - if `CLAUDE_CODE_SUBAGENT_MODEL` is configured in the environment, treat it as the active subagent model hint for this run\n   - when subagent model behavior is configured through Claude Code settings, trust that configuration instead of re-deriving or copying model values into teammate setup\n   - do not derive teammate model from `ANTHROPIC_MODEL`\n   - do not ask the user for an explicit teammate model just to launch the team\n   - do not require local `.claude\u002Fagents\u002F\u003Cteam-name>-\u003Crole>.md` teammate definitions solely to force a model choice\n11. Create the teammates on the native Agent Teams surface:\n   - this step requires the current Claude Code Agent Teams teammate launch surface, not the ordinary `Agent` tool\n   - the ordinary `Agent` tool must not be used as a teammate substitute, even if it can read or update shared tasks\n   - if no native Agent Teams teammate launch surface is available, stop instead of falling back to ordinary subagents and report that Agent Teams is unavailable for this run\n   - reference a generated teammate definition name when the current Claude build supports it and you genuinely need reusable teammate packaging\n   - prompt-only specialization is acceptable when you do not need a persisted custom teammate definition\n   - use read-only style teammate definitions for analysis or planning lanes and implementation-oriented teammate definitions for write lanes\n   - set `team_name` so every teammate joins the same shared ledger\n   - prefer `run_in_background: true` for long-running execution\n   - use `isolation: \"worktree\"` when the lane needs isolated edits\n12. Verify the launched teammate instead of assuming startup succeeded:\n   - inspect the team ledger and shared task state after teammate creation and confirm the teammate joined the intended team\n   - if the runtime cannot use the chosen teammate configuration, simplify the launch path instead of forcing an explicit model override\n   - if the teammate enters `idle` without consuming its first probe message, treat startup as failed rather than successful\n   - use a minimal readiness probe message before task assignment so an idle lane is detected early and does not silently absorb a real task\n   - the readiness probe must confirm the teammate consumed the execution context bundle and can echo a `context_ack` containing the required paths or read-order items before any real work is assigned\n13. Tell every teammate to call `TaskList`, claim or inspect its assigned work, and use `SendMessage` for coordination instead of silent progress.\n   - ack the context bundle before claiming work; a teammate must not claim work until it has confirmed the required paths\n   - after claiming work, the teammate must emit an explicit `task_started` message before settling into background execution so the leader can distinguish real execution from a silent idle lane\n   - implementation teammates must announce `interface_change` before changing shared contracts\n   - review teammates must use `review_requested` \u002F `review_completed` messages instead of relying on task status alone\n   - verification teammates must send `verification_started` and `verification_completed` with commands, exit status, and evidence paths\n14. Track progress through the shared task list:\n   - `TaskUpdate({ taskId, status: \"in_progress\" })`\n   - `TaskUpdate({ taskId, status: \"completed\" })`\n   - `TaskList()` and `TaskGet(taskId: \"...\")` to inspect team state\n   - treat `TaskUpdate({ status: \"completed\" })` as necessary but not sufficient when the task promised a completion handoff, verification summary, or result file\n15. Use `SendMessage` for handoffs, blockers, dependency releases, and context acknowledgement receipts. Approve structured messages such as `context_ack`, `shutdown_request`, or `plan_approval_request` when they arrive.\n   - when execution actually begins, prefer `task_started` messages with the task id and a short execution note\n   - when blocked, require a `task_blocked` message naming the blocker, failed assumption, and smallest safe recovery step\n   - when complete, require a `task_completed` message that includes task id, summary, verification run, files changed, and any residual concern even if the task status is already marked `completed`\n   - when a result handoff path was promised, the teammate must write that result before entering `idle`; a completion message without the promised handoff is incomplete\n16. Keep the same completion discipline as `\u002Fsp-implement`: do not cross the join point or declare completion until structured handoffs are consumed, the tracker\u002Fresult state is updated, and every teammate has confirmed the required context bundle for its lane.\n    - after each completed join point or ready batch, immediately re-read the shared task ledger, select the next ready batch and continue automatically\n    - stop only when no ready work remains, a real blocker stops progress, or an explicit human approval gate is reached\n    - planned validation tasks are still ready work; if the remaining tasks are executable tests, E2E checks, security verification, quickstart validation, or other scripted validation work already present in `tasks.md`, continue automatically instead of asking whether validation should start\n    - do not stop to ask whether validation should start unless a manual-only check or approval step is explicitly recorded in the tracker or task plan\n    - do not stop after a single completed batch just because the current assignee went idle\n17. Only after the shared completion contract is fully satisfied may you request shutdown for each teammate, then clean up the team with `TeamDelete()`.\n   - if the team has only finished core implementation or is merely ready for integration testing while required E2E, Polish, documentation, or validation tasks remain, report partial progress and keep the remaining work explicit instead of declaring overall feature completion\n   - a `shutdown_response` or other approval signal means the teammate accepted shutdown, not that it already left the team; confirm active membership before treating cleanup as complete\n\n## Output Expectations\n\nSuccessful runs should leave the user with:\n\n1. a Claude-native team config under `~\u002F.claude\u002Fteams\u002F{team-name}\u002Fconfig.json`\n2. a shared task ledger under `~\u002F.claude\u002Ftasks\u002F{team-name}\u002F`\n3. explicit teammate ownership, status transitions, and dependency tracking\n4. the same implementation lifecycle semantics as `\u002Fsp-implement`, including tracker continuity, join point visibility, and result handoff discipline\n5. implementation framed as Claude Code Agent Teams execution, not as Codex runtime or extension plumbing\n6. explicit evidence that teammates inherited Claude Code's configured subagent model behavior when applicable, without ad hoc model-guessing or forced local teammate model files\n\n## Claude Agent Teams Teammate Result Contract\n\n- Preferred result contract: WorkerTaskResult contract with status, changed files, validation evidence, blockers, failed assumptions, and recovery guidance.\n- Result file handoff path: FEATURE_DIR\u002Fworker-results\u002F\u003Ctask-id>.json\n- For filesystem handoffs, use `specify result path` with the concrete workflow identifiers such as `--feature-dir`\u002F`--task-id`, `--workspace`\u002F`--lane-id`, or `--session-slug`\u002F`--lane-id`.\n- `specify result path` emits JSON and does not accept `--format`; do not append `--format`.\n- Normalize teammate-reported statuses like `DONE`, `DONE_WITH_CONCERNS`, `BLOCKED`, and `NEEDS_CONTEXT` into the shared `WorkerTaskResult` contract before the leader accepts the handoff.\n- Keep `reported_status` when normalization occurs so the leader can distinguish raw teammate language from canonical orchestration state.\n- Wait for every Agent Teams teammate's structured handoff before accepting the join point, closing the team wave, or declaring completion.\n- Do not treat an idle teammate as done work; idle without a consumed handoff means the team result channel is still unresolved.\n- Do not interrupt or shut down teammate work before the handoff has been written or explicitly reported as `BLOCKED` or `NEEDS_CONTEXT`.\n- Treat `DONE_WITH_CONCERNS` as completed work plus follow-up concerns, not as silent success.\n- Treat `NEEDS_CONTEXT` as a blocked handoff that must carry the missing context or failed assumption explicitly.\n",{"name":5,"metadata":24,"description":7,"argument-hint":27,"compatibility":28,"user-invocable":29},{"author":25,"source":26},"github-spec-kit","src\u002Fspecify_cli\u002Fintegrations\u002Fclaude\u002Ftemplates\u002Fimplement-teams.md","Optional implementation scope or coordination guidance for the Agent Teams run","Requires spec-kit project structure with .specify\u002F directory",true,"main","021f5cbe02157229460a577e9a585f2da6d78cb0",".claude\u002Fskills\u002Fsp-implement-teams","https:\u002F\u002Fgithub.com\u002Fchenziyang110\u002Flaunchdeck","https:\u002F\u002Fgithub.com\u002Fchenziyang110","2026-08-07 18:10:54",{"source":8,"skillName":5,"commands":37,"prompt":47,"zipAvailable":29},[38,41,44],{"tool":39,"command":40},"npx","npx skills add chenziyang110\u002Flaunchdeck --skill sp-implement-teams",{"tool":42,"command":43},"bunx","bunx skills add chenziyang110\u002Flaunchdeck --skill sp-implement-teams",{"tool":45,"command":46},"pnpm","pnpm dlx skills add chenziyang110\u002Flaunchdeck --skill sp-implement-teams","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fchenziyang110\u002Flaunchdeck\u002Fblob\u002Fmain\u002F.claude\u002Fskills\u002Fsp-implement-teams\u002FSKILL.md",[49,55],{"path":50,"resourceType":51,"resourceTypeDesc":52,"sizeBytes":53,"sourceHtmlUrl":54},"references\u002FINDEX.md","REFERENCE","参考文档",620,"https:\u002F\u002Fgithub.com\u002Fchenziyang110\u002Flaunchdeck\u002Fblob\u002Fmain\u002F.claude\u002Fskills\u002Fsp-implement-teams\u002Freferences\u002FINDEX.md",{"path":56,"resourceType":51,"resourceTypeDesc":52,"sizeBytes":57,"sourceHtmlUrl":58},"references\u002Fsemantic-work-contract.md",57200,"https:\u002F\u002Fgithub.com\u002Fchenziyang110\u002Flaunchdeck\u002Fblob\u002Fmain\u002F.claude\u002Fskills\u002Fsp-implement-teams\u002Freferences\u002Fsemantic-work-contract.md",[60,67,73,79,86,95],{"skillNo":61,"name":62,"nameZh":6,"description":63,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":64,"categories":65,"keywords":66,"publishedAt":19},"01M7875F3HQ1GF5F6BR36KY3JE","launchdeck-agent","Codex host adapter contract fixture for Launchdeck.","https:\u002F\u002Fgithub.com\u002Fchenziyang110\u002Flaunchdeck\u002Fblob\u002Fmain\u002Ftest\u002Ffixtures\u002Fagent-hosts\u002Fcodex\u002Fskill\u002FSKILL.md",[],[],{"skillNo":68,"name":62,"nameZh":6,"description":69,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":70,"categories":71,"keywords":72,"publishedAt":19},"01M7875DV2DQR33K1NFJHKAMZP","Claude host adapter contract fixture for Launchdeck.","https:\u002F\u002Fgithub.com\u002Fchenziyang110\u002Flaunchdeck\u002Fblob\u002Fmain\u002Ftest\u002Ffixtures\u002Fagent-hosts\u002Fclaude\u002Fskill\u002FSKILL.md",[],[],{"skillNo":74,"name":62,"nameZh":6,"description":75,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":76,"categories":77,"keywords":78,"publishedAt":19},"01M78759JQ7A6FQ8KDQTNYS3X9","Use this skill aggressively for local project lifecycle operations even when the user does not mention Launchdeck: start this project, run the dev server, dev, build, test, restart service, stop service, show logs, inspect ports, port is occupied, clean cache; and when the user explicitly asks to configure this local project for Launchdeck or create or generate a project-adapted `.launchdeck.yml`, including 为这个项目生成 Launchdeck 配置. Do not use for ordinary code edits, docs-only work, general explanations, API design discussion, or production deployment unless the user also asks to operate or configure a local project or service.","https:\u002F\u002Fgithub.com\u002Fchenziyang110\u002Flaunchdeck\u002Fblob\u002Fmain\u002Fagent\u002Finstaller-payload\u002Fskill\u002Flaunchdeck-agent\u002FSKILL.md",[],[],{"skillNo":80,"name":81,"nameZh":6,"description":82,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":83,"categories":84,"keywords":85,"publishedAt":19},"01M78753ZJQ7G2CZT1W1G8WRJV","zig-testing","Use ONLY when user explicitly requests Zig test code, built-in test runner configuration,\ntest failure diagnosis, or coverage for Zig projects.\n\nTriggers: \"write test zig\", \"zig test\", \"testing.allocator\", \"zig coverage\",\n\"comptime test\", \"zig expectError\", \"zig snapshot test\", \"zig fuzz\".\n\nDo NOT activate for: general Zig coding without test context, build.zig configuration\nfor non-test targets, Zig compiler errors, or Zig build system setup.","https:\u002F\u002Fgithub.com\u002Fchenziyang110\u002Flaunchdeck\u002Fblob\u002Fmain\u002F.specify\u002Ftemplates\u002Fpassive-skills\u002Fzig-testing\u002FSKILL.md",[],[],{"skillNo":87,"name":88,"nameZh":6,"description":89,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":90,"licenseFileUrl":91,"sourceHtmlUrl":92,"categories":93,"keywords":94,"publishedAt":19},"01M78750JXY4Z5D5W1EX3PQ31Z","webapp-testing","Toolkit for interacting with and testing local web applications using Playwright. Supports verifying frontend functionality, debugging UI behavior, capturing browser screenshots, and viewing browser logs.","Apache-2.0","https:\u002F\u002Fgithub.com\u002Fchenziyang110\u002Flaunchdeck\u002Fblob\u002Fmain\u002F.specify\u002Ftemplates\u002Fpassive-skills\u002Fwebapp-testing\u002FLICENSE.txt","https:\u002F\u002Fgithub.com\u002Fchenziyang110\u002Flaunchdeck\u002Fblob\u002Fmain\u002F.specify\u002Ftemplates\u002Fpassive-skills\u002Fwebapp-testing\u002FSKILL.md",[],[],{"skillNo":96,"name":97,"nameZh":6,"description":98,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":99,"categories":100,"keywords":101,"publishedAt":19},"01M7874X2T83EQQFRCEY5SJJVC","verification-before-completion","Use when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions always","https:\u002F\u002Fgithub.com\u002Fchenziyang110\u002Flaunchdeck\u002Fblob\u002Fmain\u002F.specify\u002Ftemplates\u002Fpassive-skills\u002Fverification-before-completion\u002FSKILL.md",[],[]]