@flitzrrr/agent-skills 1.0.3 → 1.1.0

package/bin/sync-skills.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+# Sync DDM (DasDigitaleMomentum) skills from agent-skills repo to agy
+# Run after: git pull in agent-skills repo
+SKILLS_DIR="/Users/Martin/.gemini/antigravity/skills"
+SOURCE="/Users/Martin/git/agent-skills/vendor/opencode-processing-skills/skills"
+
+# execute-work-package is excluded: local copy has transport extensions (Options A/B/C)
+# that are not yet upstreamed to DasDigitaleMomentum/opencode-processing-skills.
+DDM_SKILLS="archive-legacy-docs author-and-verify-implementation-plan create-plan generate-docs generate-handover resume-plan update-docs update-plan"
+
+for skill in $DDM_SKILLS; do
+    rm -rf "${SKILLS_DIR:?}/${skill:?}"
+    cp -R "$SOURCE/$skill" "$SKILLS_DIR/$skill"
+    echo "Synced: $skill"
+done
+
+echo "Done. Total SKILL.md: $(find $SKILLS_DIR -maxdepth 2 -name SKILL.md | wc -l | tr -d ' ')"

package/bin/test-cli.js

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+
+/**
+ * Tests for bin/cli.js
+ * Run: node bin/test-cli.js
+ */
+
+const { execSync } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+const assert = require("assert");
+
+const CLI = path.join(__dirname, "cli.js");
+let passed = 0;
+let failed = 0;
+
+function test(name, fn) {
+  try {
+    fn();
+    console.log(`  PASS  ${name}`);
+    passed++;
+  } catch (err) {
+    console.log(`  FAIL  ${name}: ${err.message}`);
+    failed++;
+  }
+}
+
+function run(args) {
+  return execSync(`node "${CLI}" ${args}`, {
+    encoding: "utf8",
+    timeout: 10000,
+  });
+}
+
+console.log("CLI Tests\n");
+
+// Test: no args shows usage
+test("no args shows usage", () => {
+  const out = run("");
+  assert(out.includes("Usage"), "Should show usage");
+  assert(out.includes("install"), "Should mention install command");
+  assert(out.includes("update"), "Should mention update command");
+  assert(out.includes("list"), "Should mention list command");
+});
+
+// Test: unknown platform errors
+test("install unknown platform exits with error", () => {
+  try {
+    run("install nonexistent-platform");
+    assert.fail("Should have thrown");
+  } catch (err) {
+    const output = (err.stdout || "") + (err.stderr || "");
+    assert(output.includes("Unknown platform"), "Should say unknown platform");
+  }
+});
+
+// Test: list shows skills
+test("list command works", () => {
+  try {
+    const out = run("list");
+    assert(out.includes("Available Skills"), "Should show available skills header");
+  } catch {
+    // Skills may not be installed in test env, that's ok
+  }
+});
+
+// Test: cli.js is valid Node
+test("cli.js parses without syntax errors", () => {
+  execSync(`node -c "${CLI}"`, { encoding: "utf8" });
+});
+
+// Test: vscode platform is registered
+test("vscode platform is listed", () => {
+  const out = run("");
+  assert(out.includes("vscode"), "Should list vscode as available platform");
+});
+
+// Test: copilot-instructions.md exists
+test("copilot-instructions.md exists", () => {
+  const copilotPath = path.join(__dirname, "..", ".github", "copilot-instructions.md");
+  assert(
+    fs.existsSync(copilotPath),
+    "Should have .github/copilot-instructions.md"
+  );
+});
+
+// Test: copilot-instructions.md has required content
+test("copilot-instructions.md has skill references", () => {
+  const copilotPath = path.join(__dirname, "..", ".github", "copilot-instructions.md");
+  const content = fs.readFileSync(copilotPath, "utf8");
+  assert(content.includes("skills/"), "Should reference skills/ directory");
+  assert(content.includes("SKILL.md"), "Should mention SKILL.md");
+  assert(content.includes("CHEATSHEET.md"), "Should reference CHEATSHEET.md");
+});
+
+// Test: sync-docs.js is valid Node
+test("sync-docs.js parses without syntax errors", () => {
+  const syncDocs = path.join(__dirname, "sync-docs.js");
+  execSync(`node -c "${syncDocs}"`, { encoding: "utf8" });
+});
+
+// Test: sync-docs.js updates counts correctly
+test("sync-docs.js produces correct counts", () => {
+  const out = execSync(`node "${path.join(__dirname, "sync-docs.js")}"`, {
+    encoding: "utf8",
+    cwd: path.join(__dirname, ".."),
+  });
+  assert(out.includes("Found"), "Should report found skills");
+  assert(out.includes("Updated README.md"), "Should update README");
+  assert(out.includes("copilot-instructions"), "Should update copilot-instructions.md");
+  assert(out.includes("Done"), "Should finish successfully");
+});
+
+console.log(`\n${passed} passed, ${failed} failed\n`);
+process.exit(failed > 0 ? 1 : 0);

