create-agentic-pdlc 2.1.6 → 2.2.1

package/.agentic-pdlc/templates/.github/workflows/agentic-metrics.yml

@@ -0,0 +1,412 @@
+name: Agentic Metrics — Weekly Pulse
+
+on:
+  schedule:
+    - cron: '0 8 * * 0' # Sunday 8am UTC
+  workflow_dispatch:
+
+permissions:
+  contents: write
+  issues: write
+
+jobs:
+  generate-pulse:
+    name: Generate Weekly Agentic Pulse
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Collect Stage Residence Time
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const fs = require('fs');
+
+            const { owner, repo } = context.repo;
+            const since = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString();
+            const STAGE_LABELS = new Set([
+              'stage:exploration', 'stage:brainstorming', 'stage:detailing',
+              'stage:approval', 'stage:development', 'stage:testing'
+            ]);
+
+            const QUERY = `
+              query($owner: String!, $repo: String!, $since: DateTime!, $cursor: String) {
+                repository(owner: $owner, name: $repo) {
+                  issues(first: 50, after: $cursor, filterBy: { since: $since }) {
+                    pageInfo { hasNextPage endCursor }
+                    nodes {
+                      number
+                      timelineItems(first: 100, itemTypes: [LABELED_EVENT, UNLABELED_EVENT]) {
+                        nodes {
+                          ... on LabeledEvent   { __typename createdAt label { name } }
+                          ... on UnlabeledEvent { __typename createdAt label { name } }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            `;
+
+            const records = [];
+            let cursor = null;
+            do {
+              const result = await github.graphql(QUERY, { owner, repo, since, cursor });
+              const { nodes, pageInfo } = result.repository.issues;
+
+              for (const issue of nodes) {
+                const events = issue.timelineItems.nodes
+                  .filter(e => e.label && STAGE_LABELS.has(e.label.name))
+                  .sort((a, b) => new Date(a.createdAt) - new Date(b.createdAt));
+
+                const labeledAt = {};
+                for (const ev of events) {
+                  const stage = ev.label.name;
+                  if (ev.__typename === 'LabeledEvent') {
+                    labeledAt[stage] = new Date(ev.createdAt);
+                  } else if (ev.__typename === 'UnlabeledEvent' && labeledAt[stage]) {
+                    const durationDays = Math.round((new Date(ev.createdAt) - labeledAt[stage]) / 864e5 * 10) / 10;
+                    records.push({ issueNumber: issue.number, stage, durationDays });
+                    delete labeledAt[stage];
+                  }
+                }
+              }
+
+              cursor = pageInfo.hasNextPage ? pageInfo.endCursor : null;
+            } while (cursor);
+
+            function isoWeek(d) {
+              const dt = new Date(Date.UTC(d.getFullYear(), d.getMonth(), d.getDate()));
+              dt.setUTCDate(dt.getUTCDate() + 4 - (dt.getUTCDay() || 7));
+              const y = new Date(Date.UTC(dt.getUTCFullYear(), 0, 1));
+              return { year: dt.getUTCFullYear(), week: Math.ceil((((dt - y) / 86400000) + 1) / 7) };
+            }
+
+            const { year, week } = isoWeek(new Date());
+            const weekKey = `${year}-W${String(week).padStart(2, '0')}`;
+
+            fs.mkdirSync('.agentic-pdlc/metrics/raw', { recursive: true });
+            fs.writeFileSync(
+              `.agentic-pdlc/metrics/raw/${weekKey}.jsonl`,
+              records.map(r => JSON.stringify(r)).join('\n')
+            );
+
+            core.exportVariable('WEEK_KEY', weekKey);
+            console.log(`Collected ${records.length} stage transitions → week ${weekKey}`);
+
+      - name: Commit JSONL raw data
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add .agentic-pdlc/metrics/raw/
+          git diff --staged --quiet && echo "No new stage data" && exit 0
+          git commit -m "metrics: raw stage data ${WEEK_KEY} [skip ci]"
+          git push
+
+      - name: Collect PR and Issue Insights
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const fs = require('fs');
+            const { owner, repo } = context.repo;
+            const weekKey = process.env.WEEK_KEY;
+
+            // ── Helper ──────────────────────────────────────────────────────
+            function daysSince(isoStr) {
+              return (Date.now() - new Date(isoStr).getTime()) / 864e5;
+            }
+            function round1(n) { return Math.round(n * 10) / 10; }
+
+            // Week date range for issue title (ISO week, Mon–Sun)
+            function weekDateRange(key) {
+              const [yr, wStr] = key.split('-W');
+              const week = parseInt(wStr, 10);
+              // Jan 4 is always in week 1
+              const jan4 = new Date(Date.UTC(parseInt(yr, 10), 0, 4));
+              const monday = new Date(jan4);
+              monday.setUTCDate(jan4.getUTCDate() - ((jan4.getUTCDay() + 6) % 7) + (week - 1) * 7);
+              const sunday = new Date(monday);
+              sunday.setUTCDate(monday.getUTCDate() + 6);
+              const months = ['Jan','Fev','Mar','Abr','Mai','Jun','Jul','Ago','Set','Out','Nov','Dez'];
+              const pad = n => String(n).padStart(2, '0');
+              const startMonth = months[monday.getUTCMonth()];
+              const endMonth   = months[sunday.getUTCMonth()];
+              const monthLabel = startMonth === endMonth ? startMonth : startMonth + '/' + endMonth;
+              return pad(monday.getUTCDate()) + '-' + pad(sunday.getUTCDate()) + '/' + monthLabel;
+            }
+
+            // ── Signal collection ───────────────────────────────────────────
+            const signals = [];
+
+            // 1. Orphan issues: open >14 days with no linked PR
+            const closeRe = /(?:closes?|fixes?|resolves?)\s+#(\d+)/gi;
+            const openIssues = await github.paginate(github.rest.issues.listForRepo, {
+              owner, repo, state: 'open', per_page: 100
+            });
+
+            const recentPRs = await github.paginate(github.rest.pulls.list, {
+              owner, repo, state: 'closed', per_page: 50,
+              sort: 'updated', direction: 'desc'
+            });
+
+            const linkedIssueNums = new Set();
+            for (const pr of recentPRs) {
+              const body = pr.body || '';
+              let m;
+              while ((m = closeRe.exec(body)) !== null) linkedIssueNums.add(parseInt(m[1]));
+              closeRe.lastIndex = 0;
+            }
+
+            const orphans = openIssues.filter(i =>
+              !i.pull_request &&
+              daysSince(i.created_at) > 14 &&
+              !linkedIssueNums.has(i.number)
+            );
+
+            if (orphans.length > 0) {
+              const names = orphans.slice(0, 5).map(i => `#${i.number} "${i.title}"`).join(', ');
+              const extra = orphans.length > 5 ? ` e mais ${orphans.length - 5}` : '';
+              signals.push({
+                level: 'red',
+                emoji: '🔴',
+                title: `**${orphans.length} issue${orphans.length > 1 ? 's abertas' : ' aberta'} há 14+ dias sem PR linkado**`,
+                body: `${names}${extra}\n→ Atribua, planeje ou feche se não for mais relevante.`
+              });
+            } else {
+              signals.push({
+                level: 'green',
+                emoji: '🟢',
+                title: '**Nenhuma issue esquecida**',
+                body: 'Todas as issues abertas têm menos de 14 dias ou têm PR linkado.'
+              });
+            }
+
+            // 2. PR merge time trend: last 10 merged PRs split 5+5
+            const mergedPRs = recentPRs
+              .filter(pr => pr.merged_at)
+              .slice(0, 10);
+
+            if (mergedPRs.length >= 4) {
+              const half = Math.floor(mergedPRs.length / 2);
+              const recent = mergedPRs.slice(0, half);
+              const older  = mergedPRs.slice(half);
+              const avgDays = prs => {
+                const total = prs.reduce((s, pr) =>
+                  s + (new Date(pr.merged_at) - new Date(pr.created_at)) / 864e5, 0);
+                return round1(total / prs.length);
+              };
+              const recentAvg = avgDays(recent);
+              const olderAvg  = avgDays(older);
+              const ratio = recentAvg / olderAvg;
+
+              if (ratio >= 1.5) {
+                signals.push({
+                  level: 'yellow',
+                  emoji: '🟡',
+                  title: `**Tempo de merge aumentou ${round1(ratio)}x esta semana**`,
+                  body: `Últimos ${half} PRs: **${recentAvg} dias** · ${half} anteriores: **${olderAvg} dias**\n→ Algo desacelerou o review. Verifique PRs pendentes de aprovação.`
+                });
+              } else if (ratio <= 0.67) {
+                signals.push({
+                  level: 'green',
+                  emoji: '🟢',
+                  title: `**Tempo de merge melhorou ${round1(1/ratio)}x esta semana**`,
+                  body: `Últimos ${half} PRs: **${recentAvg} dias** · ${half} anteriores: **${olderAvg} dias** ✅`
+                });
+              } else {
+                signals.push({
+                  level: 'neutral',
+                  emoji: '🔵',
+                  title: `**Tempo de merge estável: ${recentAvg} dias** (semana passada: ${olderAvg}d)`,
+                  body: ''
+                });
+              }
+            }
+
+            // 3. Rework rate: commits per PR — single push session = first-shot
+            const weekAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000);
+            const weekMerged = recentPRs.filter(pr => pr.merged_at && new Date(pr.merged_at) > weekAgo);
+
+            if (weekMerged.length > 0) {
+              let firstShots = 0;
+              for (const pr of weekMerged.slice(0, 10)) {
+                try {
+                  const commits = await github.rest.pulls.listCommits({
+                    owner, repo, pull_number: pr.number, per_page: 100
+                  });
+                  const times = commits.data.map(c => new Date(c.commit.committer.date).getTime()).sort();
+                  let sessions = 1;
+                  for (let i = 1; i < times.length; i++) {
+                    if (times[i] - times[i-1] > 10 * 60 * 1000) sessions++;
+                  }
+                  if (sessions === 1) firstShots++;
+                } catch (e) { /* skip if commits not accessible */ }
+              }
+              const total = Math.min(weekMerged.length, 10);
+              const pct = Math.round(firstShots / total * 100);
+
+              // Detect if repo uses an agent label (jules, sweep, codex, etc.)
+              const agentLabels = new Set(['jules', 'sweep', 'codex', 'copilot']);
+              const usesAgent = weekMerged.some(pr =>
+                (pr.labels || []).some(l => agentLabels.has(l.name.toLowerCase()))
+              );
+              const subject = usesAgent ? 'Agent first-shot rate' : 'PRs sem rework';
+              const verb = usesAgent ? 'acertaram de primeira' : 'foram mergeados sem rework';
+
+              if (pct >= 80) {
+                signals.push({
+                  level: 'green',
+                  emoji: '🟢',
+                  title: `**${subject}: ${pct}%**`,
+                  body: `${firstShots} de ${total} PRs ${verb} esta semana. ✅`
+                });
+              } else if (pct < 50) {
+                signals.push({
+                  level: 'yellow',
+                  emoji: '🟡',
+                  title: `**${subject}: ${pct}% — rework alto**`,
+                  body: `Apenas ${firstShots} de ${total} PRs sem commits extras.\n→ Specs incompletas ou mudanças de requisito durante implementação.`
+                });
+              } else {
+                signals.push({
+                  level: 'neutral',
+                  emoji: '🔵',
+                  title: `**${subject}: ${pct}%**`,
+                  body: `${firstShots} de ${total} PRs sem rework commits.`
+                });
+              }
+            }
+
+            // 4. Unlinked PRs: merged without Closes/Fixes #N
+            const unlinkRe = /(?:closes?|fixes?|resolves?)\s+#\d+/i;
+            const unlinked = weekMerged.filter(pr => !unlinkRe.test(pr.body || ''));
+            if (unlinked.length > 0) {
+              const nums = unlinked.map(pr => `#${pr.number}`).join(', ');
+              signals.push({
+                level: 'yellow',
+                emoji: '🔵',
+                title: `**${unlinked.length} PR${unlinked.length > 1 ? 's mergeados' : ' mergeado'} sem link de issue**`,
+                body: `${nums} não ${unlinked.length > 1 ? 'têm' : 'tem'} \`Closes #N\` no body. Difícil rastrear o que resolveram.\n→ Edite o body do PR ou feche as issues relacionadas manualmente.`
+              });
+            }
+
+            // ── Stage Residence Time section (conditional) ──────────────────
+            let stageSection = '';
+            const jsonlPath = `.agentic-pdlc/metrics/raw/${weekKey}.jsonl`;
+            if (fs.existsSync(jsonlPath)) {
+              const records = fs.readFileSync(jsonlPath, 'utf8').trim().split('\n').filter(Boolean).map(JSON.parse);
+              if (records.length > 0) {
+                const STAGES = [
+                  ['stage:exploration',   'Exploration'],
+                  ['stage:brainstorming', 'Brainstorming'],
+                  ['stage:detailing',     'Detailing'],
+                  ['stage:approval',      'Approval'],
+                  ['stage:development',   'Development'],
+                  ['stage:testing',       'Testing'],
+                ];
+                const byStage = {};
+                for (const r of records) {
+                  if (!byStage[r.stage]) byStage[r.stage] = [];
+                  byStage[r.stage].push(r.durationDays);
+                }
+                const avg = arr => arr.reduce((a, b) => a + b, 0) / arr.length;
+
+                let maxStage = null, maxDays = 0;
+                const rows = [];
+                for (const [stage, label] of STAGES) {
+                  const days = byStage[stage];
+                  if (!days) continue;
+                  const a = round1(avg(days));
+                  rows.push(`| **${label}** | ${a}d | ${days.length} |`);
+                  if (a > maxDays) { maxStage = label; maxDays = a; }
+                }
+
+                if (rows.length > 0) {
+                  stageSection = `\n---\n\n### 🔄 Stage Residence Time *(board ativo)*\n\n| Stage | Média | Issues |\n|---|---|---|\n${rows.join('\n')}\n\n> \`${maxStage}\` é o maior gargalo (${maxDays}d avg). Considere quebrar specs ou aumentar cadência de revisão nessa fase.\n`;
+                }
+              }
+            }
+
+            // ── Narrative ───────────────────────────────────────────────────
+            const reds    = signals.filter(s => s.level === 'red').length;
+            const yellows = signals.filter(s => s.level === 'yellow').length;
+
+            let narrative;
+            if (reds >= 2)             narrative = '⚠️ Fluxo sob pressão esta semana. Múltiplos bloqueios identificados. Priorize limpar issues orphans e revisar PRs pendentes antes de iniciar novas features.';
+            else if (reds === 1 && yellows >= 1) narrative = 'Semana mista. Um ponto crítico e sinais de desaceleração. Verifique os itens marcados em 🔴 antes de avançar.';
+            else if (reds === 0 && yellows === 0) narrative = '🟢 Fluxo saudável. Nenhum bloqueio identificado esta semana. Bom momento para avançar em novas features.';
+            else                        narrative = 'Fluxo normal. Alguns ajustes de processo podem melhorar rastreabilidade e velocidade.';
+
+            // ── Build issue body ────────────────────────────────────────────
+            const signalLines = signals.map(s =>
+              `${s.emoji} ${s.title}${s.body ? '\n' + s.body : ''}`
+            ).join('\n\n');
+
+            const nextWeekNum = (() => {
+              const d = new Date(); d.setDate(d.getDate() + 7);
+              const dt = new Date(Date.UTC(d.getFullYear(), d.getMonth(), d.getDate()));
+              dt.setUTCDate(dt.getUTCDate() + 4 - (dt.getUTCDay() || 7));
+              const y = new Date(Date.UTC(dt.getUTCFullYear(), 0, 1));
+              const w = Math.ceil((((dt - y) / 86400000) + 1) / 7);
+              return `${dt.getUTCFullYear()}-W${String(w).padStart(2, '0')}`;
+            })();
+
+            const body = [
+              '> Auto-generated by [agentic-pdlc](https://github.com/rafaeltcosta86/agentic-pdlc). Appears every Sunday.',
+              '',
+              narrative,
+              '',
+              '---',
+              '',
+              '### Sinais desta semana',
+              '',
+              signalLines,
+              stageSection,
+              '---',
+              '*Próximo pulse: ' + nextWeekNum + '*',
+              '',
+              '💬 Este pulse foi útil? [Conta pra gente](https://github.com/rafaeltcosta86/agentic-pdlc/issues/new?template=pulse-feedback.md&title=' + encodeURIComponent('[Pulse] ' + weekKey) + ') — 1 clique, sem formulário.'
+            ].join('\n');
+
+            const dateRange = weekDateRange(weekKey);
+            core.exportVariable('PULSE_TITLE', '📊 Agentic Pulse — ' + weekKey + ' (' + dateRange + ')');
+            core.exportVariable('PULSE_BODY', body);
+            console.log(`Built pulse issue for ${weekKey} — ${signals.length} signals, ${reds} red, ${yellows} yellow`);
+
+      - name: Create Weekly Pulse Issue
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const { owner, repo } = context.repo;
+            const title = process.env.PULSE_TITLE;
+            const body  = process.env.PULSE_BODY;
+            const LABEL = 'metrics:weekly';
+
+            // Ensure label exists
+            try {
+              await github.rest.issues.getLabel({ owner, repo, name: LABEL });
+            } catch (e) {
+              await github.rest.issues.createLabel({
+                owner, repo, name: LABEL,
+                color: '0075ca',
+                description: 'Auto-generated weekly metrics pulse'
+              });
+              console.log(`Created label ${LABEL}`);
+            }
+
+            // Close previous pulse issues
+            const prev = await github.rest.issues.listForRepo({
+              owner, repo, labels: LABEL, state: 'open', per_page: 20
+            });
+            for (const issue of prev.data) {
+              if (issue.title !== title) {
+                await github.rest.issues.update({ owner, repo, issue_number: issue.number, state: 'closed' });
+                console.log(`Closed previous pulse: #${issue.number}`);
+              }
+            }
+
+            // Create new pulse issue
+            const created = await github.rest.issues.create({
+              owner, repo, title, body, labels: [LABEL]
+            });
+            console.log(`✅ Created pulse issue: #${created.data.number} — ${title}`);

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

