@athenaflow/plugin-fullstack-engineering 0.1.1

package/.claude-plugin/plugin.json

@@ -0,0 +1,19 @@
+{
+  "name": "fullstack-engineering",
+  "description": "User-invocable companion to the fullstack-engineering Workflow. Ships a single skill that captures the same state machine \u2014 Brainstorm \u2192 Isolate \u2192 Plan \u2192 Execute (TDD + browser pass) \u2192 Manual QA \u2192 Finish \u2014 for on-demand use without running the full Workflow loop.",
+  "version": "0.1.1",
+  "author": {
+    "name": "Athenaflow"
+  },
+  "keywords": [
+    "fullstack",
+    "engineering",
+    "workflow",
+    "tdd",
+    "browser-pass",
+    "alignment",
+    "phase-gates"
+  ],
+  "category": "engineering",
+  "repository": "https://github.com/AthenaFlow/workflow-marketplace"
+}

package/.codex-plugin/plugin.json

@@ -0,0 +1,15 @@
+{
+  "name": "fullstack-engineering",
+  "version": "0.1.1",
+  "description": "User-invocable companion to the fullstack-engineering Workflow. Ships a single skill that captures the same state machine \u2014 Brainstorm \u2192 Isolate \u2192 Plan \u2192 Execute (TDD + browser pass) \u2192 Manual QA \u2192 Finish \u2014 for on-demand use without running the full Workflow loop.",
+  "author": {
+    "name": "Athenaflow"
+  },
+  "skills": "./skills/",
+  "interface": {
+    "displayName": "Full-Stack Engineering",
+    "shortDescription": "On-demand companion to the fullstack-engineering Workflow",
+    "developerName": "Athenaflow",
+    "category": "Engineering"
+  }
+}

package/dist/0.1.1/.agents/plugins/marketplace.json

@@ -0,0 +1,14 @@
+{
+  "schemaVersion": 1,
+  "name": "athena-workflow-marketplace",
+  "plugins": [
+    {
+      "name": "fullstack-engineering",
+      "version": "0.1.1",
+      "source": {
+        "source": "local",
+        "path": "./codex/plugin"
+      }
+    }
+  ]
+}

package/dist/0.1.1/GENERATED.md

@@ -0,0 +1,12 @@
+# Generated artifacts
+
+Built by `scripts/build-plugin-artifacts.mjs` (or `npm run build:artifacts` from `plugins/fullstack-engineering`).
+
+**Do not hand-edit any file in this directory.** Edits are clobbered on the next build.
+
+Source of truth:
+- Per-plugin Manifests: `../../.claude-plugin/plugin.json`, `../../.codex-plugin/plugin.json`
+- Skills: `../../skills/`
+- Marketplace Registries: repo-root `.claude-plugin/marketplace.json` and `.agents/plugins/marketplace.json`
+
+Built version: 0.1.1

package/dist/0.1.1/claude/plugin/.claude-plugin/plugin.json

@@ -0,0 +1,19 @@
+{
+  "name": "fullstack-engineering",
+  "description": "User-invocable companion to the fullstack-engineering Workflow. Ships a single skill that captures the same state machine \u2014 Brainstorm \u2192 Isolate \u2192 Plan \u2192 Execute (TDD + browser pass) \u2192 Manual QA \u2192 Finish \u2014 for on-demand use without running the full Workflow loop.",
+  "version": "0.1.1",
+  "author": {
+    "name": "Athenaflow"
+  },
+  "keywords": [
+    "fullstack",
+    "engineering",
+    "workflow",
+    "tdd",
+    "browser-pass",
+    "alignment",
+    "phase-gates"
+  ],
+  "category": "engineering",
+  "repository": "https://github.com/AthenaFlow/workflow-marketplace"
+}

package/dist/0.1.1/claude/plugin/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@athenaflow/plugin-fullstack-engineering",
+  "version": "0.1.1",
+  "description": "User-invocable companion to the fullstack-engineering Workflow.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lespaceman/athena-workflow-marketplace.git",
+    "directory": "plugins/fullstack-engineering"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    ".claude-plugin/",
+    ".codex-plugin/",
+    "skills/",
+    "dist/"
+  ]
+}

package/dist/0.1.1/claude/plugin/skills/fullstack-engineering/PHASES.md

