create-agentic-pdlc 2.3.0 → 3.0.0

package/templates/full/AGENTS.md

@@ -0,0 +1,143 @@
+# {{PROJECT_NAME}} — AI Agent Instructions
+
+This template is the contract between the project and any external AI agent 
+(Claude Code, Cursor, Copilot, Jules, Codex, Sweep, etc.). Read this before committing any change.
+
+## Project Overview
+
+{{PROJECT_DESCRIPTION}}
+
+**Structure:**
+{{PROJECT_STRUCTURE}}
+
+## Before Any Change
+
+```bash
+git fetch origin && git checkout main && git pull
+```
+
+Always start from the current `main` HEAD. Never work over stale snapshots.
+
+## Invariants / Non-negotiable business rules
+
+{{INVARIANTS}}
+<!-- Examples:
+1. **Human-in-the-Loop** — No external side-effect actions without explicit human approval.
+2. **Immutable Audit-Log** — It's strictly forbidden to UPDATE/DELETE on audit_log; INSERT only.
+3. **Credential Isolation** — Decryption occurs only in a specific service.
+-->
+
+## Mandatory Workflow
+
+0. **Identity**: Always prefix your GitHub comments with `🤖 **Agent:** ` to distinguish yourself.
+1. **Stage Check**: Before applying any label or taking any action, run `gh issue view <N> --json labels,title` to determine the issue's current stage. State: *"Issue #N — [title] — is currently at `<stage>`. Requesting confirmation to advance to `<next>`."* Wait for an explicit stage-advancement signal in this conversation turn. A prioritization signal ("work on X", "tackle X next") does **not** count as confirmation — only an explicit signal counts (e.g. "start brainstorming", "yes advance", "go"). **Exceptions — skip this step and proceed directly**:
+   - `spec:approved` → begin implementation (gate already passed)
+   - `stage:development` or `stage:testing` → issue is owned by automation; do not intervene unless explicitly asked to fix a specific problem
+   - `stage:approval` → spec already written; wait for PM to add `spec:approved` before doing anything
+2. **Initial State**: Apply the `stage:brainstorming` label using the GitHub CLI (`gh issue edit <N> --add-label "stage:brainstorming"`). **Exception — pre-spec'd issue**: if the issue body already contains all required spec sections (`## Problem`, `## Solution`, `## Acceptance Criteria`, `## Edge Cases`, `## Out of Scope`, `## Files to Modify`) — all present and non-empty — apply `stage:approval` directly in a single call instead, skipping `stage:brainstorming` and `stage:detailing`.
+3. Read the issue entirely — understand its type (US/BUG/TASK/SPIKE) and the Acceptance Criteria.
+4. Read `docs/pdlc.md` — understand the PDLC and the Definition of Done in this project.
+5. Read all files mentioned in the issue's technical context.
+6. Implement the **minimum viable change** that satisfies the ACs — do not refactor beyond scope.
+7. Run tests: `{{TEST_COMMAND}}`
+8. Run typecheck (if applicable): `{{TYPECHECK_COMMAND}}`
+9. Create a Pull Request with `Closes #N` in the body — automation moves the board.
+
+## Spec Format
+
+When writing or rewriting an issue body during detailing, include ALL sections below. Omitting any section blocks `stage:approval`.
+
+**Destination: the issue body.** Write spec content to the issue body using `gh issue edit <N> --body "..."` — not to a file. A file is acceptable as optional reference only. Automation checks the issue body for `## Acceptance Criteria` and `## Files to Modify` to advance the stage; content that exists only in a file is invisible to it.
+
+```
+## Problem
+[1-3 sentences. What fails. Who affected. Measured impact.]
+
+## Sprint Goal / Success Metrics
+| Metric | Baseline | Target | When |
+|--------|----------|--------|------|
+
+## Solution
+[Behavioral description of what is built. No implementation details.]
+
+## Acceptance Criteria
+**AC1 — [name]**
+- Given [precondition]
+- When [action]
+- Then [outcome]
+
+## Edge Cases
+- EC1: [condition] → [expected behavior]
+
+## Out of Scope
+- [item] — reason
+
+## Non-Functional Requirements
+- Performance: [metric with number]
+- Security: [constraint]
+- Reliability: [constraint]
+> For pure docs/markdown issues with zero runtime behavior, include the NFRs section and state "N/A".
+
+## Files to Modify
+- `path/to/file` — what changes
+```
+
+## Stage Transition Rules (non-negotiable)
+
+MUST apply `stage:brainstorming` label immediately on starting work — before reading
+any code, before invoking any skill. Then read context and present problem summary
++ 2–3 solution options in a single message.
+
+MUST NOT add `stage:detailing` label until the user has explicitly selected
+an approach in the current conversation turn. Work done in a prior
+planning session does NOT count as confirmation.
+
+MUST NOT add `spec:approved` or `stage:development` — these represent final
+human approval or automation output. Adding them manually triggers irreversible
+automation (Jules dispatch, board move).
+
+MUST NOT manually add `stage:approval` except via the pre-spec'd exception
+below. In the standard flow, `stage:approval` is set after you write a complete
+spec and the user confirms; it is not applied before the spec exists.
+
+Each stage transition requires a fresh explicit signal from the user in the same
+session where the transition happens. The pre-spec'd exception is the only
+deviation from this rule.
+
+**Pre-spec'd exception**: if the issue body already contains all required spec
+sections (`## Problem`, `## Solution`, `## Acceptance Criteria`, `## Edge Cases`,
+`## Out of Scope`, `## Files to Modify`) — all present and non-empty — apply
+`stage:approval` directly in a single `gh issue edit` call, skipping
+`stage:brainstorming` and `stage:detailing`. One label event eliminates the
+race condition that causes the project board to land on the wrong column.
+
+## Pipeline Updates
+
+To add or configure optional agents (Jules, QA Agent, Sentinel) at any time:
+
+```bash
+npx create-agentic-pdlc --update
+```
+
+Run this when the user says anything like "update the pipeline", "update the board", or "configure the agents". It detects what is already configured and interactively sets up what is missing — without touching this file or any user-owned config.
+
+## What NOT to do
+
+- Never commit directly to `main`.
+- Never open a PR without passing the tests.
+- Never implement beyond the immediate scope of the issue.
+- Never create future-proofing abstractions for hypothetical features.
+- The agent MUST NOT apply these labels under any circumstances (PM only):
+  - `spec:approved`: triggers Jules dispatch + board move to Development.
+  - `qa:approved`: triggers board move to Code Review.
+  - `qa:needs-work`: signals the PR requires changes and halts the flow.
+- Never add or remove stage:* labels manually, except: `stage:brainstorming` as the initial label when starting work, or `stage:approval` directly when applying the pre-spec'd exception. All other stage transitions are owned by GitHub Actions automation and the PM.
+{{EXTRA_DONT}}
+
+## Project Standards
+
+- **Tests:** `{{TEST_COMMAND}}`
+- **Lint/Types:** `{{LINT_COMMAND}}`
+- **Typecheck:** `{{TYPECHECK_COMMAND}}`
+- **Build:** `{{BUILD_COMMAND}}`
+{{EXTRA_PATTERNS}}