package/bin/update-wiki.js

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+
+/**
+ * Update the GitHub Wiki with current catalog data.
+ * Clones the wiki repo, regenerates the Skills-Catalog page, and pushes.
+ *
+ * Run: node bin/update-wiki.js
+ * Requires: git, SSH access to the wiki repo
+ */
+
+const fs = require("fs");
+const path = require("path");
+const { execSync } = require("child_process");
+
+const ROOT = path.join(__dirname, "..");
+const CATALOG = path.join(ROOT, "docs", "catalog.json");
+const WIKI_DIR = "/tmp/agent-skills-wiki";
+const WIKI_REPO = "git@github.com:flitzrrr/agent-skills.wiki.git";
+
+function run(cmd, opts) {
+  return execSync(cmd, { encoding: "utf8", ...opts }).trim();
+}
+
+function groupBy(arr, key) {
+  const map = {};
+  for (const item of arr) {
+    const k = item[key];
+    (map[k] = map[k] || []).push(item);
+  }
+  return map;
+}
+
+function main() {
+  if (!fs.existsSync(CATALOG)) {
+    console.error("catalog.json not found. Run build-catalog.js first.");
+    process.exit(1);
+  }
+
+  const catalog = JSON.parse(fs.readFileSync(CATALOG, "utf8"));
+  const grouped = groupBy(catalog.skills, "source");
+  const sourceEntries = Object.entries(grouped).sort((a, b) => b[1].length - a[1].length);
+
+  // Clone wiki
+  try {
+    if (fs.existsSync(WIKI_DIR)) {
+      run(`rm -rf ${WIKI_DIR}`);
+    }
+    run(`git clone ${WIKI_REPO} ${WIKI_DIR}`);
+  } catch (e) {
+    console.error("Failed to clone wiki repo:", e.message);
+    process.exit(1);
+  }
+
+  // Generate Skills-Catalog.md
+  let md = `# Skills Catalog\n\n`;
+  md += `> Last updated: ${catalog.generated.split("T")[0]} | **${catalog.total} skills** across **${sourceEntries.length} sources**\n\n`;
+  md += `The full searchable catalog with copy-to-clipboard is on the [GitHub Pages site](https://flitzrrr.github.io/agent-skills/#catalog).\n\n`;
+  md += `## Skills by Source\n\n`;
+
+  for (const [source, skills] of sourceEntries) {
+    md += `### ${source} (${skills.length} skills)\n\n`;
+    md += `| Skill | Description |\n`;
+    md += `|-------|-------------|\n`;
+    for (const s of skills) {
+      const desc = s.description || "--";
+      md += `| \`${s.name}\` | ${desc} |\n`;
+    }
+    md += `\n`;
+  }
+
+  fs.writeFileSync(path.join(WIKI_DIR, "Skills-Catalog.md"), md);
+
+  // Update Home page stats
+  const homePath = path.join(WIKI_DIR, "Home.md");
+  if (fs.existsSync(homePath)) {
+    let home = fs.readFileSync(homePath, "utf8");
+    // Update skill count references
+    home = home.replace(/\b\d{2,4}\+?\s+skills\b/gi, `${catalog.total}+ skills`);
+    fs.writeFileSync(homePath, home);
+  }
+
+  // Commit and push
+  try {
+    run("git add -A", { cwd: WIKI_DIR });
+    const diff = run("git diff --cached --stat", { cwd: WIKI_DIR });
+    if (!diff) {
+      console.log("Wiki is already up to date.");
+      return;
+    }
+
+    run(`git config user.name "github-actions[bot]"`, { cwd: WIKI_DIR });
+    run(`git config user.email "github-actions[bot]@users.noreply.github.com"`, { cwd: WIKI_DIR });
+    run(`git commit -m "docs: update skill catalog [${catalog.generated.split("T")[0]}]"`, { cwd: WIKI_DIR });
+    run("git push origin master", { cwd: WIKI_DIR });
+    console.log("Wiki updated and pushed.");
+  } catch (e) {
+    console.error("Failed to push wiki:", e.message);
+    process.exit(1);
+  }
+}
+
+main();