@@ -0,0 +1,111 @@
+# Phase pipeline (reference detail)
+
+Each phase has: **Entry** (input artifact required to enter), **Do** (the action — invoke the owning skill where one exists; otherwise follow the procedure here), and **Exit** (output artifact required to leave).
+
+The inner-loop skills (`grill-with-docs`, `grill-me`, `to-prd`, `to-issues`, `tdd`, `diagnose`, `zoom-out`, `prototype`, `improve-codebase-architecture`, `write-a-skill`) come from Matt Pocock's [Skills For Real Engineers](https://github.com/mattpocock/skills) and are used here under their original terms. Browser verification comes from this repo's own `agent-web-interface` plugin.
+
+## 1. Brainstorm — `grill-with-docs` (code) or `grill-me` (non-code)
+
+- **Entry:** any new request. Treat every request as rough unless an approved design doc / PRD exists on disk or an approved lightweight session plan already exists.
+- **Do:** invoke `grill-with-docs` for code work — it interviews you against the project's domain language (`CONTEXT.md`) and decisions (`docs/adr/`), then updates those docs inline as decisions crystallise. Use `grill-me` for non-code or pure design alignment without doc updates.
+- **Simple-task exit:** approved lightweight session plan stating goal, intended files, verification. No PRD required.
+- **Full-task exit artifact:** approved design document / PRD on disk (often produced by following the grilling session with `to-prd`). Use for ambiguous, multi-step, architectural, user-visible, or risky work.
+- **No code in this phase.**
+- **You are NOT in this phase if:** an approved design doc / PRD or session plan already exists. Move to Phase 2.
+
+## 2. Isolate — manual phase
+
+There is no Pocock skill for git worktree setup. Run this directly:
+
+- **Entry:** approved design doc / PRD, or approved lightweight session plan.
+- **Do:**
+  1. `git worktree add ../<repo>-<branch> -b <branch>` from the repo root.
+  2. `cd` into the worktree and run project setup (install deps, env files).
+  3. Run the full test suite once to confirm a clean **green baseline** before touching anything. If the baseline is red, stop and fix the baseline (or surface to the user) before proceeding.
+- **Exit artifact:** worktree on a new branch with verified green baseline.
+- **Skip rule:** never skip this even for "small" changes. Isolation is what makes the rest of the pipeline safe.
+
+## 3. Plan — `to-prd` then `to-issues`
+
+- **Entry:** approved design doc / brainstorming output + clean worktree. Simple tasks with a session plan can skip and execute from the session plan.
+- **Do:**
+  1. `to-prd` — synthesize the conversation context into a PRD on the project issue tracker. No fresh interview; it captures what was already discussed. Skip if a PRD already exists.
+  2. `to-issues` — break the PRD into independently-grabbable issues using tracer-bullet vertical slices. Each issue should be a 2–5 minute task with exact file paths, the complete change, and verification steps.
+- **Exit artifact:** issue list (or plan file) of discrete, independently verifiable tasks.
+- **Skip rule:** "I'll just remember the steps" is not a plan. Write the issues / plan file.
+
+## 4. Execute — manual loop, with `tdd` mandatory inside each task
+
+- **Entry:** approved plan / issue list on disk, or approved lightweight session plan.
+- **Do:** pick one task at a time. For each task:
+  - **TDD via `tdd`:** failing test → watch it fail → minimal code → watch it pass → refactor → commit. Vertical slice per cycle, never horizontal (don't write all tests then all code). Code written before its test gets deleted.
+  - **Browser pass via `agent-web-interface` for any user-visible behavior:** load `agent-web-interface:agent-web-interface-guide` first, then exercise against a running dev server. Capture a screenshot/snapshot. Code-level green tests do not substitute. If there is no UI surface yet, say so explicitly — do not silently skip.
+  - **Bug surfaces mid-task → `diagnose`:** if something is broken, throwing, failing, or behaving inconsistently, switch into the disciplined diagnosis loop (reproduce → minimise → hypothesise → instrument → fix → regression-test). Do not patch by guessing.
+  - **Unfamiliar code → `zoom-out`:** before editing code you do not yet understand, zoom out for the broader context.
+- **Exit per task:** test green + browser-pass artifact (or explicit no-UI declaration) + review findings addressed.
+
+## 5. Review — manual phase (between tasks, not a separate phase)
+
+There is no Pocock skill for between-task code review. Default approach:
+
+- After each task (or end of a small related batch), have the user — or a fresh subagent — read the diff against the task's stated verification.
+- Critical findings block the next task. Lower-severity findings can be tracked and addressed later — but tracked, not forgotten.
+- For codebase-wide drift after several tasks (modules getting tangled, names diverging from `CONTEXT.md`), run `improve-codebase-architecture` to find deepening opportunities and consolidate.
+
+## 6. Finish — manual phase
+
+There is no Pocock skill for finishing a development branch. Procedure:
+
+- **Entry:** all planned tasks complete, tests green, no open critical review issues.
+- **Do:**
+  1. Run the full test suite one more time — must be green.
+  2. Final `agent-web-interface` browser pass across the whole feature: golden path + every edge case named in the design.
+  3. **Default action in this repo: merge locally to `main` and remove the worktree.** Skip the 4-option integration prompt. Only stop and ask the user if: tests fail, the merge has conflicts, the base branch isn't `main`, or the user has explicitly asked for a PR instead.
+  4. Destructive fallbacks (discard) still require typed confirmation.
+- **Exit:** branch merged to `main`, worktree cleaned up.
+
+## Pinned skills and plugins
+
+### Matt Pocock's [Skills For Real Engineers](https://github.com/mattpocock/skills) — process discipline
+
+These cover the inner loops the workflow leans on. Used under their original terms; credit to Matt Pocock.
+
+- `grill-with-docs` — alignment + shared language; interview against `CONTEXT.md` and `docs/adr/` and update both inline. Phase 1 default for code work.
+- `grill-me` — alignment without doc updates. Phase 1 fallback for non-code/simple sessions.
+- `to-prd` — synthesize current conversation into a PRD on the issue tracker. Phase 3 step 1.
+- `to-issues` — break a PRD/plan into vertical-slice issues. Phase 3 step 2.
+- `tdd` — red-green-refactor; vertical slices only. Mandatory inside every Phase 4 task that produces code.
+- `diagnose` — reproduce → minimise → hypothesise → instrument → fix → regression-test. Use whenever a bug surfaces mid-execution.
+- `zoom-out` — broader/system-level context for unfamiliar code. Use before editing code you do not understand.
+- `prototype` — throwaway terminal app or several radically different UI variations to flush out a design before committing. Optional Phase 1 aid.
+- `improve-codebase-architecture` — find deepening opportunities; consolidate tangled modules. Run periodically between tasks; ideal between feature batches.
+- `triage` — issue-tracker state machine when managing a backlog of incoming bugs / feature requests.
+- `write-a-skill` — when authoring or editing a skill (including this one).
+
+Skills with no Pocock equivalent (worktree setup, between-task code review, finishing) are run as manual procedures defined per phase above.
+
+### `tanstack-start` — frontend/full-stack framework knowledge
+
+Use whenever the task involves TanStack Start, TanStack Router, server functions, server routes, SSR, RSC, or migrating from Next.js. Core skill: `tanstack-start:tanstack-start-guide`. Domain-specific skills under `skills/upstream/@tanstack/...` cover routing, Start internals, the router plugin, virtual file routes, and React Server Components. Consult these before hand-rolling routing or data patterns.
+
+### `frontend-design` — UI quality and product-facing design
+
+Use whenever the task includes a user-visible screen, flow, layout, interaction pattern, or visual state. Load before making UI decisions so the implementation has deliberate hierarchy, responsive behavior, accessibility, and domain-appropriate visual polish instead of framework-default screens.
+
+### `shadcn` — component library and design system
+
+Use whenever UI work needs accessible primitives, form patterns, theming, or registry components. Skill: `shadcn:shadcn-ui`. Prefer installing from the shadcn registry over hand-writing button/input/dialog primitives.
+
+### `agent-web-interface` — live browser interaction (mandatory test layer)
+
+Required test layer for anything user-visible. Every Phase 4 task that builds or modifies UI, a route, a server function exposed to the browser, an API consumed by the UI, or any end-to-end flow MUST be exercised against a running dev server through `mcp__plugin_agent-web-interface_browser__*` tools before being considered done. Unit and integration tests do not substitute.
+
+Skill: `agent-web-interface:agent-web-interface-guide`. **Load it BEFORE any `mcp__plugin_agent-web-interface_browser__*` tool call** so observations are structured and selectors are stable.
+
+Use it to walk the golden path, exercise edge cases and error states named in the design, capture a screenshot/snapshot as the task's verification artifact, and spot regressions in adjacent flows the change could plausibly affect.
+
+If the app cannot be exercised this way (no dev server, pure backend with no client yet), say so explicitly in the verification step — do not silently skip the browser pass.
+
+## Attribution
+
+The inner-loop process discipline in this skill is adapted from **Matt Pocock's [Skills For Real Engineers](https://github.com/mattpocock/skills)**. The phase scaffolding (Brainstorm → Isolate → Plan → Execute → Review → Finish) and the mandatory browser-pass test layer (`agent-web-interface`) are this repo's own. All trademarks and links are property of their respective owners.

package/dist/0.1.1/claude/plugin/skills/fullstack-engineering/SKILL.md

@@ -0,0 +1,111 @@
+---
+name: fullstack-engineering
+description: End-to-end engineering workflow as a state machine - Brainstorm → Isolate → Plan → Execute (TDD + browser pass) → Review → Finish. Each phase has a required input and exit artifact on disk. Use when starting any non-trivial feature, bug fix, or refactor; when the user wants disciplined process with phase gates, design docs, plan files, worktrees, TDD, and browser verification; when they say "fullstack engineering", "follow the workflow", "do this properly end to end", or coordinate brainstorming + planning + execution together. Not for one-line edits, doc tweaks, or read-only investigation.
+---
+
+# Full-Stack Engineering
+
+A state machine, not a suggestion. Each phase has a required input artifact and exit artifact, both on disk. **You may not act outside the current phase.** If you are about to take an action that does not match your current phase, STOP and re-enter the correct phase first.
+
+If you think there is even a 1% chance you are skipping a phase, you are skipping a phase.
+
+The skill leans on Matt Pocock's [Skills For Real Engineers](https://github.com/mattpocock/skills) for the inner loops (alignment, planning, TDD, diagnosis). See [PHASES.md](PHASES.md) for full attribution.
+
+## The only thing you do every turn
+
+Before any other tool call, every single turn, run the **Phase Detector** and announce the result. No exceptions — not for "quick" edits, not for "obvious" fixes, not for "just one file", not even for clarifying questions that touch code.
+
+### Phase Detector (run first, every turn)
+
+Check artifacts on disk in this exact order. The **first** matching row tells you the phase.
+
+For simple, low-risk tasks, a lightweight planning session may satisfy Phase 1 — record the brief plan in the session naming the task, intended files, and verification. Use a full design doc and plan file for anything ambiguous, multi-step, architectural, user-visible, or risky.
+
+| Check (in order) | Phase | Owning skill |
+|---|---|---|
+| All planned tasks done + tests green + integration option not chosen yet | **6. Finish** | (no skill — see PHASES.md) |
+| Plan file / issue list exists with incomplete tasks | **4. Execute** (+ Review between tasks) | `tdd` per task; `diagnose` if a bug surfaces |
+| Approved lightweight session plan + worktree exists | **4. Execute** | `tdd` per task |
+| Approved design doc / PRD + worktree + no plan file | **3. Plan** | `to-prd` then `to-issues` |
+| Approved design doc + no worktree | **2. Isolate** | (no skill — see PHASES.md) |
+| Approved lightweight session plan + no worktree | **2. Isolate** | (no skill — see PHASES.md) |
+| Anything else (new request, vague idea, no approved plan/design) | **1. Brainstorm** | `grill-with-docs` (code) or `grill-me` (non-code) |
+
+Announce, in one line, before any other tool call:
+`Phase: <N. Name> — invoking <skill or "manual phase">. Artifacts seen: <what you found>.`
+
+When a phase has an owning skill, invoke it via the Skill tool before doing anything else. When a phase has no owning skill (Isolate, Finish), follow the procedure in [PHASES.md](PHASES.md) directly.
+
+## Hard rules (override everything else)
+
+1. **No code without an approved design doc / PRD or lightweight session plan.** If `Edit`/`Write`/`MultiEdit` is about to touch source files and neither exists, you are in Phase 1, not Phase 4.
+2. **No code without a plan.** Full tasks → plan file or issue list on disk. Simple tasks → approved session plan naming task, files, verification.
+3. **No production code outside an active TDD cycle.** Failing test first, watch it fail, then minimum code to pass. Code written before its test gets deleted. (Use `tdd`.)
+4. **No "done" claim on user-visible work without a browser pass.** A screenshot or page snapshot from `mcp__plugin_agent-web-interface_browser__*` is the only acceptable proof. "Tests pass" is not proof.
+5. **Critical review findings block the next task.** Fix before advancing.
+6. **New scope means a new Brainstorm.** No expanding scope mid-execution. (Re-enter `grill-with-docs`.)
+7. **Surface blockers, do not guess.** Missing creds, decisions, or access → stop and ask.
+
+Violating any of these is a workflow failure, not a shortcut.
+
+## Red-flag thoughts — these mean STOP
+
+If any of these appear, you are about to skip a phase.
+
+| Thought | Why it's wrong |
+|---|---|
+| "Small change, I'll just edit it." | Small changes still need a planning session. |
+| "I already know the design." | If it's not on disk and approved, it's a guess. Run `grill-with-docs`. |
+| "Let me explore the codebase first." | Exploration belongs inside Brainstorm or Plan. Use `zoom-out` for unfamiliar code. |
+| "I'll write the test after I see if it works." | Not TDD. Test first. Code without a prior test gets deleted. |
+| "Unit tests pass, task is done." | User-visible tasks need a browser-pass artifact. |
+| "I'll fix this critical finding next task." | Critical findings block forward motion. |
+| "User just wants me to do X, not follow process." | They installed this workflow on purpose. |
+| "I'll add this related improvement while I'm here." | New scope = new Brainstorm. |
+| "I'll answer their question quickly without a skill." | Phase Detector runs even for questions. |
+
+## Phase decision flow
+
+```
+            ┌─────────────────────────────┐
+            │  New turn — run Phase       │
+            │  Detector (artifacts on     │
+            │  disk decide the phase)     │
+            └──────────────┬──────────────┘
+                           │
+    ┌──────────────────────┼──────────────────────┐
+    │                      │                      │
+no approved          design/plan +          plan file or
+plan/design?         no worktree?           tasks remaining?
+    │                      │                      │
+    ▼                      ▼                      ▼
+Phase 1: Brainstorm    Phase 2: Isolate      Phase 4: Execute
+(grill-with-docs       (manual: worktree     (tdd per task;
+ / grill-me)            + green baseline)     diagnose on bugs;
+                                              browser pass via
+                                              agent-web-interface)
+                                                  │
+                                                  ▼
+                                              all done +
+                                              tests green
+                                                  │
+                                                  ▼
+                                              Phase 6: Finish
+                                              (manual: merge to
+                                               main + cleanup)
+```
+
+## When you cannot proceed
+
+If a phase is blocked by missing requirements, credentials, environment access, or a user decision: **stop with the exact blocker and the next required input.** Do not skip ahead. Do not guess. Stuck-and-asking is a correct state; pretending-to-progress is not.
+
+## Self-check before every tool call
+
+Before any tool call other than the Skill tool invoking the phase's owning skill (or, for skill-less phases, the first action of that phase):
+
+1. Did I run the Phase Detector this turn?
+2. Did I announce the phase?
+3. Did I invoke the owning skill (or follow PHASES.md for skill-less phases)?
+4. Is the tool I'm about to call something that phase would actually have me do right now?
+
+If any answer is no, stop and fix it.

package/dist/0.1.1/claude/plugin/skills/fullstack-engineering/agents/claude.yaml

@@ -0,0 +1,2 @@
+frontmatter:
+  user-invocable: true

package/dist/0.1.1/claude/plugin/skills/fullstack-engineering/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Full-Stack Engineering"
+  short_description: "On-demand companion to the fullstack-engineering Workflow — same state machine, invoked once instead of looped"
+  default_prompt: "Walk me through the fullstack-engineering state machine for this change: foundation check, alignment, isolate, plan, execute (TDD + browser pass), review, manual QA, finish."

package/dist/0.1.1/codex/plugin/.codex-plugin/plugin.json

@@ -0,0 +1,15 @@
+{
+  "name": "fullstack-engineering",
+  "version": "0.1.1",
+  "description": "User-invocable companion to the fullstack-engineering Workflow. Ships a single skill that captures the same state machine \u2014 Brainstorm \u2192 Isolate \u2192 Plan \u2192 Execute (TDD + browser pass) \u2192 Manual QA \u2192 Finish \u2014 for on-demand use without running the full Workflow loop.",
+  "author": {
+    "name": "Athenaflow"
+  },
+  "skills": "./skills/",
+  "interface": {
+    "displayName": "Full-Stack Engineering",
+    "shortDescription": "On-demand companion to the fullstack-engineering Workflow",
+    "developerName": "Athenaflow",
+    "category": "Engineering"
+  }
+}

package/dist/0.1.1/codex/plugin/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@athenaflow/plugin-fullstack-engineering",
+  "version": "0.1.1",
+  "description": "User-invocable companion to the fullstack-engineering Workflow.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lespaceman/athena-workflow-marketplace.git",
+    "directory": "plugins/fullstack-engineering"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    ".claude-plugin/",
+    ".codex-plugin/",
+    "skills/",
+    "dist/"
+  ]
+}