@@ -0,0 +1,16 @@
+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 }}

package/.agentic-pdlc/templates/.github/workflows/ci.yml

@@ -0,0 +1,40 @@
+name: Sentinel / CI
+
+on:
+  pull_request:
+    branches: [ main ]
+  push:
+    branches: [ main ]
+
+jobs:
+  validate:
+    name: Run tests and linters
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup environment
+        run: echo "Replace this with your language/toolchain setup (e.g., actions/setup-node)"
+        
+      - name: Install dependencies
+        run: echo "Replace this with your package manager install command"
+
+      - name: Run Linters
+        if: ${{ !contains('{{LINT_COMMAND}}', '{{') }}
+        run: |
+          {{LINT_COMMAND}}
+
+      - name: Typecheck
+        if: ${{ !contains('{{TYPECHECK_COMMAND}}', '{{') }}
+        run: |
+          {{TYPECHECK_COMMAND}}
+
+      - name: Build
+        if: ${{ !contains('{{BUILD_COMMAND}}', '{{') }}
+        run: |
+          {{BUILD_COMMAND}}
+
+      - name: Run Tests
+        if: ${{ !contains('{{TEST_COMMAND}}', '{{') }}
+        run: |
+          {{TEST_COMMAND}}

package/.agentic-pdlc/templates/.github/workflows/pdlc-health-check.yml