package/templates/full/CLAUDE.md

@@ -0,0 +1,30 @@
+<!-- agentic-full -->
+## Multi-Agent Pipeline
+
+This project uses automated agents beyond the spec gate:
+
+| Agent | Role | Trigger |
+|---|---|---|
+| Implementation Agent (Jules or custom) | Implements spec after `spec:approved` | `agent-trigger.yml` |
+| QA Agent | Verifies PR against ACs via GitHub Models | `project-automation.yml` Variant B |
+| Sentinel | Architecture audit via Gemini Code Assist CI | `architecture-violation` label |
+
+**QA Labels — automation-owned, never apply manually:**
+- `qa:approved` — QA Agent passed; card moves to Code Review
+- `qa:needs-work` — QA Agent found issues; PR flow halts
+- `infra:qa-broken` — QA Agent error; requires manual review
+
+**Board Automation:**
+`project-automation.yml` moves cards between board columns based on labels and PR events.
+Column Option IDs and Project IDs are documented in `docs/pdlc.md`.
+
+Read `docs/pdlc.md` for the full board layout, column IDs, and label reference.
+
+**Pipeline Updates:**
+To add or configure optional agents (Jules, QA Agent, Sentinel):
+```bash
+npx create-agentic-pdlc --update
+```
+
+Run this when asked to "update the pipeline", "configure the agents", or "update the board".
+It detects what is already configured and sets up what is missing — without touching user-owned files.