package/dist/0.1.1/codex/plugin/skills/fullstack-engineering/PHASES.md

@@ -0,0 +1,111 @@
+# Phase pipeline (reference detail)
+
+Each phase has: **Entry** (input artifact required to enter), **Do** (the action — invoke the owning skill where one exists; otherwise follow the procedure here), and **Exit** (output artifact required to leave).
+
+The inner-loop skills (`grill-with-docs`, `grill-me`, `to-prd`, `to-issues`, `tdd`, `diagnose`, `zoom-out`, `prototype`, `improve-codebase-architecture`, `write-a-skill`) come from Matt Pocock's [Skills For Real Engineers](https://github.com/mattpocock/skills) and are used here under their original terms. Browser verification comes from this repo's own `agent-web-interface` plugin.
+
+## 1. Brainstorm — `grill-with-docs` (code) or `grill-me` (non-code)
+
+- **Entry:** any new request. Treat every request as rough unless an approved design doc / PRD exists on disk or an approved lightweight session plan already exists.
+- **Do:** invoke `grill-with-docs` for code work — it interviews you against the project's domain language (`CONTEXT.md`) and decisions (`docs/adr/`), then updates those docs inline as decisions crystallise. Use `grill-me` for non-code or pure design alignment without doc updates.
+- **Simple-task exit:** approved lightweight session plan stating goal, intended files, verification. No PRD required.
+- **Full-task exit artifact:** approved design document / PRD on disk (often produced by following the grilling session with `to-prd`). Use for ambiguous, multi-step, architectural, user-visible, or risky work.
+- **No code in this phase.**
+- **You are NOT in this phase if:** an approved design doc / PRD or session plan already exists. Move to Phase 2.
+
+## 2. Isolate — manual phase
+
+There is no Pocock skill for git worktree setup. Run this directly:
+
+- **Entry:** approved design doc / PRD, or approved lightweight session plan.
+- **Do:**
+  1. `git worktree add ../<repo>-<branch> -b <branch>` from the repo root.
+  2. `cd` into the worktree and run project setup (install deps, env files).
+  3. Run the full test suite once to confirm a clean **green baseline** before touching anything. If the baseline is red, stop and fix the baseline (or surface to the user) before proceeding.
+- **Exit artifact:** worktree on a new branch with verified green baseline.
+- **Skip rule:** never skip this even for "small" changes. Isolation is what makes the rest of the pipeline safe.
+
+## 3. Plan — `to-prd` then `to-issues`
+
+- **Entry:** approved design doc / brainstorming output + clean worktree. Simple tasks with a session plan can skip and execute from the session plan.
+- **Do:**
+  1. `to-prd` — synthesize the conversation context into a PRD on the project issue tracker. No fresh interview; it captures what was already discussed. Skip if a PRD already exists.
+  2. `to-issues` — break the PRD into independently-grabbable issues using tracer-bullet vertical slices. Each issue should be a 2–5 minute task with exact file paths, the complete change, and verification steps.
+- **Exit artifact:** issue list (or plan file) of discrete, independently verifiable tasks.
+- **Skip rule:** "I'll just remember the steps" is not a plan. Write the issues / plan file.
+
+## 4. Execute — manual loop, with `tdd` mandatory inside each task
+
+- **Entry:** approved plan / issue list on disk, or approved lightweight session plan.
+- **Do:** pick one task at a time. For each task:
+  - **TDD via `tdd`:** failing test → watch it fail → minimal code → watch it pass → refactor → commit. Vertical slice per cycle, never horizontal (don't write all tests then all code). Code written before its test gets deleted.
+  - **Browser pass via `agent-web-interface` for any user-visible behavior:** load `agent-web-interface:agent-web-interface-guide` first, then exercise against a running dev server. Capture a screenshot/snapshot. Code-level green tests do not substitute. If there is no UI surface yet, say so explicitly — do not silently skip.
+  - **Bug surfaces mid-task → `diagnose`:** if something is broken, throwing, failing, or behaving inconsistently, switch into the disciplined diagnosis loop (reproduce → minimise → hypothesise → instrument → fix → regression-test). Do not patch by guessing.
+  - **Unfamiliar code → `zoom-out`:** before editing code you do not yet understand, zoom out for the broader context.
+- **Exit per task:** test green + browser-pass artifact (or explicit no-UI declaration) + review findings addressed.
+
+## 5. Review — manual phase (between tasks, not a separate phase)
+
+There is no Pocock skill for between-task code review. Default approach:
+
+- After each task (or end of a small related batch), have the user — or a fresh subagent — read the diff against the task's stated verification.
+- Critical findings block the next task. Lower-severity findings can be tracked and addressed later — but tracked, not forgotten.
+- For codebase-wide drift after several tasks (modules getting tangled, names diverging from `CONTEXT.md`), run `improve-codebase-architecture` to find deepening opportunities and consolidate.
+
+## 6. Finish — manual phase
+
+There is no Pocock skill for finishing a development branch. Procedure:
+
+- **Entry:** all planned tasks complete, tests green, no open critical review issues.
+- **Do:**
+  1. Run the full test suite one more time — must be green.
+  2. Final `agent-web-interface` browser pass across the whole feature: golden path + every edge case named in the design.
+  3. **Default action in this repo: merge locally to `main` and remove the worktree.** Skip the 4-option integration prompt. Only stop and ask the user if: tests fail, the merge has conflicts, the base branch isn't `main`, or the user has explicitly asked for a PR instead.
+  4. Destructive fallbacks (discard) still require typed confirmation.
+- **Exit:** branch merged to `main`, worktree cleaned up.
+
+## Pinned skills and plugins
+
+### Matt Pocock's [Skills For Real Engineers](https://github.com/mattpocock/skills) — process discipline
+
+These cover the inner loops the workflow leans on. Used under their original terms; credit to Matt Pocock.
+
+- `grill-with-docs` — alignment + shared language; interview against `CONTEXT.md` and `docs/adr/` and update both inline. Phase 1 default for code work.
+- `grill-me` — alignment without doc updates. Phase 1 fallback for non-code/simple sessions.
+- `to-prd` — synthesize current conversation into a PRD on the issue tracker. Phase 3 step 1.
+- `to-issues` — break a PRD/plan into vertical-slice issues. Phase 3 step 2.
+- `tdd` — red-green-refactor; vertical slices only. Mandatory inside every Phase 4 task that produces code.
+- `diagnose` — reproduce → minimise → hypothesise → instrument → fix → regression-test. Use whenever a bug surfaces mid-execution.
+- `zoom-out` — broader/system-level context for unfamiliar code. Use before editing code you do not understand.
+- `prototype` — throwaway terminal app or several radically different UI variations to flush out a design before committing. Optional Phase 1 aid.
+- `improve-codebase-architecture` — find deepening opportunities; consolidate tangled modules. Run periodically between tasks; ideal between feature batches.
+- `triage` — issue-tracker state machine when managing a backlog of incoming bugs / feature requests.
+- `write-a-skill` — when authoring or editing a skill (including this one).
+
+Skills with no Pocock equivalent (worktree setup, between-task code review, finishing) are run as manual procedures defined per phase above.
+
+### `tanstack-start` — frontend/full-stack framework knowledge
+
+Use whenever the task involves TanStack Start, TanStack Router, server functions, server routes, SSR, RSC, or migrating from Next.js. Core skill: `tanstack-start:tanstack-start-guide`. Domain-specific skills under `skills/upstream/@tanstack/...` cover routing, Start internals, the router plugin, virtual file routes, and React Server Components. Consult these before hand-rolling routing or data patterns.
+
+### `frontend-design` — UI quality and product-facing design
+
+Use whenever the task includes a user-visible screen, flow, layout, interaction pattern, or visual state. Load before making UI decisions so the implementation has deliberate hierarchy, responsive behavior, accessibility, and domain-appropriate visual polish instead of framework-default screens.
+
+### `shadcn` — component library and design system
+
+Use whenever UI work needs accessible primitives, form patterns, theming, or registry components. Skill: `shadcn:shadcn-ui`. Prefer installing from the shadcn registry over hand-writing button/input/dialog primitives.
+
+### `agent-web-interface` — live browser interaction (mandatory test layer)
+
+Required test layer for anything user-visible. Every Phase 4 task that builds or modifies UI, a route, a server function exposed to the browser, an API consumed by the UI, or any end-to-end flow MUST be exercised against a running dev server through `mcp__plugin_agent-web-interface_browser__*` tools before being considered done. Unit and integration tests do not substitute.
+
+Skill: `agent-web-interface:agent-web-interface-guide`. **Load it BEFORE any `mcp__plugin_agent-web-interface_browser__*` tool call** so observations are structured and selectors are stable.
+
+Use it to walk the golden path, exercise edge cases and error states named in the design, capture a screenshot/snapshot as the task's verification artifact, and spot regressions in adjacent flows the change could plausibly affect.
+
+If the app cannot be exercised this way (no dev server, pure backend with no client yet), say so explicitly in the verification step — do not silently skip the browser pass.
+
+## Attribution
+
+The inner-loop process discipline in this skill is adapted from **Matt Pocock's [Skills For Real Engineers](https://github.com/mattpocock/skills)**. The phase scaffolding (Brainstorm → Isolate → Plan → Execute → Review → Finish) and the mandatory browser-pass test layer (`agent-web-interface`) are this repo's own. All trademarks and links are property of their respective owners.

package/dist/0.1.1/codex/plugin/skills/fullstack-engineering/SKILL.md

@@ -0,0 +1,111 @@
+---
+name: fullstack-engineering
+description: End-to-end engineering workflow as a state machine - Brainstorm → Isolate → Plan → Execute (TDD + browser pass) → Review → Finish. Each phase has a required input and exit artifact on disk. Use when starting any non-trivial feature, bug fix, or refactor; when the user wants disciplined process with phase gates, design docs, plan files, worktrees, TDD, and browser verification; when they say "fullstack engineering", "follow the workflow", "do this properly end to end", or coordinate brainstorming + planning + execution together. Not for one-line edits, doc tweaks, or read-only investigation.
+---
+
+# Full-Stack Engineering
+
+A state machine, not a suggestion. Each phase has a required input artifact and exit artifact, both on disk. **You may not act outside the current phase.** If you are about to take an action that does not match your current phase, STOP and re-enter the correct phase first.
+
+If you think there is even a 1% chance you are skipping a phase, you are skipping a phase.
+
+The skill leans on Matt Pocock's [Skills For Real Engineers](https://github.com/mattpocock/skills) for the inner loops (alignment, planning, TDD, diagnosis). See [PHASES.md](PHASES.md) for full attribution.
+
+## The only thing you do every turn
+
+Before any other tool call, every single turn, run the **Phase Detector** and announce the result. No exceptions — not for "quick" edits, not for "obvious" fixes, not for "just one file", not even for clarifying questions that touch code.
+
+### Phase Detector (run first, every turn)
+
+Check artifacts on disk in this exact order. The **first** matching row tells you the phase.
+
+For simple, low-risk tasks, a lightweight planning session may satisfy Phase 1 — record the brief plan in the session naming the task, intended files, and verification. Use a full design doc and plan file for anything ambiguous, multi-step, architectural, user-visible, or risky.
+
+| Check (in order) | Phase | Owning skill |
+|---|---|---|
+| All planned tasks done + tests green + integration option not chosen yet | **6. Finish** | (no skill — see PHASES.md) |
+| Plan file / issue list exists with incomplete tasks | **4. Execute** (+ Review between tasks) | `tdd` per task; `diagnose` if a bug surfaces |
+| Approved lightweight session plan + worktree exists | **4. Execute** | `tdd` per task |
+| Approved design doc / PRD + worktree + no plan file | **3. Plan** | `to-prd` then `to-issues` |
+| Approved design doc + no worktree | **2. Isolate** | (no skill — see PHASES.md) |
+| Approved lightweight session plan + no worktree | **2. Isolate** | (no skill — see PHASES.md) |
+| Anything else (new request, vague idea, no approved plan/design) | **1. Brainstorm** | `grill-with-docs` (code) or `grill-me` (non-code) |
+
+Announce, in one line, before any other tool call:
+`Phase: <N. Name> — invoking <skill or "manual phase">. Artifacts seen: <what you found>.`
+
+When a phase has an owning skill, invoke it via the Skill tool before doing anything else. When a phase has no owning skill (Isolate, Finish), follow the procedure in [PHASES.md](PHASES.md) directly.
+
+## Hard rules (override everything else)
+
+1. **No code without an approved design doc / PRD or lightweight session plan.** If `Edit`/`Write`/`MultiEdit` is about to touch source files and neither exists, you are in Phase 1, not Phase 4.
+2. **No code without a plan.** Full tasks → plan file or issue list on disk. Simple tasks → approved session plan naming task, files, verification.
+3. **No production code outside an active TDD cycle.** Failing test first, watch it fail, then minimum code to pass. Code written before its test gets deleted. (Use `tdd`.)
+4. **No "done" claim on user-visible work without a browser pass.** A screenshot or page snapshot from `mcp__plugin_agent-web-interface_browser__*` is the only acceptable proof. "Tests pass" is not proof.
+5. **Critical review findings block the next task.** Fix before advancing.
+6. **New scope means a new Brainstorm.** No expanding scope mid-execution. (Re-enter `grill-with-docs`.)
+7. **Surface blockers, do not guess.** Missing creds, decisions, or access → stop and ask.
+
+Violating any of these is a workflow failure, not a shortcut.
+
+## Red-flag thoughts — these mean STOP
+
+If any of these appear, you are about to skip a phase.
+
+| Thought | Why it's wrong |
+|---|---|
+| "Small change, I'll just edit it." | Small changes still need a planning session. |
+| "I already know the design." | If it's not on disk and approved, it's a guess. Run `grill-with-docs`. |
+| "Let me explore the codebase first." | Exploration belongs inside Brainstorm or Plan. Use `zoom-out` for unfamiliar code. |
+| "I'll write the test after I see if it works." | Not TDD. Test first. Code without a prior test gets deleted. |
+| "Unit tests pass, task is done." | User-visible tasks need a browser-pass artifact. |
+| "I'll fix this critical finding next task." | Critical findings block forward motion. |
+| "User just wants me to do X, not follow process." | They installed this workflow on purpose. |
+| "I'll add this related improvement while I'm here." | New scope = new Brainstorm. |
+| "I'll answer their question quickly without a skill." | Phase Detector runs even for questions. |
+
+## Phase decision flow
+
+```
+            ┌─────────────────────────────┐
+            │  New turn — run Phase       │
+            │  Detector (artifacts on     │
+            │  disk decide the phase)     │
+            └──────────────┬──────────────┘
+                           │
+    ┌──────────────────────┼──────────────────────┐
+    │                      │                      │
+no approved          design/plan +          plan file or
+plan/design?         no worktree?           tasks remaining?
+    │                      │                      │
+    ▼                      ▼                      ▼
+Phase 1: Brainstorm    Phase 2: Isolate      Phase 4: Execute
+(grill-with-docs       (manual: worktree     (tdd per task;
+ / grill-me)            + green baseline)     diagnose on bugs;
+                                              browser pass via
+                                              agent-web-interface)
+                                                  │
+                                                  ▼
+                                              all done +
+                                              tests green
+                                                  │
+                                                  ▼
+                                              Phase 6: Finish
+                                              (manual: merge to
+                                               main + cleanup)
+```
+
+## When you cannot proceed
+
+If a phase is blocked by missing requirements, credentials, environment access, or a user decision: **stop with the exact blocker and the next required input.** Do not skip ahead. Do not guess. Stuck-and-asking is a correct state; pretending-to-progress is not.
+
+## Self-check before every tool call
+
+Before any tool call other than the Skill tool invoking the phase's owning skill (or, for skill-less phases, the first action of that phase):
+
+1. Did I run the Phase Detector this turn?
+2. Did I announce the phase?
+3. Did I invoke the owning skill (or follow PHASES.md for skill-less phases)?
+4. Is the tool I'm about to call something that phase would actually have me do right now?
+
+If any answer is no, stop and fix it.

package/dist/0.1.1/codex/plugin/skills/fullstack-engineering/agents/claude.yaml

@@ -0,0 +1,2 @@
+frontmatter:
+  user-invocable: true

package/dist/0.1.1/codex/plugin/skills/fullstack-engineering/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Full-Stack Engineering"
+  short_description: "On-demand companion to the fullstack-engineering Workflow — same state machine, invoked once instead of looped"
+  default_prompt: "Walk me through the fullstack-engineering state machine for this change: foundation check, alignment, isolate, plan, execute (TDD + browser pass), review, manual QA, finish."

package/dist/0.1.1/release.json

@@ -0,0 +1,18 @@
+{
+  "schemaVersion": 1,
+  "pluginRef": "fullstack-engineering@athena-workflow-marketplace",
+  "pluginName": "fullstack-engineering",
+  "marketplaceName": "athena-workflow-marketplace",
+  "version": "0.1.1",
+  "artifacts": {
+    "claude": {
+      "type": "directory",
+      "path": "./claude/plugin"
+    },
+    "codex": {
+      "type": "marketplace",
+      "marketplacePath": "./.agents/plugins/marketplace.json",
+      "pluginPath": "./codex/plugin"
+    }
+  }
+}

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@athenaflow/plugin-fullstack-engineering",
+  "version": "0.1.1",
+  "description": "User-invocable companion to the fullstack-engineering Workflow.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lespaceman/athena-workflow-marketplace.git",
+    "directory": "plugins/fullstack-engineering"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    ".claude-plugin/",
+    ".codex-plugin/",
+    "skills/",
+    "dist/"
+  ],
+  "scripts": {
+    "build:artifacts": "node ../../scripts/build-plugin-artifacts.mjs .",
+    "prepack": "npm run build:artifacts"
+  }
+}