@@ -0,0 +1,123 @@
+name: PDLC Health Check (Drift Detection)
+
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: '0 8 * * 1' # Every Monday at 8am
+
+env:
+  PROJECT_ID: "{{PROJECT_ID}}"
+  STATUS_FIELD_ID: "{{STATUS_FIELD_ID}}"
+  STATUS_EXPLORATION: "{{ID_EXPLORATION}}"
+  STATUS_BRAINSTORMING: "{{ID_BRAINSTORMING}}"
+  STATUS_DETAILING: "{{ID_DETAILING}}"
+  STATUS_APPROVAL: "{{ID_APPROVAL}}"
+  STATUS_DEVELOPMENT: "{{ID_DEVELOPMENT}}"
+  STATUS_TESTING: "{{ID_TESTING}}"
+  STATUS_CODE_REVIEW_PR: "{{ID_CODE_REVIEW_PR}}"
+  STATUS_PRODUCTION: "{{ID_PRODUCTION}}"
+
+jobs:
+  check-drift:
+    name: Detect Project Board Drift
+    runs-on: ubuntu-latest
+    env:
+      PROJECT_TOKEN: ${{ secrets.PROJECT_TOKEN }}
+    permissions:
+      issues: write
+    steps:
+      - name: Validate Board Configuration
+        if: ${{ env.PROJECT_TOKEN != '' && env.PROJECT_ID != '{{PROJECT_ID}}' }}
+        uses: actions/github-script@v7
+        with:
+          github-token: ${{ env.PROJECT_TOKEN }}
+          script: |
+            const projectId = process.env.PROJECT_ID;
+            const statusFieldId = process.env.STATUS_FIELD_ID;
+            const envVars = {
+              'STATUS_EXPLORATION': process.env.STATUS_EXPLORATION,
+              'STATUS_BRAINSTORMING': process.env.STATUS_BRAINSTORMING,
+              'STATUS_DETAILING': process.env.STATUS_DETAILING,
+              'STATUS_APPROVAL': process.env.STATUS_APPROVAL,
+              'STATUS_DEVELOPMENT': process.env.STATUS_DEVELOPMENT,
+              'STATUS_TESTING': process.env.STATUS_TESTING,
+              'STATUS_CODE_REVIEW_PR': process.env.STATUS_CODE_REVIEW_PR,
+              'STATUS_PRODUCTION': process.env.STATUS_PRODUCTION
+            };
+
+            const query = `
+              query($projectId: ID!) {
+                node(id: $projectId) {
+                  ... on ProjectV2 {
+                    title
+                    fields(first: 20) {
+                      nodes {
+                        ... on ProjectV2SingleSelectField {
+                          id
+                          name
+                          options {
+                            id
+                            name
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            `;
+
+            let result;
+            try {
+              result = await github.graphql(query, { projectId });
+            } catch (error) {
+              console.log("❌ Error fetching project. Verify your PROJECT_ID.");
+              console.log(error);
+              return;
+            }
+
+            const project = result.node;
+            if (!project) {
+              console.log("❌ Project not found.");
+              return;
+            }
+
+            const statusField = project.fields.nodes.find(f => f.id === statusFieldId);
+            if (!statusField) {
+              console.log("❌ Status field not found.");
+              return;
+            }
+
+            const validOptions = statusField.options;
+            const validOptionIds = validOptions.map(o => o.id);
+
+            let hasDrift = false;
+            let missingVars = [];
+
+            for (const [varName, id] of Object.entries(envVars)) {
+              if (id && !id.startsWith('{{') && !validOptionIds.includes(id)) {
+                hasDrift = true;
+                missingVars.push(varName);
+              }
+            }
+
+            if (hasDrift) {
+              console.log("🚨 Drift detected! The following mapped columns no longer exist: " + missingVars.join(", "));
+              
+              let table = "| Column Name | New ID |\n|---|---|\n";
+              validOptions.forEach(opt => {
+                table += `| ${opt.name} | \`${opt.id}\` |\n`;
+              });
+
+              const body = `🚨 **Agentic PDLC Drift Detected**\n\nThe following columns mapped in your \`.github/workflows/project-automation.yml\` no longer exist in your project board:\n\n**${missingVars.join(", ")}**\n\n### How to fix it:\nHere is the list of current columns in your board with their valid IDs. Please update the \`env\` block in your \`.github/workflows/project-automation.yml\` and \`.github/workflows/pdlc-health-check.yml\`.\n\n${table}`;
+
+              await github.rest.issues.create({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                title: '🚨 Agentic PDLC Drift Detected in Project Board',
+                body: body,
+                labels: ['bug']
+              });
+            } else {
+              console.log("✅ No drift detected. Board configuration is healthy.");
+            }