package/package.json

@@ -1,7 +1,10 @@
 {
   "name": "@flitzrrr/agent-skills",
-  "version": "1.0.3",
-  "description": "121 AI agent skills from 15 industry-leading sources — multiplatform-ready for Claude Code, Codex, Cursor, Antigravity, OpenCode, Lovable, and more.",
+  "version": "1.1.0",
+  "description": "504 AI agent skills from 19 sources — multiplatform-ready for VS Code (GitHub Copilot), Claude Code, Codex, Cursor, Antigravity, OpenCode, Lovable, and more.",
+  "scripts": {
+    "test": "node bin/test-cli.js"
+  },
   "bin": {
     "agent-skills": "bin/cli.js"
   },
@@ -9,6 +12,9 @@
     "ai",
     "agent",
     "skills",
+    "vscode",
+    "github-copilot",
+    "copilot",
     "claude",
     "codex",
     "cursor",
@@ -32,6 +38,7 @@
     "CHEATSHEET.md",
     ".cursorrules",
     ".lovable",
+    ".github/copilot-instructions.md",
     "README.md"
   ]
 }

package/skills/dispatch-parallel-agents/skill.md

@@ -0,0 +1,95 @@
+---
+name: dispatch-parallel-agents
+description: Dispatch independent tasks to parallel subagents when 2+ problems can be solved without shared state or sequential dependencies.
+license: MIT
+compatibility:
+  opencode: ">=0.1"
+metadata:
+  category: execution
+  phase: implementation
+---
+
+# Skill: Dispatch Parallel Agents
+
+This skill parallelizes independent work across multiple subagents. Each agent gets a focused scope, isolated context, and a clear deliverable.
+
+---
+
+## When to Use
+
+Use when:
+
+- 2+ independent tasks exist that do not share state
+- Each task can be understood and completed without context from the others
+- Tasks do not edit the same files
+
+Do **not** use when:
+
+- Failures are related (fixing one might fix others -- investigate together first)
+- Tasks require understanding the full system state
+- Agents would interfere with each other (editing the same files, using the same resources)
+- You are in exploratory mode and do not yet know what is broken
+
+---
+
+## Execution Model
+
+### Roles
+
+- **Primary (coordinator)**
+  - Identifies independent problem domains
+  - Crafts focused prompts for each agent
+  - Reviews results and integrates changes
+  - Resolves conflicts if agents touched overlapping code
+
+- **Subagents (workers)**
+  - Each receives a scoped task with all necessary context
+  - Works independently without knowledge of other agents
+  - Returns a summary of findings and changes
+
+---
+
+## Workflow
+
+### Step 1: Identify Independent Domains
+
+Group tasks by what they affect. Each domain must be independent -- fixing one must not affect the others.
+
+Example:
+- Domain A: Fix stats page header styling
+- Domain B: Update billing page layout
+- Domain C: Add admin role detection
+
+These are independent because they touch different files and different logic.
+
+### Step 2: Craft Agent Prompts
+
+Each agent prompt must be:
+
+- **Focused** -- one clear problem domain, not "fix everything"
+- **Self-contained** -- all context needed to understand the problem (file paths, error messages, expected behavior)
+- **Constrained** -- explicit boundaries on what the agent should and should not change
+- **Output-specific** -- what the agent should return (summary, file list, verification result)
+
+### Step 3: Dispatch
+
+Launch all agents in a single message with multiple Agent tool calls. This ensures true parallel execution.
+
+### Step 4: Review and Integrate
+
+When agents return:
+
+1. Read each agent's summary
+2. Check for conflicts (did agents edit the same code?)
+3. Verify changes work together (run build, run tests)
+4. Integrate all changes
+
+---
+
+## Rules
+
+1. **Independence is mandatory**: If tasks share state or files, do not parallelize. Process sequentially instead.
+2. **Focused prompts**: Each agent gets exactly what it needs. Do not dump full session context into agent prompts.
+3. **Verify after integration**: Always run the build and relevant tests after merging all agent outputs. Agents cannot verify cross-agent interactions.
+4. **Do not over-parallelize**: 2-3 agents is typical. More than 5 agents indicates the tasks should be structured differently (e.g., as a plan with phases).
+5. **Conflicts require manual resolution**: If two agents edited the same file, the primary resolves the conflict -- do not blindly apply both changes.