package/skills/fullstack-engineering/PHASES.md

@@ -0,0 +1,111 @@
+# Phase pipeline (reference detail)
+
+Each phase has: **Entry** (input artifact required to enter), **Do** (the action — invoke the owning skill where one exists; otherwise follow the procedure here), and **Exit** (output artifact required to leave).
+
+The inner-loop skills (`grill-with-docs`, `grill-me`, `to-prd`, `to-issues`, `tdd`, `diagnose`, `zoom-out`, `prototype`, `improve-codebase-architecture`, `write-a-skill`) come from Matt Pocock's [Skills For Real Engineers](https://github.com/mattpocock/skills) and are used here under their original terms. Browser verification comes from this repo's own `agent-web-interface` plugin.
+
+## 1. Brainstorm — `grill-with-docs` (code) or `grill-me` (non-code)
+
+- **Entry:** any new request. Treat every request as rough unless an approved design doc / PRD exists on disk or an approved lightweight session plan already exists.
+- **Do:** invoke `grill-with-docs` for code work — it interviews you against the project's domain language (`CONTEXT.md`) and decisions (`docs/adr/`), then updates those docs inline as decisions crystallise. Use `grill-me` for non-code or pure design alignment without doc updates.
+- **Simple-task exit:** approved lightweight session plan stating goal, intended files, verification. No PRD required.
+- **Full-task exit artifact:** approved design document / PRD on disk (often produced by following the grilling session with `to-prd`). Use for ambiguous, multi-step, architectural, user-visible, or risky work.
+- **No code in this phase.**
+- **You are NOT in this phase if:** an approved design doc / PRD or session plan already exists. Move to Phase 2.
+
+## 2. Isolate — manual phase
+
+There is no Pocock skill for git worktree setup. Run this directly:
+
+- **Entry:** approved design doc / PRD, or approved lightweight session plan.
+- **Do:**
+  1. `git worktree add ../<repo>-<branch> -b <branch>` from the repo root.
+  2. `cd` into the worktree and run project setup (install deps, env files).
+  3. Run the full test suite once to confirm a clean **green baseline** before touching anything. If the baseline is red, stop and fix the baseline (or surface to the user) before proceeding.
+- **Exit artifact:** worktree on a new branch with verified green baseline.
+- **Skip rule:** never skip this even for "small" changes. Isolation is what makes the rest of the pipeline safe.
+
+## 3. Plan — `to-prd` then `to-issues`
+
+- **Entry:** approved design doc / brainstorming output + clean worktree. Simple tasks with a session plan can skip and execute from the session plan.
+- **Do:**
+  1. `to-prd` — synthesize the conversation context into a PRD on the project issue tracker. No fresh interview; it captures what was already discussed. Skip if a PRD already exists.
+  2. `to-issues` — break the PRD into independently-grabbable issues using tracer-bullet vertical slices. Each issue should be a 2–5 minute task with exact file paths, the complete change, and verification steps.
+- **Exit artifact:** issue list (or plan file) of discrete, independently verifiable tasks.
+- **Skip rule:** "I'll just remember the steps" is not a plan. Write the issues / plan file.
+
+## 4. Execute — manual loop, with `tdd` mandatory inside each task
+
+- **Entry:** approved plan / issue list on disk, or approved lightweight session plan.
+- **Do:** pick one task at a time. For each task:
+  - **TDD via `tdd`:** failing test → watch it fail → minimal code → watch it pass → refactor → commit. Vertical slice per cycle, never horizontal (don't write all tests then all code). Code written before its test gets deleted.
+  - **Browser pass via `agent-web-interface` for any user-visible behavior:** load `agent-web-interface:agent-web-interface-guide` first, then exercise against a running dev server. Capture a screenshot/snapshot. Code-level green tests do not substitute. If there is no UI surface yet, say so explicitly — do not silently skip.
+  - **Bug surfaces mid-task → `diagnose`:** if something is broken, throwing, failing, or behaving inconsistently, switch into the disciplined diagnosis loop (reproduce → minimise → hypothesise → instrument → fix → regression-test). Do not patch by guessing.
+  - **Unfamiliar code → `zoom-out`:** before editing code you do not yet understand, zoom out for the broader context.
+- **Exit per task:** test green + browser-pass artifact (or explicit no-UI declaration) + review findings addressed.
+
+## 5. Review — manual phase (between tasks, not a separate phase)
+
+There is no Pocock skill for between-task code review. Default approach:
+
+- After each task (or end of a small related batch), have the user — or a fresh subagent — read the diff against the task's stated verification.
+- Critical findings block the next task. Lower-severity findings can be tracked and addressed later — but tracked, not forgotten.
+- For codebase-wide drift after several tasks (modules getting tangled, names diverging from `CONTEXT.md`), run `improve-codebase-architecture` to find deepening opportunities and consolidate.
+
+## 6. Finish — manual phase
+
+There is no Pocock skill for finishing a development branch. Procedure:
+
+- **Entry:** all planned tasks complete, tests green, no open critical review issues.
+- **Do:**
+  1. Run the full test suite one more time — must be green.
+  2. Final `agent-web-interface` browser pass across the whole feature: golden path + every edge case named in the design.
+  3. **Default action in this repo: merge locally to `main` and remove the worktree.** Skip the 4-option integration prompt. Only stop and ask the user if: tests fail, the merge has conflicts, the base branch isn't `main`, or the user has explicitly asked for a PR instead.
+  4. Destructive fallbacks (discard) still require typed confirmation.
+- **Exit:** branch merged to `main`, worktree cleaned up.
+
+## Pinned skills and plugins
+
+### Matt Pocock's [Skills For Real Engineers](https://github.com/mattpocock/skills) — process discipline
+
+These cover the inner loops the workflow leans on. Used under their original terms; credit to Matt Pocock.
+
+- `grill-with-docs` — alignment + shared language; interview against `CONTEXT.md` and `docs/adr/` and update both inline. Phase 1 default for code work.
+- `grill-me` — alignment without doc updates. Phase 1 fallback for non-code/simple sessions.
+- `to-prd` — synthesize current conversation into a PRD on the issue tracker. Phase 3 step 1.
+- `to-issues` — break a PRD/plan into vertical-slice issues. Phase 3 step 2.
+- `tdd` — red-green-refactor; vertical slices only. Mandatory inside every Phase 4 task that produces code.
+- `diagnose` — reproduce → minimise → hypothesise → instrument → fix → regression-test. Use whenever a bug surfaces mid-execution.
+- `zoom-out` — broader/system-level context for unfamiliar code. Use before editing code you do not understand.
+- `prototype` — throwaway terminal app or several radically different UI variations to flush out a design before committing. Optional Phase 1 aid.
+- `improve-codebase-architecture` — find deepening opportunities; consolidate tangled modules. Run periodically between tasks; ideal between feature batches.
+- `triage` — issue-tracker state machine when managing a backlog of incoming bugs / feature requests.
+- `write-a-skill` — when authoring or editing a skill (including this one).
+
+Skills with no Pocock equivalent (worktree setup, between-task code review, finishing) are run as manual procedures defined per phase above.
+
+### `tanstack-start` — frontend/full-stack framework knowledge
+
+Use whenever the task involves TanStack Start, TanStack Router, server functions, server routes, SSR, RSC, or migrating from Next.js. Core skill: `tanstack-start:tanstack-start-guide`. Domain-specific skills under `skills/upstream/@tanstack/...` cover routing, Start internals, the router plugin, virtual file routes, and React Server Components. Consult these before hand-rolling routing or data patterns.
+
+### `frontend-design` — UI quality and product-facing design
+
+Use whenever the task includes a user-visible screen, flow, layout, interaction pattern, or visual state. Load before making UI decisions so the implementation has deliberate hierarchy, responsive behavior, accessibility, and domain-appropriate visual polish instead of framework-default screens.
+
+### `shadcn` — component library and design system
+
+Use whenever UI work needs accessible primitives, form patterns, theming, or registry components. Skill: `shadcn:shadcn-ui`. Prefer installing from the shadcn registry over hand-writing button/input/dialog primitives.
+
+### `agent-web-interface` — live browser interaction (mandatory test layer)
+
+Required test layer for anything user-visible. Every Phase 4 task that builds or modifies UI, a route, a server function exposed to the browser, an API consumed by the UI, or any end-to-end flow MUST be exercised against a running dev server through `mcp__plugin_agent-web-interface_browser__*` tools before being considered done. Unit and integration tests do not substitute.
+
+Skill: `agent-web-interface:agent-web-interface-guide`. **Load it BEFORE any `mcp__plugin_agent-web-interface_browser__*` tool call** so observations are structured and selectors are stable.
+
+Use it to walk the golden path, exercise edge cases and error states named in the design, capture a screenshot/snapshot as the task's verification artifact, and spot regressions in adjacent flows the change could plausibly affect.
+
+If the app cannot be exercised this way (no dev server, pure backend with no client yet), say so explicitly in the verification step — do not silently skip the browser pass.
+
+## Attribution
+
+The inner-loop process discipline in this skill is adapted from **Matt Pocock's [Skills For Real Engineers](https://github.com/mattpocock/skills)**. The phase scaffolding (Brainstorm → Isolate → Plan → Execute → Review → Finish) and the mandatory browser-pass test layer (`agent-web-interface`) are this repo's own. All trademarks and links are property of their respective owners.

package/skills/fullstack-engineering/SKILL.md

@@ -0,0 +1,111 @@
+---
+name: fullstack-engineering
+description: End-to-end engineering workflow as a state machine - Brainstorm → Isolate → Plan → Execute (TDD + browser pass) → Review → Finish. Each phase has a required input and exit artifact on disk. Use when starting any non-trivial feature, bug fix, or refactor; when the user wants disciplined process with phase gates, design docs, plan files, worktrees, TDD, and browser verification; when they say "fullstack engineering", "follow the workflow", "do this properly end to end", or coordinate brainstorming + planning + execution together. Not for one-line edits, doc tweaks, or read-only investigation.
+---
+
+# Full-Stack Engineering
+
+A state machine, not a suggestion. Each phase has a required input artifact and exit artifact, both on disk. **You may not act outside the current phase.** If you are about to take an action that does not match your current phase, STOP and re-enter the correct phase first.
+
+If you think there is even a 1% chance you are skipping a phase, you are skipping a phase.
+
+The skill leans on Matt Pocock's [Skills For Real Engineers](https://github.com/mattpocock/skills) for the inner loops (alignment, planning, TDD, diagnosis). See [PHASES.md](PHASES.md) for full attribution.
+
+## The only thing you do every turn
+
+Before any other tool call, every single turn, run the **Phase Detector** and announce the result. No exceptions — not for "quick" edits, not for "obvious" fixes, not for "just one file", not even for clarifying questions that touch code.
+
+### Phase Detector (run first, every turn)
+
+Check artifacts on disk in this exact order. The **first** matching row tells you the phase.
+
+For simple, low-risk tasks, a lightweight planning session may satisfy Phase 1 — record the brief plan in the session naming the task, intended files, and verification. Use a full design doc and plan file for anything ambiguous, multi-step, architectural, user-visible, or risky.
+
+| Check (in order) | Phase | Owning skill |
+|---|---|---|
+| All planned tasks done + tests green + integration option not chosen yet | **6. Finish** | (no skill — see PHASES.md) |
+| Plan file / issue list exists with incomplete tasks | **4. Execute** (+ Review between tasks) | `tdd` per task; `diagnose` if a bug surfaces |
+| Approved lightweight session plan + worktree exists | **4. Execute** | `tdd` per task |
+| Approved design doc / PRD + worktree + no plan file | **3. Plan** | `to-prd` then `to-issues` |
+| Approved design doc + no worktree | **2. Isolate** | (no skill — see PHASES.md) |
+| Approved lightweight session plan + no worktree | **2. Isolate** | (no skill — see PHASES.md) |
+| Anything else (new request, vague idea, no approved plan/design) | **1. Brainstorm** | `grill-with-docs` (code) or `grill-me` (non-code) |
+
+Announce, in one line, before any other tool call:
+`Phase: <N. Name> — invoking <skill or "manual phase">. Artifacts seen: <what you found>.`
+
+When a phase has an owning skill, invoke it via the Skill tool before doing anything else. When a phase has no owning skill (Isolate, Finish), follow the procedure in [PHASES.md](PHASES.md) directly.
+
+## Hard rules (override everything else)
+
+1. **No code without an approved design doc / PRD or lightweight session plan.** If `Edit`/`Write`/`MultiEdit` is about to touch source files and neither exists, you are in Phase 1, not Phase 4.
+2. **No code without a plan.** Full tasks → plan file or issue list on disk. Simple tasks → approved session plan naming task, files, verification.
+3. **No production code outside an active TDD cycle.** Failing test first, watch it fail, then minimum code to pass. Code written before its test gets deleted. (Use `tdd`.)
+4. **No "done" claim on user-visible work without a browser pass.** A screenshot or page snapshot from `mcp__plugin_agent-web-interface_browser__*` is the only acceptable proof. "Tests pass" is not proof.
+5. **Critical review findings block the next task.** Fix before advancing.
+6. **New scope means a new Brainstorm.** No expanding scope mid-execution. (Re-enter `grill-with-docs`.)
+7. **Surface blockers, do not guess.** Missing creds, decisions, or access → stop and ask.
+
+Violating any of these is a workflow failure, not a shortcut.
+
+## Red-flag thoughts — these mean STOP
+
+If any of these appear, you are about to skip a phase.
+
+| Thought | Why it's wrong |
+|---|---|
+| "Small change, I'll just edit it." | Small changes still need a planning session. |
+| "I already know the design." | If it's not on disk and approved, it's a guess. Run `grill-with-docs`. |
+| "Let me explore the codebase first." | Exploration belongs inside Brainstorm or Plan. Use `zoom-out` for unfamiliar code. |
+| "I'll write the test after I see if it works." | Not TDD. Test first. Code without a prior test gets deleted. |
+| "Unit tests pass, task is done." | User-visible tasks need a browser-pass artifact. |
+| "I'll fix this critical finding next task." | Critical findings block forward motion. |
+| "User just wants me to do X, not follow process." | They installed this workflow on purpose. |
+| "I'll add this related improvement while I'm here." | New scope = new Brainstorm. |
+| "I'll answer their question quickly without a skill." | Phase Detector runs even for questions. |
+
+## Phase decision flow
+
+```
+            ┌─────────────────────────────┐
+            │  New turn — run Phase       │
+            │  Detector (artifacts on     │
+            │  disk decide the phase)     │
+            └──────────────┬──────────────┘
+                           │
+    ┌──────────────────────┼──────────────────────┐
+    │                      │                      │
+no approved          design/plan +          plan file or
+plan/design?         no worktree?           tasks remaining?
+    │                      │                      │
+    ▼                      ▼                      ▼
+Phase 1: Brainstorm    Phase 2: Isolate      Phase 4: Execute
+(grill-with-docs       (manual: worktree     (tdd per task;
+ / grill-me)            + green baseline)     diagnose on bugs;
+                                              browser pass via
+                                              agent-web-interface)
+                                                  │
+                                                  ▼
+                                              all done +
+                                              tests green
+                                                  │
+                                                  ▼
+                                              Phase 6: Finish
+                                              (manual: merge to
+                                               main + cleanup)
+```
+
+## When you cannot proceed
+
+If a phase is blocked by missing requirements, credentials, environment access, or a user decision: **stop with the exact blocker and the next required input.** Do not skip ahead. Do not guess. Stuck-and-asking is a correct state; pretending-to-progress is not.
+
+## Self-check before every tool call
+
+Before any tool call other than the Skill tool invoking the phase's owning skill (or, for skill-less phases, the first action of that phase):
+
+1. Did I run the Phase Detector this turn?
+2. Did I announce the phase?
+3. Did I invoke the owning skill (or follow PHASES.md for skill-less phases)?
+4. Is the tool I'm about to call something that phase would actually have me do right now?
+
+If any answer is no, stop and fix it.

package/skills/fullstack-engineering/agents/claude.yaml

@@ -0,0 +1,2 @@
+frontmatter:
+  user-invocable: true

package/skills/fullstack-engineering/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Full-Stack Engineering"
+  short_description: "On-demand companion to the fullstack-engineering Workflow — same state machine, invoked once instead of looped"
+  default_prompt: "Walk me through the fullstack-engineering state machine for this change: foundation check, alignment, isolate, plan, execute (TDD + browser pass), review, manual QA, finish."