package/templates/{docs → full/docs}/pdlc.md

@@ -58,7 +58,7 @@ REPO         = {{REPO_OWNER}}/{{REPO_NAME}}
 ```
 [icon] [PREFIX]: [short description, imperative tense]
 
-👤 US:     user story
+✨ feat:   new feature or behavioral change
 🐛 BUG:    bug
 🔧 TASK:   operational task
 🔬 SPIKE:  exploration/evaluation spike
@@ -77,7 +77,7 @@ REPO         = {{REPO_OWNER}}/{{REPO_NAME}}
 | `qa:approved` | PR | Green | QA Agent passed — AC coverage verified |
 | `qa:needs-work` | PR | Red | QA Agent failed — PR needs changes |
 | `infra:qa-broken` | PR | Orange | QA Agent error — manual review required |
-| `type:us` | Issue | Blue | New feature or behavioral change — full flow |
+| `type:feature` | Issue | Blue | New feature or behavioral change — full flow |
 | `type:task` | Issue | Yellow | Operational/non-functional change — full flow |
 | `type:bug` | Issue | Red | Something broken — full flow |
 | `type:spike` | Issue | Gray | Research/evaluation — never reaches Development |
@@ -98,12 +98,12 @@ The `type:*` label is the authoritative signal — set automatically by the agen
 
 | Label | Flow |
 |---|---|
-| `type:us` | brainstorming → Gate 1 → detailing → approval |
+| `type:feature` | brainstorming → Gate 1 → detailing → approval |
 | `type:task` | brainstorming → Gate 1 → detailing → approval |
 | `type:bug` | brainstorming → Gate 1 → detailing → approval |
 | `type:spike` | brainstorming → Gate 1 → detailing → conclusion comment (never reaches Development) |
 
-If no `type:*` label present and agent confidence < 85%, defaults to `type:us` (safe fallback — never skips gates by omission).
+If no `type:*` label present and agent confidence < 85%, defaults to `type:feature` (safe fallback — never skips gates by omission).
 
 ## Bypass Mechanism
 

package/templates/lite/AGENTS.md

@@ -0,0 +1,121 @@
+# {{PROJECT_NAME}} — AI Agent Instructions
+
+This is the contract between the project and any external AI agent
+(Claude Code, Cursor, Copilot, Codex, Sweep, etc.). Read this before committing any change.
+
+## Project Overview
+
+{{PROJECT_DESCRIPTION}}
+
+**Structure:**
+{{PROJECT_STRUCTURE}}
+
+## Before Any Change
+
+```bash
+git fetch origin && git checkout main && git pull
+```
+
+Always start from the current `main` HEAD. Never work over stale snapshots.
+
+## Invariants / Non-negotiable business rules
+
+{{INVARIANTS}}
+<!-- Examples:
+1. **Minimum viable change** — implement exactly what the spec says; no future-proofing.
+2. **Human-in-the-Loop** — No external side-effect actions without explicit human approval.
+3. **Immutable Audit-Log** — INSERT only on audit_log; never UPDATE/DELETE.
+-->
+
+## Mandatory Workflow
+
+0. **Identity**: Always prefix your GitHub comments with `🤖 **Agent:** ` to distinguish yourself.
+1. **Stage Check**: Run `gh issue view <N> --json labels,title` to determine current stage.
+   - `spec:approved` → begin implementation (gate already passed)
+   - `stage:approval` → spec written; wait for PM to add `spec:approved`
+   - Otherwise → follow the stage gate below
+2. Apply `stage:brainstorming` before reading any code: `gh issue edit <N> --add-label "stage:brainstorming"`
+3. Read the issue entirely — understand type and Acceptance Criteria.
+4. Read all files mentioned in the issue's technical context.
+5. Present problem summary + 2–3 solution options. **Stop and wait for PM choice.**
+6. Once PM selects an approach, write the complete spec into the issue body. Advance to `stage:approval`.
+7. Wait for PM to add `spec:approved`. Then implement the **minimum viable change** that satisfies the ACs.
+8. Run tests: `{{TEST_COMMAND}}`
+9. Create a Pull Request with `Closes #N` in the body.
+
+## Spec Format
+
+**Destination: the issue body.** Write spec content using `gh issue edit <N> --body "..."` — not to a file.
+Automation checks the issue body for `## Acceptance Criteria` and `## Files to Modify`.
+
+```
+## Problem
+[1-3 sentences. What fails. Who affected. Measured impact.]
+
+## Sprint Goal / Success Metrics
+| Metric | Baseline | Target | When |
+|--------|----------|--------|------|
+
+## Solution
+[Behavioral description of what is built. No implementation details.]
+
+## Acceptance Criteria
+**AC1 — [name]**
+- Given [precondition]
+- When [action]
+- Then [outcome]
+
+## Edge Cases
+- EC1: [condition] → [expected behavior]
+
+## Out of Scope
+- [item] — reason
+
+## Non-Functional Requirements
+- Performance: [metric with number]
+- Security: [constraint]
+- Reliability: [constraint]
+> For pure docs/markdown issues with zero runtime behavior, include the NFRs section and state "N/A".
+
+## Files to Modify
+- `path/to/file` — what changes
+```
+
+## Stage Gate Labels
+
+| Label | Who sets it | Meaning |
+|---|---|---|
+| `stage:brainstorming` | Agent | Brainstorming started — first action before reading code |
+| `stage:detailing` | Agent | Spec is being written |
+| `stage:approval` | Agent | Spec complete, awaiting PM review |
+| `spec:approved` | **PM only** | Gate cleared — implement |
+
+**NEVER apply `spec:approved`, `stage:development`, or `qa:*`.** These are owned by the PM and automation.
+
+## Stage Transition Rules (non-negotiable)
+
+MUST apply `stage:brainstorming` immediately on starting work — before reading any code,
+before invoking any skill.
+
+MUST NOT add `stage:detailing` until the user has explicitly selected an approach
+in the current conversation turn.
+
+MUST NOT add `spec:approved` or any approval-trigger label under any circumstances.
+
+Each stage transition requires a fresh explicit signal from the user in the same session.
+
+## What NOT to Do
+
+- Never commit directly to `main`.
+- Never open a PR without `spec:approved` on the linked issue.
+- Never implement beyond the immediate scope of the issue.
+- Never create future-proofing abstractions for hypothetical features.
+{{EXTRA_DONT}}
+
+## Project Standards
+
+- **Tests:** `{{TEST_COMMAND}}`
+- **Lint/Types:** `{{LINT_COMMAND}}`
+- **Typecheck:** `{{TYPECHECK_COMMAND}}`
+- **Build:** `{{BUILD_COMMAND}}`
+{{EXTRA_PATTERNS}}