package/skills/execute-work-package/SKILL.md

@@ -0,0 +1,279 @@
+---
+name: execute-work-package
+description: Execute a significant implementation unit (phase or major slice) using a gated subagent loop (blueprint -> gate -> execute -> digest) without creating new persistent artifacts.
+license: MIT
+compatibility:
+  opencode: ">=0.1"
+  claude-code: ">=1.0"
+  cursor: ">=0.40"
+  copilot: ">=1.0"
+  codex: ">=0.1"
+  windsurf: ">=1.0"
+metadata:
+  category: execution
+  phase: implementation
+  transport_options: [mcp, stateful, fresh]
+---
+
+# Skill: Execute Work Packet
+
+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**: Fresh subagent implements and verifies
+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.
+- You want to offload implementation to a subagent without causing primary context bloat.
+- You want predictable, reviewable execution with a single explicit gate.
+
+If your phase implementation plan is still vague or unverified against the repo, run `author-and-verify-implementation-plan` first.
+
+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 packet (phase or significant phase slice).
+  - Owns Git operations (stage/commit/PR) unless explicitly delegated.
+  - Updates plan/todo via `update-plan` as needed.
+
+- **Subagent (implementer)**
+  - Does execution only.
+  - First returns a **step list**.
+  - After approval, executes those steps and returns a **digest**.
+  - Does not do Git operations.
+
+## 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 any updates to `plans/**` (typically via `update-plan`).
+- **implementer**: execution only (blueprint → execute → digest), no Git.
+- **doc-explorer**: not used for this skill (unless you explicitly want docs/plan artifacts, in which case use the appropriate planning/doc skills).
+
+### Why `docs/` and `plans/` matter here
+
+- `plans/` provides the gated intent/DoD and references for what to implement.
+- `docs/` (if present) provides curated inventories (modules/features/symbols) so the subagent does not rediscover everything.
+
+### Transport
+
+This skill supports three transport mechanisms. **If l4l MCP tools are available** (check: do you have `precheck_new`, `approve_blueprint`, `execute` tools?), **always use Option A.** Only fall back to B/C if MCP is not configured.
+
+#### Option A: MCP via l4l (Default)
+
+Use the l4l Sub-Agent MCP server. The primary calls MCP tools directly — no Agent spawning needed:
+
+1. `precheck_new(intent, scope_paths, output_format="skill")` → returns Execution Blueprint
+2. `approve_blueprint(handle_id)` → explicit gate
+3. `execute(handle_id, output_format="skill")` → returns Execution Digest
+
+Benefits: state persistence across restarts, model decoupling (cheap Sub-LLM), scope enforcement, iterative blueprint refinement.
+
+Setup: See l4l's `docs/CLAUDE_CODE_SETUP.md`.
+
+#### Option B: Stateful Subagent (OpenCode)
+
+Original design using `resumeSessionId` to maintain subagent state between BLUEPRINT and EXECUTE:
+
+- BLUEPRINT and EXECUTE use the **same** session (resumed via `resumeSessionId`)
+- The subagent retains context from the BLUEPRINT phase
+
+This is the native OpenCode pattern.
+
+#### Option C: Fresh Agent (Claude Code / Cursor / Copilot)
+
+BLUEPRINT and EXECUTE use **separate** Agent invocations (not SendMessage to resume):
+
+- **BLUEPRINT Agent**: spawned with `mode: auto`, returns the step list, then terminates.
+- **EXECUTE Agent**: spawned as a **new** Agent with the approved step list baked into the prompt. This avoids unreliable SendMessage-based resumption of idle agents.
+
+The EXECUTE prompt must include the full approved step list and all references — the agent has no memory of the BLUEPRINT agent's context.
+
+#### Platform Decision Table
+
+| Platform | Recommended | Fallback |
+|----------|------------|----------|
+| Claude Code | Option A (MCP) | Option C (Fresh Agent) |
+| Cursor | Option A (MCP) | Option C (Fresh Agent) |
+| Copilot | Option A (MCP) | Option C (Fresh Agent) |
+| Codex | Option C (Fresh Agent) | — |
+| Windsurf | Option A (MCP) | Option C (Fresh Agent) |
+| OpenCode | Option B (Stateful) | Option A (MCP) |
+
+---
+
+## Protocol
+
+### 0) Primary inputs (for any work packet)
+
+Before delegating:
+
+- Ensure the work packet is already gated (scope/DoD decided).
+- Provide an explicit **task statement** plus **references** to the relevant planning artifacts.
+  The subagent should read these references itself (the primary does not need to paste content).
+  Recommended references:
+  - `plans/<plan>/plan.md`
+  - `plans/<plan>/phases/phase-N.md`
+  - `plans/<plan>/implementation/phase-N-impl.md`
+  - `plans/<plan>/todo.md` (optional)
+- If project documentation exists, also provide references to it so the subagent can use the curated inventories
+  (symbols, modules, features) instead of rediscovering everything from scratch:
+  - `docs/overview.md` (optional)
+  - `docs/modules/*.md` (optional)
+  - `docs/features/*.md` (optional)
+- Provide a **Verify Command** if one is already decided.
+  If not, the subagent proposes exactly **one** verify command in the BLUEPRINT (to be gated by the primary).
+
+### 1) MODE: BLUEPRINT (Execution Blueprint)
+
+> **Option A (MCP):** Call `precheck_new(intent=..., scope_paths=..., output_format="skill")`. The blueprint is returned directly — no Agent spawn needed.
+
+Primary delegates to `implementer` with a prompt based on `tpl-implementer-preflight-prompt.md`.
+
+**Gate:** Primary reviews the step list and either:
+
+- Approves (GO)
+- Requests revision (feedback)
+- Aborts and replans
+
+#### Invariant: explicit approval token
+
+Primary provides an explicit approval token before execution (primary-internal gate). Example:
+
+- `APPROVE-WP1`
+
+If the user requests changes, the step list must be revised and re-approved with a new approval token.
+
+### 2) Execute (new Agent)
+
+> **Option A (MCP):** Call `approve_blueprint(handle_id)` then `execute(handle_id, output_format="skill")`. The digest is returned directly — no Agent spawn needed.
+
+Primary spawns a **new** `implementer` Agent with a prompt based on `tpl-implementer-execute-prompt.md`. The prompt includes the full approved step list, all references, and the verify command. Do NOT use SendMessage to resume the BLUEPRINT agent — spawn a fresh Agent instead.
+
+#### Invariant: MODE lock
+
+The execute prompt MUST start with a clear mode indicator:
+
+- `MODE: EXECUTE`
+
+and MUST include the approval token.
+
+> **Option A (MCP):** Skip Steps 2–3 above. The `execute` MCP tool returns the digest directly.
+
+### 3) Digest back to Primary
+
+Subagent responds with a compact digest:
+
+- Outcome (succeeded/failed)
+- Files changed (paths)
+- Verification result (command + exit)
+- If failure: only a small, relevant excerpt (no full logs)
+
+### 4) Primary post-processing
+
+Read the digest carefully. The subagent's verification result determines next steps:
+
+- **Verification passed:** Spot-check with `git diff --stat` to confirm expected changes. Do not re-run the full test suite yourself – the subagent already did.
+- **Verification failed or incomplete:** If additional testing is needed, spawn a new subagent with specific test instructions and relevant references. Do not run large test suites in the primary session.
+- **BLOCKED / no verification ran:** Decide whether to provide missing input and re-delegate, or run a targeted check yourself.
+
+Then:
+
+- Updates `plans/<plan>/todo.md` and phase status via `update-plan`
+- Commits / creates PR **only** when explicitly requested by the user
+
+Optional but recommended (Primary):
+
+- Before execute: capture baseline via `git status` / `git diff --name-only`
+- After execute: confirm changes exist via `git diff --stat`
+
+---
+
+## Output Contracts
+
+### Step List Contract (Subagent -> Primary)
+
+Subagent returns an **Execution Blueprint** in the format of `tpl-execution-blueprint.md`.
+
+The blueprint is expected to be **concrete** (file paths and/or symbol/component targets), not a restatement of plan text.
+
+#### Mode: BLUEPRINT
+
+In BLUEPRINT mode, the subagent must NOT:
+
+- apply patches
+- run commands
+- claim that code was changed
+
+### Digest Contract (Subagent -> Primary)
+
+Subagent MUST return only:
+
+- **Outcome**: succeeded | failed
+- **Edits**: list of files changed + 1-line note each
+- **Verify**: command + exit code + (if failed) small excerpt
+- **Next**: 1–3 bullets (or “ready for Primary Git/commit”)
+
+#### Mode: EXECUTE
+
+In EXECUTE mode, the subagent must:
+
+- implement changes (typically via patch/apply_patch)
+- run the verify command (via bash)
+- if neither happened: return **BLOCKED** with a concrete reason
+
+---
+
+## Rules
+
+- Subagent must not run Git operations (commit, rebase, push).
+- Skill-first: when this skill is invoked, follow its MODE + output contracts before doing anything else.
+- Keep verification minimal: **one** explicit verify command unless the work packet DoD requires more. The verify command must **exercise the changed behavior** (e.g., run relevant tests, hit the affected endpoint, trigger the modified flow) — not just compile, lint, or type-check.
+- No raw diffs or long logs in responses.
+- If verify fails: apply **minimal, targeted fixes** (no refactors) and re-run verify. If still failing or a larger change is required, stop and report a digest with a minimal relevant excerpt.
+- If the step list must change during execution: stop and ask Primary for a new gate.
+
+---
+
+## Coding Standards
+
+These apply to all code written during execution – by the implementer subagent or the primary.
+
+1. **No hardcoded defaults.** Use configuration files or environment variables for values that may change across environments.
+2. **Analyze root cause.** Don't patch symptoms. Understand why something is broken before changing code.
+3. **Minimal changes.** Only touch what the work packet requires. Don't refactor adjacent code you weren't asked to change.
+4. **Preserve existing patterns.** Match the conventions already established in the codebase (naming, structure, error handling).
+5. **No silent failures.** Don't swallow errors or add fallbacks that hide problems. If something fails, it should be visible.
+6. **Respect the dependency boundary.** Don't introduce new dependencies without explicit approval from the primary/user.
+
+If `docs/coding-standards.md` exists in the target repo, read and follow it as well – project-specific standards take precedence.
+
+---
+
+## Templates
+
+- `tpl-implementer-preflight-prompt.md` — Primary -> Subagent (MODE: BLUEPRINT) prompt
+- `tpl-implementer-execute-prompt.md` — Primary -> Subagent (MODE: EXECUTE) prompt (same `task_id`)
+- `tpl-execution-blueprint.md` — canonical blueprint format (step list)
+- `tpl-execution-digest.md` — canonical digest format

package/skills/execute-work-package/tpl-execution-blueprint.md

@@ -0,0 +1,39 @@
+---
+type: execution
+entity: blueprint
+skill: execute-work-package
+created: "{{date}}"
+---
+
+# Execution Blueprint (Step List)
+
+## Work Packet
+
+- intent: {{intent}}
+- scope_paths: {{scope_paths}}
+
+## References
+
+### Plans
+- plan: {{plan_ref}}
+- phase: {{phase_ref}}
+- implementation_plan: {{implementation_plan_ref}}
+- todo (optional): {{todo_ref}}
+
+### Docs (optional)
+- overview: {{docs_overview_ref}}
+- modules: {{docs_modules_ref}}
+- features: {{docs_features_ref}}
+
+## Steps
+
+1. <concrete step; include file path and/or symbol/component>
+2. ...
+
+## Touched Files
+
+- path/to/file
+
+## Verify
+
+`<single command>`