package/.agentic-pdlc/templates/.github/workflows/pdlc-stage-gate.yml

@@ -0,0 +1,51 @@
+name: PDLC Stage Gate
+on:
+  pull_request:
+    types: [opened, synchronize, reopened, labeled, unlabeled]
+
+permissions:
+  pull-requests: read
+  issues: read
+
+jobs:
+  stage-gate:
+    name: PDLC Stage Gate
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check stage:approval
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          set -e
+          REPO="${{ github.repository }}"
+          PR_NUMBER="${{ github.event.pull_request.number }}"
+
+          PR_LABELS=$(gh pr view "$PR_NUMBER" --repo "$REPO" --json labels --jq '[.labels[].name] | join(" ")')
+          if echo "$PR_LABELS" | grep -qw "hotfix"; then
+            echo "✅ Hotfix label — stage gate bypassed."
+            exit 0
+          fi
+
+          PR_BODY=$(gh pr view "$PR_NUMBER" --repo "$REPO" --json body --jq '.body // ""')
+          ISSUE_NUMS=$(echo "$PR_BODY" | grep -oiE '(Closes?|Fixes?|Resolves?)\s+#([0-9]+)' | grep -oE '[0-9]+' || true)
+
+          if [ -z "$ISSUE_NUMS" ]; then
+            echo "❌ No linked issues in PR body."
+            echo "   Add 'Closes #N' to PR body, or add 'hotfix' label to PR for emergencies."
+            exit 1
+          fi
+
+          for NUM in $ISSUE_NUMS; do
+            LABELS=$(gh issue view "$NUM" --repo "$REPO" --json labels --jq '[.labels[].name] | join(" ")' 2>/dev/null || echo "")
+            if echo "$LABELS" | grep -qw "stage:approval" || echo "$LABELS" | grep -qw "spec:approved" || echo "$LABELS" | grep -qw "stage:development"; then
+              echo "✅ Issue #$NUM approved"
+            else
+              STAGE=$(echo "$LABELS" | tr ' ' '\n' | grep "^stage:" | head -1 || echo "none")
+              echo "❌ Issue #$NUM missing approval (current: $STAGE)"
+              echo "   Required: stage:approval OR spec:approved OR stage:development label on the issue."
+              echo "   Emergency bypass: add 'hotfix' label to this PR."
+              exit 1
+            fi
+          done
+
+          echo "✅ All linked issues approved."