package/templates/lite/CLAUDE.md

@@ -0,0 +1,44 @@
+# {{PROJECT_NAME}}
+
+**What it is:** {{PROJECT_DESCRIPTION}}
+
+## Non-Negotiable Invariants
+
+1. **Minimum viable change** — implement exactly what the spec says. No refactoring beyond scope, no future-proofing, no abstractions for hypothetical needs.
+2. **Spec before code** — never edit files, create branches, or commit unless the linked issue has label `spec:approved` (set by PM only) or the branch starts with `hotfix/`.
+
+## Stage Gate
+
+Three labels gate every issue:
+
+| Label | Who sets it | What it unlocks |
+|---|---|---|
+| `stage:brainstorming` | Agent (first action) | Reading code + presenting options |
+| `stage:approval` | Agent (after spec is written) | Signals spec is ready for PM review |
+| `spec:approved` | **PM only** | Clears agent to implement |
+
+**NEVER apply `spec:approved`.** The PM sets it after reviewing the spec in the issue body. Applying it triggers irreversible automation.
+
+## Workflow
+
+1. Apply `stage:brainstorming` immediately — before reading code or invoking any tool.
+2. Read the issue. Present problem summary + 2–3 solution options. **Stop and wait for PM to choose.**
+3. Once PM selects an approach, write the complete spec into the issue body (`gh issue edit <N> --body "..."`). Advance to `stage:approval`.
+4. **Stop.** Wait for PM to add `spec:approved`.
+5. After `spec:approved`: create branch, implement minimum viable change, open PR with `Closes #N`.
+
+## Hook Behavior
+
+A `PreToolUse` hook blocks `gh pr create` unless:
+- The linked issue has `spec:approved`, **or**
+- The branch name starts with `hotfix/`
+
+If blocked: check the issue labels before retrying.
+
+## What NOT to Do
+
+- Never commit to `main` directly.
+- Never open a PR without `spec:approved` on the linked issue.
+- Never implement beyond the immediate scope of the spec.
+- Never add abstractions, error handling, or features for hypothetical future needs.
+- Never apply `spec:approved`, `stage:development`, or `qa:*` — these are PM/automation only.

