跳至正文
OpenAgentSkill
浏览已开放 · 目录记录日期 2026-11-21 · 自动更新和账户服务暂时关闭。
其他技能

execute-work-package

Execute a bounded implementation unit from authoritative plan references or an inline gated brief using a stateful subagent loop (steps -> gate -> execute -> digest) without creating new persistent artifacts.

DasDigitaleMomentum · 已有静态检查记录

安装与使用

运行命令前先阅读来源与依赖说明。复制命令不会自动安装或执行。

npx skills add DasDigitaleMomentum/opencode-processing-skills --skill execute-work-package

技能说明


name: execute-work-package description: Execute a bounded implementation unit from authoritative plan references or an inline gated brief using a stateful subagent loop (steps -> gate -> execute -> digest) without creating new persistent artifacts. license: MIT compatibility: opencode: ">=0.1" metadata: category: execution phase: implementation

Skill: Execute Work Package

This skill standardizes execution/implementation once planning is gated.

It is a small, repeatable protocol:

  1. BLUEPRINT: Subagent returns an Execution Blueprint (step list)
  2. GATE: Primary approves (primary-internal)
  3. EXECUTE: Subagent implements and verifies (same task_id)
  4. DIGEST: Subagent returns a compact digest (no raw logs/diffs)

This skill deliberately does not create new persistent artifacts in docs/ or plans/.


When to Use

Use this skill when:

  • A plan/phase (or a major slice of a phase) already has a clear DoD and verification approach; or
  • A self-contained work package has an inline gated brief with its task, DoD, constraints, and approved broad/full final verification.
  • You want to offload implementation to a subagent without causing primary context bloat.
  • You want predictable, reviewable execution with a single explicit gate.

If persistent phase work has a vague or unverified implementation plan, run author-and-verify-implementation-plan first. Do not create a persistent plan solely because a bounded inline work package is significant or non-trivial.

Multi-phase ordering: When a plan has multiple phases, create all implementation plans first (via author-and-verify-implementation-plan), then execute phases sequentially — one at a time. Do not alternate between planning and executing per phase; the cross-phase view catches conflicts early and sequential execution avoids errors from interdependencies.

Do not use this skill to:

  • (Re-)do planning (scope, risks, alternatives) — that is Primary work.
  • Generate documentation/planning artifacts — use generate-docs, create-plan, update-plan, update-docs.

Execution Model

Roles

  • Primary (maintainer)

    • Owns scope/DoD/risk decisions and gating.
    • Chooses the work package (phase, significant phase slice, or self-contained inline brief).
    • Owns Git operations (stage/commit/PR) unless explicitly delegated.
    • Updates plan/todo via update-plan as needed when a persistent plan exists.
  • Subagent (implementer)

    • Does execution only for exactly one phase/work package in a fresh session.
    • First returns a step list.
    • May add a concise optional Package Sizing Note when natural execution slices exist, but never splits scope or chooses a slice; the Primary decides whether to approve the full package or issue a smaller fresh package.
    • After approval, executes those steps and returns a digest.
    • Uses retriever by default for separable evidence collection while retaining ownership of the Blueprint, edits, and verification.
    • Directly reads scoped source and compact targeted evidence, but keeps uncurated bulk evidence out of its context. It uses reliable focused filtering when sufficient and retriever for complete raw or coherent multi-file evidence.
    • BLUEPRINT remains command-free. In EXECUTE, potentially verbose output is spooled to a predictable path under /tmp/opencode/; the immediate context receives only path, command, exit status, and compact metadata/evidence.
    • Retires after the digest, subject only to the same-package review-fix exception under Statefulness; another phase/work package starts with a fresh implementer.
    • Does not do Git operations.
    • Checkpoints after approved Blueprint steps or bounded parts of a large step, consulting the latest possibly lagged telemetry before deliberately starting another context-heavy unit.
    • Uses browser-walkthrough for approved automated browser acceptance; agent-observed walkthroughs belong to a Delegate, while user-attended walkthroughs remain Primary-coordinated and may use a retained Delegate session for bounded browser segments.

Routing Matrix (Who does what)

  • Writes: code files in the target repository (working tree changes) and runs verification commands.
  • Does NOT write: plans/** or docs/** artifacts.
  • Primary: owns gating/approval, Git operations, and, when a persistent plan exists, updates to plans/** (typically via update-plan).
  • implementer: execution only (blueprint → execute → digest), no Git.
  • Session boundary: one fresh implementer per phase/work package; its BLUEPRINT and EXECUTE calls share a session. Post-digest reuse is limited to the review-fix exception under Statefulness.
  • retriever: default leaf for separable evidence collection by the implementer; no edits, decisions, or artifact ownership.
  • browser walkthroughs: automated acceptance is Implementer-owned during EXECUTE, agent-observed walkthroughs route to a Delegate, and user-attended walkthroughs are Primary-coordinated with optional retained-Delegate execution; no browser-specific persona is created.
  • doc-explorer: not used for this skill (unless you explicitly want docs/plan artifacts, in which case use the appropriate planning/doc skills).

Authority and navigation

  • plans/ provides gated intent/DoD and references when the package belongs to a persistent plan lifecycle.
  • Otherwise, the inline gated work-package brief is authoritative and supplies the task, DoD, constraints, and final verification.
  • docs/ (if present) provides curated inventories (modules/features/symbols) so the subagent does not rediscover everything.

Scope and Specification Boundary

Gold-plating is work not required by an explicit user requirement, gated scope/DoD, or a concrete existing invariant necessary for the requested behavior to function. It includes invented product rules or guardrails, speculative configurability,

阅读完整来源 ↗