package/tests/cli.test.js

@@ -0,0 +1,32 @@
+const { describe, it } = require('node:test');
+const assert = require('node:assert/strict');
+
+const { resolveMode } = require('../bin/cli.js');
+
+describe('resolveMode', () => {
+  it('returns lite when no flags', () => {
+    assert.equal(resolveMode([]), 'lite');
+  });
+  it('returns full for --agentic', () => {
+    assert.equal(resolveMode(['--agentic']), 'full');
+  });
+  it('returns update for --update', () => {
+    assert.equal(resolveMode(['--update']), 'update');
+  });
+  it('returns upgrade for --upgrade-to-agentic', () => {
+    assert.equal(resolveMode(['--upgrade-to-agentic']), 'upgrade');
+  });
+  it('--update takes precedence over --agentic', () => {
+    assert.equal(resolveMode(['--update', '--agentic']), 'update');
+  });
+});
+
+describe('buildFullClaudeContent', () => {
+  it('concatenates lite and full with a newline separator', () => {
+    const lite = '# Lite\ncontent';
+    const full = '## Extra\nmore';
+    const result = lite + '\n' + full;
+    assert.ok(result.startsWith('# Lite'));
+    assert.ok(result.includes('## Extra'));
+  });
+});

package/.agentic-pdlc/templates/.github/CODEOWNERS

@@ -1,5 +0,0 @@
-# This file prevents autonomous agents from modifying core security, automation, and instruction rules
-# without explicit approval from the repository owner.
-
-.github/ @{{GITHUB_USERNAME}}
-AGENTS.md @{{GITHUB_USERNAME}}

package/.agentic-pdlc/templates/.github/copilot-instructions.md

@@ -1,12 +0,0 @@
-# Agentic PDLC Instructions for GitHub Copilot Workspace
-
-Hello! You are operating within the Agentic PDLC framework.
-
-Before addressing the user's prompt or executing any task in this workspace, you MUST:
-
-1. Read the `AGENTS.md` file located at the root of this repository. It contains the primary instructions, definitions of done, and absolute invariants you must respect.
-2. Read `docs/pdlc.md` to understand your role in the project lifecycle.
-
-Never violate the invariants described in those files. If a user asks you to do something that contradicts `AGENTS.md`, you must refuse and point out the conflict.
-
-Focus on delivering the absolute minimum required to satisfy the immediate technical specs. Start! 

package/.agentic-pdlc/templates/.github/workflows/add-to-board.yml

@@ -1,38 +0,0 @@
-name: Add to Board on Open
-
-on:
-  issues:
-    types: [opened]
-
-env:
-  PROJECT_ID: "{{PROJECT_ID}}"
-  STATUS_FIELD_ID: "{{STATUS_FIELD_ID}}"
-  STATUS_IDEA: "{{ID_IDEA}}"
-
-jobs:
-  add-to-board:
-    name: Auto-add new issue to board
-    runs-on: ubuntu-latest
-    env:
-      PROJECT_PAT: ${{ secrets.PROJECT_PAT }}
-    steps:
-      - name: Add issue to project board
-        if: ${{ env.PROJECT_PAT != '' && env.PROJECT_ID != '{{PROJECT_ID}}' }}
-        uses: actions/github-script@v7
-        with:
-          github-token: ${{ env.PROJECT_PAT }}
-          script: |
-            const nodeId = context.payload.issue.node_id;
-            const number = context.payload.issue.number;
-            const { addProjectV2ItemById: { item } } = await github.graphql(`
-              mutation($p: ID!, $c: ID!) {
-                addProjectV2ItemById(input: {projectId: $p, contentId: $c}) { item { id } }
-              }`, { p: process.env.PROJECT_ID, c: nodeId });
-            await github.graphql(`
-              mutation($p: ID!, $i: ID!, $f: ID!, $v: ProjectV2FieldValue!) {
-                updateProjectV2ItemFieldValue(input: {projectId: $p, itemId: $i, fieldId: $f, value: $v}) {
-                  projectV2Item { id }
-                }
-              }`, { p: process.env.PROJECT_ID, i: item.id, f: process.env.STATUS_FIELD_ID,
-                   v: { singleSelectOptionId: process.env.STATUS_IDEA } });
-            console.log(`Issue #${number} added to board → Idea`);

package/.agentic-pdlc/templates/.github/workflows/agent-trigger.yml

@@ -1,146 +0,0 @@
-name: Trigger Implementation Agent
-
-# Triggers when spec:approved is added to an issue (Gate 2)
-# or when an architecture-violation issue is modified (Sentinel flow)
-on:
-  issues:
-    types: [labeled]
-
-jobs:
-  trigger-implementation-agent:
-    name: Trigger {{IMPLEMENTATION_AGENT_NAME}} for implementation
-    # Runs only when spec:approved is added
-    if: github.event.label.name == 'spec:approved'
-    runs-on: ubuntu-latest
-    permissions:
-      issues: write
-      pull-requests: write
-      contents: read
-    env:
-      PROJECT_PAT: ${{ secrets.PROJECT_PAT }}
-      PROJECT_ID: "{{PROJECT_ID}}"
-      STATUS_FIELD_ID: "{{STATUS_FIELD_ID}}"
-      STATUS_DEVELOPMENT: "{{ID_DEVELOPMENT}}"
-    steps:
-      - name: Update Labels
-        uses: actions/github-script@v7
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          script: |
-            const { owner, repo } = context.repo;
-            const issue_number = context.payload.issue.number;
-
-            try {
-              await github.rest.issues.removeLabel({
-                owner,
-                repo,
-                issue_number,
-                name: 'stage:approval'
-              });
-            } catch (error) {
-              console.log('Label stage:approval not found or could not be removed');
-            }
-
-            const agentLabel = '{{IMPLEMENTATION_AGENT_LABEL}}';
-            const labelsToAdd = ['stage:development'];
-            if (!agentLabel.includes('{{')) labelsToAdd.push(agentLabel, 'agent:working');
-
-            await github.rest.issues.addLabels({
-              owner,
-              repo,
-              issue_number,
-              labels: labelsToAdd
-            });
-
-      - name: Move board card to Development
-        if: ${{ env.PROJECT_PAT != '' && env.PROJECT_ID != '{{PROJECT_ID}}' }}
-        continue-on-error: true
-        uses: actions/github-script@v7
-        with:
-          github-token: ${{ env.PROJECT_PAT }}
-          script: |
-            const nodeId = context.payload.issue.node_id;
-            const number = context.payload.issue.number;
-            const { addProjectV2ItemById: { item } } = await github.graphql(`
-              mutation($p: ID!, $c: ID!) {
-                addProjectV2ItemById(input: {projectId: $p, contentId: $c}) { item { id } }
-              }`, { p: process.env.PROJECT_ID, c: nodeId });
-            await github.graphql(`
-              mutation($p: ID!, $i: ID!, $f: ID!, $v: ProjectV2FieldValue!) {
-                updateProjectV2ItemFieldValue(input: {projectId: $p, itemId: $i, fieldId: $f, value: $v}) {
-                  projectV2Item { id }
-                }
-              }`, { p: process.env.PROJECT_ID, i: item.id, f: process.env.STATUS_FIELD_ID,
-                   v: { singleSelectOptionId: process.env.STATUS_DEVELOPMENT } });
-            console.log(`Issue #${number} → Development`);
-
-      - name: Comment on issue to trigger agent and prevent race conditions
-        if: ${{ !contains('{{IMPLEMENTATION_AGENT_LABEL}}', '{{') && vars.JULES_ENABLED == 'true' }}
-        uses: actions/github-script@v7
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          script: |
-            const issueNumber = context.payload.issue.number;
-            const issueTitle = context.payload.issue.title;
-
-            const body = [
-              `🤖 **Agentic PDLC Orchestrator:** I have dispatched the implementation agent. Please wait for the Pull Request and avoid making concurrent commits on this task to prevent race conditions.`,
-              '',
-              `{{AGENT_HANDLE}} The spec for this issue has been approved. Please implement it exactly as described in the body above.`,
-              '',
-              '**Mandatory steps before you begin:**',
-              '1. `git fetch origin && git checkout main && git pull` — always start from the current HEAD',
-              '2. Read `AGENTS.md` — mandatory rules for agents in this repository',
-              '3. Read `docs/pdlc.md` — Definition of Done and invariants reference',
-              '',
-              '**Rules:**',
-              '- Implement strictly what the Acceptance Criteria describes',
-              '- Run `{{TEST_COMMAND}}` before opening the Pull Request',
-              `- Include \`Closes #${issueNumber}\` in the PR body`,
-              '- Create a descriptive branch branching from `main`',
-            ].join('\n');
-
-            await github.rest.issues.createComment({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              issue_number: issueNumber,
-              body,
-            });
-
-  trigger-agent-on-violation:
-    name: Trigger {{IMPLEMENTATION_AGENT_NAME}} for architecture violation
-    # Runs when architecture-violation is added (Sentinel flow)
-    if: github.event.label.name == 'architecture-violation'
-    runs-on: ubuntu-latest
-    permissions:
-      issues: write
-      pull-requests: write
-      contents: read
-    steps:
-      - name: Comment on issue to trigger agent
-        if: ${{ !contains('{{IMPLEMENTATION_AGENT_LABEL}}', '{{') && vars.JULES_ENABLED == 'true' }}
-        uses: actions/github-script@v7
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          script: |
-            const issueNumber = context.payload.issue.number;
-
-            const body = [
-              `{{AGENT_HANDLE}} Please fix the architecture violation described in this issue.`,
-              '',
-              '**Mandatory steps before you begin:**',
-              '1. `git fetch origin && git checkout main && git pull` — always start from the current HEAD',
-              '2. Read `AGENTS.md` — mandatory rules for agents in this repository',
-              '',
-              '**Rules:**',
-              '- Fix only what the violation points out — do not refactor unrelated code',
-              '- Run `{{TEST_COMMAND}}` before opening the Pull Request',
-              `- Include \`Closes #${issueNumber}\` in the PR body`,
-            ].join('\n');
-
-            await github.rest.issues.createComment({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              issue_number: issueNumber,
-              body,
-            });

package/.agentic-pdlc/templates/.github/workflows/auto-approve.yml

@@ -1,16 +0,0 @@
-name: Auto Approve PRs
-on:
-  pull_request:
-    types: [opened, labeled, synchronize]
-
-permissions:
-  pull-requests: write
-
-jobs:
-  auto-approve:
-    runs-on: ubuntu-latest
-    if: contains(github.event.pull_request.labels.*.name, 'auto-approve')
-    steps:
-      - uses: hmarr/auto-approve-action@v4
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}