@cobusgreyling/loop-init 1.1.0

package/README.md

@@ -0,0 +1,47 @@
+# loop-init
+
+Scaffold loop engineering starters into your project by pattern and tool.
+
+## Install & Run
+
+```bash
+npx @cobusgreyling/loop-init . --pattern daily-triage --tool grok
+npx @cobusgreyling/loop-init . -p pr-babysitter -t claude
+npx @cobusgreyling/loop-init . -p dependency-sweeper --dry-run
+```
+
+See [docs/RELEASE.md](../../docs/RELEASE.md) for npm publish tags. The published package bundles `starters/` and `templates/` from this monorepo.
+
+## Patterns
+
+| Pattern | Default state file |
+|---------|-------------------|
+| `daily-triage` | `STATE.md` |
+| `pr-babysitter` | `pr-babysitter-state.md` |
+| `ci-sweeper` | `ci-sweeper-state.md` |
+| `dependency-sweeper` | `dependency-sweeper-state.md` |
+| `post-merge-cleanup` | `post-merge-state.md` |
+| `changelog-drafter` | `changelog-drafter-state.md` |
+
+L2 patterns (`ci-sweeper`, `dependency-sweeper`) also copy `minimal-fix` and `loop-verifier` templates when missing from the starter.
+
+## Tools
+
+- `grok` (default)
+- `claude`
+- `codex`
+
+Falls back to Grok starter paths when a per-tool variant is not yet available.
+
+## From this repo
+
+```bash
+cd tools/loop-init && npm ci && npm test
+node dist/cli.js /path/to/project --pattern daily-triage --tool grok
+```
+
+Pair with `loop-audit` after scaffolding:
+
+```bash
+npx @cobusgreyling/loop-audit . --suggest
+```

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,296 @@
+#!/usr/bin/env node
+import { cp, mkdir, readFile, writeFile, access } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PACKAGE_ROOT = path.resolve(__dirname, '..');
+const MONOREPO_STARTERS = path.resolve(PACKAGE_ROOT, '../../starters');
+const MONOREPO_TEMPLATES = path.resolve(PACKAGE_ROOT, '../../templates');
+const PATTERN_STARTERS = {
+    'daily-triage': 'minimal-loop',
+    'pr-babysitter': 'pr-babysitter',
+    'ci-sweeper': 'ci-sweeper',
+    'dependency-sweeper': 'dependency-sweeper',
+    'post-merge-cleanup': 'post-merge-cleanup',
+    'changelog-drafter': 'changelog-drafter',
+};
+const TOOL_SUFFIX = {
+    grok: '',
+    claude: '-claude',
+    codex: '-codex',
+};
+const L2_PATTERNS = new Set(['ci-sweeper', 'dependency-sweeper']);
+const PATTERNS_NEEDING_FIX = new Set([
+    'pr-babysitter',
+    'ci-sweeper',
+    'dependency-sweeper',
+    'post-merge-cleanup',
+]);
+const STATE_FILES = {
+    'daily-triage': 'STATE.md',
+    'pr-babysitter': 'pr-babysitter-state.md',
+    'ci-sweeper': 'ci-sweeper-state.md',
+    'dependency-sweeper': 'dependency-sweeper-state.md',
+    'post-merge-cleanup': 'post-merge-state.md',
+    'changelog-drafter': 'changelog-drafter-state.md',
+};
+function parseArgs(argv) {
+    let pattern = 'daily-triage';
+    let tool = 'grok';
+    let target = '.';
+    let dryRun = false;
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === '--pattern' || a === '-p')
+            pattern = argv[++i];
+        else if (a === '--tool' || a === '-t')
+            tool = argv[++i];
+        else if (a === '--dry-run')
+            dryRun = true;
+        else if (a === '--help' || a === '-h')
+            return { help: true, pattern, tool, target, dryRun };
+        else if (!a.startsWith('-'))
+            target = a;
+    }
+    return { help: false, pattern, tool, target, dryRun };
+}
+async function exists(p) {
+    try {
+        await access(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function copyDir(src, dest, dryRun) {
+    if (!(await exists(src)))
+        return false;
+    if (dryRun) {
+        console.log(`  would copy: ${src} → ${dest}`);
+        return true;
+    }
+    await mkdir(path.dirname(dest), { recursive: true });
+    await cp(src, dest, { recursive: true });
+    console.log(`  copied: ${src} → ${dest}`);
+    return true;
+}
+async function resolveBundledOrMonorepo(name) {
+    const bundled = path.join(PACKAGE_ROOT, name);
+    if (await exists(bundled))
+        return bundled;
+    return name === 'starters' ? MONOREPO_STARTERS : MONOREPO_TEMPLATES;
+}
+async function copyTemplateSkill(templatesRoot, templateFile, targetDir, tool, skillName, dryRun) {
+    const src = path.join(templatesRoot, templateFile);
+    const destByTool = {
+        grok: path.join(targetDir, '.grok', 'skills', skillName, 'SKILL.md'),
+        claude: path.join(targetDir, '.claude', 'skills', skillName, 'SKILL.md'),
+        codex: path.join(targetDir, '.codex', 'skills', skillName, 'SKILL.md'),
+    };
+    const dest = destByTool[tool];
+    if (await exists(dest))
+        return;
+    await copyFile(src, dest, dryRun);
+}
+async function copyTemplateVerifier(templatesRoot, targetDir, tool, dryRun) {
+    const verifierPaths = {
+        grok: path.join(targetDir, '.grok', 'skills', 'loop-verifier', 'SKILL.md'),
+        claude: path.join(targetDir, '.claude', 'agents', 'loop-verifier.md'),
+        codex: path.join(targetDir, '.codex', 'agents', 'verifier.toml'),
+    };
+    const dest = verifierPaths[tool];
+    if (await exists(dest))
+        return;
+    if (tool === 'codex') {
+        const src = path.join(templatesRoot, 'SKILL.md.verifier');
+        const body = await readFile(src, 'utf8');
+        const toml = `name = "loop-verifier"\ndescription = "Independent verification agent for loop-produced changes."\n\n[system_prompt]\ncontent = """\n${body}\n"""\n`;
+        if (dryRun) {
+            console.log(`  would write verifier: ${dest}`);
+            return;
+        }
+        await mkdir(path.dirname(dest), { recursive: true });
+        await writeFile(dest, toml);
+        console.log(`  created: ${dest} (from verifier template)`);
+        return;
+    }
+    const src = path.join(templatesRoot, 'SKILL.md.verifier');
+    await copyFile(src, dest, dryRun);
+}
+async function copyL2Templates(pattern, tool, targetDir, templatesRoot, dryRun) {
+    if (!PATTERNS_NEEDING_FIX.has(pattern) && !L2_PATTERNS.has(pattern))
+        return;
+    await copyTemplateSkill(templatesRoot, 'SKILL.md.minimal-fix', targetDir, tool, 'minimal-fix', dryRun);
+    if (L2_PATTERNS.has(pattern) || pattern === 'dependency-sweeper') {
+        await copyTemplateVerifier(templatesRoot, targetDir, tool, dryRun);
+    }
+}
+async function copyFile(src, dest, dryRun) {
+    if (!(await exists(src)))
+        return false;
+    if (dryRun) {
+        console.log(`  would copy: ${src} → ${dest}`);
+        return true;
+    }
+    await mkdir(path.dirname(dest), { recursive: true });
+    await cp(src, dest);
+    console.log(`  copied: ${src} → ${dest}`);
+    return true;
+}
+function firstLoopCommand(pattern, tool) {
+    const cmds = {
+        'daily-triage': {
+            grok: '/loop 1d Run loop-triage. Update STATE.md. No auto-fix in week one.',
+            claude: '/loop 1d $loop-triage — update STATE.md. Report-only week one.',
+            codex: 'Automation daily: $loop-triage → update STATE.md. Report-only.',
+        },
+        'pr-babysitter': {
+            grok: '/loop 10m Run pr-review-triage. Update pr-babysitter-state.md. Worktree + minimal-fix + verifier for allowlisted PRs only. Escalate after 3 attempts.',
+            claude: '/loop 10m $pr-review-triage — update pr-babysitter-state.md. No auto-merge.',
+            codex: 'Automation 10m: pr-review-triage → pr-babysitter-state.md. No auto-merge.',
+        },
+        'ci-sweeper': {
+            grok: '/loop 15m Run ci-triage on failing CI. Update ci-sweeper-state.md. Fix only regressions in worktree. Max 3 attempts.',
+            claude: '/loop 15m $ci-triage — update ci-sweeper-state.md. Max 3 fix attempts.',
+            codex: 'Automation 15m: ci-triage on CI failures. Max 3 attempts.',
+        },
+        'dependency-sweeper': {
+            grok: '/loop 6h Run dependency-triage. Patch-only auto-fix in worktree + verifier. Escalate majors and denylist.',
+            claude: '/loop 6h $dependency-triage — patch-only with verifier. Escalate risky bumps.',
+            codex: 'Automation 6h: dependency-triage. Patch-only with verifier.',
+        },
+        'post-merge-cleanup': {
+            grok: '/loop 1d Run post-merge-scan on recent merges. Update post-merge-state.md. Small fixes only in worktree.',
+            claude: '/loop 1d $post-merge-scan — update post-merge-state.md. Small fixes only.',
+            codex: 'Automation daily: post-merge-scan → post-merge-state.md.',
+        },
+        'changelog-drafter': {
+            grok: '/loop 1d Run changelog-scan on merges since last tag. Produce categorized draft in RELEASE_NOTES_DRAFT.md using draft-release-notes. Update changelog-drafter-state.md. Human review only.',
+            claude: '/loop 1d $changelog-scan + draft-release-notes — write RELEASE_NOTES_DRAFT.md and update state. Human approves before publish.',
+            codex: 'Automation daily: changelog-scan + draft-release-notes → RELEASE_NOTES_DRAFT.md. Human review.',
+        },
+    };
+    return cmds[pattern][tool];
+}
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    if (args.help) {
+        console.log(`loop-init — scaffold loop engineering starters
+
+Usage:
+  loop-init [target-dir] --pattern <name> --tool <grok|claude|codex>
+
+Patterns:
+  daily-triage (default)
+  pr-babysitter
+  ci-sweeper
+  dependency-sweeper
+  post-merge-cleanup
+  changelog-drafter (new low-risk release notes pattern)
+
+Options:
+  -p, --pattern   Pattern to scaffold
+  -t, --tool      Tool target (default: grok)
+  --dry-run       Print actions without copying
+  -h, --help      This help
+
+Examples:
+  npx @cobusgreyling/loop-init . --pattern daily-triage --tool grok
+  npx @cobusgreyling/loop-init . -p pr-babysitter -t claude
+`);
+        process.exit(0);
+    }
+    const { pattern, tool, target, dryRun } = args;
+    const targetDir = path.resolve(target);
+    const baseStarter = PATTERN_STARTERS[pattern];
+    const suffix = TOOL_SUFFIX[tool];
+    const starterName = pattern === 'daily-triage' ? `minimal-loop${suffix}` : baseStarter;
+    const startersRoot = await resolveBundledOrMonorepo('starters');
+    const templatesRoot = await resolveBundledOrMonorepo('templates');
+    const starterRoot = path.join(startersRoot, starterName);
+    if (!(await exists(starterRoot))) {
+        const fallback = path.join(startersRoot, baseStarter);
+        if (!(await exists(fallback))) {
+            console.error(`Starter not found: ${starterRoot}`);
+            process.exit(1);
+        }
+        console.log(`Note: no ${tool} variant for ${pattern} — using ${baseStarter} (Grok paths)`);
+    }
+    const effectiveStarter = (await exists(starterRoot))
+        ? starterRoot
+        : path.join(startersRoot, baseStarter);
+    console.log(`\nloop-init: ${pattern} → ${targetDir} (${tool})${dryRun ? ' [dry-run]' : ''}\n`);
+    const skillRoots = [
+        path.join(effectiveStarter, '.grok', 'skills'),
+        path.join(effectiveStarter, '.claude', 'skills'),
+        path.join(effectiveStarter, '.codex', 'skills'),
+    ];
+    for (const skillsDir of skillRoots) {
+        if (!(await exists(skillsDir)))
+            continue;
+        const toolPrefix = skillsDir.includes('.grok')
+            ? '.grok/skills'
+            : skillsDir.includes('.claude')
+                ? '.claude/skills'
+                : '.codex/skills';
+        const entries = await readDirNames(skillsDir);
+        for (const entry of entries) {
+            await copyDir(path.join(skillsDir, entry), path.join(targetDir, toolPrefix, entry), dryRun);
+        }
+    }
+    const agentFiles = [
+        { src: path.join(effectiveStarter, '.claude', 'agents'), dest: path.join(targetDir, '.claude', 'agents') },
+        { src: path.join(effectiveStarter, '.codex', 'agents'), dest: path.join(targetDir, '.codex', 'agents') },
+    ];
+    for (const { src, dest } of agentFiles) {
+        if (await exists(src)) {
+            const entries = await readDirNames(src);
+            for (const entry of entries) {
+                await copyFile(path.join(src, entry), path.join(dest, entry), dryRun);
+            }
+        }
+    }
+    const stateFile = STATE_FILES[pattern];
+    const stateExample = path.join(effectiveStarter, `${stateFile}.example`);
+    if (await exists(stateExample)) {
+        await copyFile(stateExample, path.join(targetDir, stateFile), dryRun);
+    }
+    else {
+        const alt = path.join(effectiveStarter, 'STATE.md.example');
+        if (await exists(alt)) {
+            await copyFile(alt, path.join(targetDir, stateFile), dryRun);
+        }
+    }
+    const loopMd = path.join(effectiveStarter, 'LOOP.md');
+    if (await exists(loopMd)) {
+        await copyFile(loopMd, path.join(targetDir, 'LOOP.md'), dryRun);
+    }
+    await copyL2Templates(pattern, tool, targetDir, templatesRoot, dryRun);
+    if (!dryRun && !(await exists(path.join(targetDir, 'AGENTS.md')))) {
+        const agentsTemplate = `# AGENTS.md
+
+## Test commands
+npm test
+npm run lint
+
+## Loop conventions
+- Report-only week one (L1) before enabling auto-fix (L2)
+- See LOOP.md for cadence and human gates
+`;
+        await writeFile(path.join(targetDir, 'AGENTS.md'), agentsTemplate);
+        console.log('  created: AGENTS.md (template)');
+    }
+    console.log('\n=== Next steps ===');
+    console.log(`  npx @cobusgreyling/loop-audit ${target === '.' ? '.' : target} --suggest`);
+    console.log(`  First loop command (${tool}):\n  ${firstLoopCommand(pattern, tool)}\n`);
+}
+async function readDirNames(dir) {
+    const { readdir } = await import('node:fs/promises');
+    const entries = await readdir(dir, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory() || e.isFile()).map((e) => e.name);
+}
+main().catch((err) => {
+    console.error('loop-init failed:', err instanceof Error ? err.message : err);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@cobusgreyling/loop-init",
+  "version": "1.1.0",
+  "description": "Scaffold loop engineering starters into your project by pattern and tool.",
+  "type": "module",
+  "bin": {
+    "loop-init": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "starters",
+    "templates",
+    "README.md"
+  ],
+  "scripts": {
+    "bundle": "node scripts/bundle-assets.mjs",
+    "build": "npm run bundle && tsc",
+    "test": "npm run build && node --test test/cli.test.mjs",
+    "prepublishOnly": "npm test",
+    "start": "node dist/cli.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "loop-engineering",
+    "ai-agents",
+    "scaffold",
+    "starter"
+  ],
+  "author": "Cobus Greyling",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cobusgreyling/loop-engineering.git",
+    "directory": "tools/loop-init"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  }
+}

package/starters/README.md

@@ -0,0 +1,33 @@
+# Starters
+
+Clone-and-run scaffolds. Copy into your project — or use `loop-init`:
+
+```bash
+npx @cobusgreyling/loop-init . --pattern daily-triage --tool grok
+npx @cobusgreyling/loop-init . -p pr-babysitter -t claude
+```
+
+## Daily Triage (L1 report-only)
+
+| Starter | Tool | Path |
+|---------|------|------|
+| [minimal-loop](./minimal-loop/) | Grok | `.grok/skills/` |
+| [minimal-loop-claude](./minimal-loop-claude/) | Claude Code | `.claude/skills/` + `.claude/agents/` |
+| [minimal-loop-codex](./minimal-loop-codex/) | Codex | `.codex/skills/` + `.codex/agents/` |
+
+## L2 assisted patterns
+
+| Starter | Pattern | Tools | Readiness |
+|---------|---------|-------|-----------|
+| [pr-babysitter](./pr-babysitter/) | PR Babysitter | Grok, Claude, Codex | L2 assisted |
+| [ci-sweeper](./ci-sweeper/) | CI Sweeper | Grok, Claude, Codex | L2 assisted |
+| [dependency-sweeper](./dependency-sweeper/) | Dependency Sweeper | Grok, Claude, Codex | L2 patch-only |
+| [post-merge-cleanup](./post-merge-cleanup/) | Post-Merge Cleanup | Grok, Claude, Codex | L1 → L2 |
+| [changelog-drafter](./changelog-drafter/) | Changelog Drafter | Grok, Claude, Codex | L1 draft → L2 |
+
+After copying:
+
+```bash
+npx @cobusgreyling/loop-audit .
+npx @cobusgreyling/loop-audit . --suggest
+```

package/starters/changelog-drafter/.claude/agents/verifier.md

@@ -0,0 +1,5 @@
+You are the independent verifier for the Changelog Drafter loop.
+
+Review the draft against the raw scan data. Flag any hallucinated items, missing breaking/security notes, or tone problems.
+
+Output a clear verdict + specific suggested fixes. Default to requiring changes.

package/starters/changelog-drafter/.claude/skills/changelog-scan/SKILL.md

@@ -0,0 +1,11 @@
+---
+name: changelog-scan
+description: Scan recent merges/PRs/commits for release note content. Structured output for drafter.
+user_invocable: true
+---
+
+# Changelog Scan (Claude)
+
+Same contract as the Grok version. Produce the per-item blocks + Scan Summary.
+
+Key rules: cite PR numbers, surface breaking/security explicitly, ignore pure dep and bot noise unless security.

package/starters/changelog-drafter/.claude/skills/draft-release-notes/SKILL.md

@@ -0,0 +1,11 @@
+---
+name: draft-release-notes
+description: Turn changelog-scan output into polished, categorized release notes draft. Propose only.
+user_invocable: true
+---
+
+# Draft Release Notes (Claude)
+
+Follow the exact structure and rules from the Grok `draft-release-notes` skill.
+
+Output a clean `RELEASE_NOTES_DRAFT.md` (or clear section the loop can persist). Always flag breaking + security at top. End with review note for human.

package/starters/changelog-drafter/.codex/agents/verifier.toml

@@ -0,0 +1,12 @@
+name = "changelog-verifier"
+description = "Independent checker for release note drafts produced by the changelog drafter. Accuracy and completeness focused."
+reasoning_effort = "high"
+
+[system_prompt]
+content = """
+You verify release note drafts against the source scan list.
+- No invented changes.
+- Breaking and security items must be prominent and accurate.
+- Output: Verdict (APPROVE / REVISE / ESCALATE) + bullet list of issues or "looks good".
+Default stance: require evidence.
+"""

package/starters/changelog-drafter/.codex/skills/changelog-scan/SKILL.md

@@ -0,0 +1,9 @@
+---
+name: changelog-scan
+description: Scan recent merges and commits since last release for changelog content.
+user_invocable: true
+---
+
+Produce the same structured per-item + summary format as the reference implementation.
+
+Focus on user-facing changes. Explicitly list breaking and security signals.

package/starters/changelog-drafter/.codex/skills/draft-release-notes/SKILL.md

@@ -0,0 +1,9 @@
+---
+name: draft-release-notes
+description: Generate categorized release notes draft from scan data. Human must approve before publish.
+user_invocable: true
+---
+
+Use the standard release notes template (Features / Fixes / Breaking / Security / etc.).
+
+Output clean markdown suitable for CHANGELOG or GitHub release. Include review disclaimer.

package/starters/changelog-drafter/.grok/skills/changelog-scan/SKILL.md

@@ -0,0 +1,53 @@
+---
+name: changelog-scan
+description: >
+  Scan recent merges to main (and noteworthy direct commits) since a given window
+  (last tag or date in state). Extract titles, labels, types, linked issues, and
+  signals for breaking changes or security. Produces structured input for a
+  release notes drafter. Use in changelog-drafter loops.
+user_invocable: true
+---
+
+# Changelog Scan Skill
+
+## Inputs the loop will provide
+- Last release tag or previous run timestamp (from state or git)
+- Current date / "now"
+- Any explicit "since" override
+
+## Output Format (one block per significant item)
+
+```markdown
+### PR #1234 — feat(auth): add magic link login (merged 2026-06-08)
+- Type: feature
+- Labels: enhancement
+- Breaking: no
+- Security: no
+- Linked: #1220
+- Summary (one sentence from PR or commit): Users can now log in via emailed magic links.
+- Files touched (high level): auth/, emails/
+```
+
+Rules for what to include:
+- All merged PRs to main in the window.
+- Direct commits on main that look user-facing (conventional commit feat/fix/perf/security or have linked issues).
+- Ignore pure dependency bumps, internal chores, and bot PRs unless they are security-related (those are handled by dependency-sweeper).
+
+## Additional Signals to Surface
+- Any PR or commit message containing "BREAKING", "breaking change", or `!` conventional commit.
+- Security-related keywords or labels (CVE, vuln, security).
+- Items with "deprecate" or "remove" language.
+
+## Output Summary Section (always at end)
+
+```markdown
+## Scan Summary
+- Total items: N
+- Features: N
+- Fixes: N
+- Breaking: N (list them)
+- Security: N (list them)
+- Recommended next action for loop: draft-release-notes | human review needed first | too many items — split window
+```
+
+Be precise and cite sources (PR numbers / shas). Do not invent details.

package/starters/changelog-drafter/.grok/skills/draft-release-notes/SKILL.md

@@ -0,0 +1,65 @@
+---
+name: draft-release-notes
+description: >
+  Takes a structured list of changes from changelog-scan and produces a clean,
+  categorized, user-facing release notes draft. Follows project voice and
+  conventions. Never publishes — only proposes a draft file or section.
+user_invocable: true
+---
+
+# Draft Release Notes Skill
+
+## Inputs
+- Structured output from `changelog-scan` (the list of items + summary)
+- Previous release version (from state)
+- Target next version (or "unreleased" / "next")
+- Optional: short "Release voice" guidance from AGENTS.md or a project skill (tone, what to highlight, what to omit)
+
+## Output
+Write a ready-to-review draft to `RELEASE_NOTES_DRAFT.md` (or print it clearly so the loop can save it).
+
+Use this structure (adapt section names to what actually exists; omit empty sections):
+
+```markdown
+# Release Notes — vX.Y.Z (unreleased)
+
+## Breaking Changes
+- ...
+
+## Features
+- ...
+
+## Bug Fixes
+- ...
+
+## Performance
+- ...
+
+## Security
+- ...
+
+## Documentation & Examples
+- ...
+
+## Internal / Maintenance (usually omitted from public notes)
+- ...
+
+**Thanks** to @contributor1, @contributor2 for contributions to this release.
+
+**Full changelog**: https://github.com/ORG/REPO/compare/vPREV...HEAD
+```
+
+## Rules
+- Be concise and scannable. One line per item when possible, with link to PR.
+- Use the actual title / one-sentence summary from the scan. Do not embellish or add marketing fluff unless the project voice explicitly wants it.
+- Always call out breaking changes and security items at the top.
+- If a change has a user upgrade step that is obvious from the PR, include a one-sentence "Upgrade note".
+- Never claim a change was made if it was not in the scanned input.
+- At the very end of the draft, include a short "Draft generated by loop — please review for accuracy and tone before publishing."
+
+## When to Escalate Instead of Drafting
+- More than ~40 items in one window → suggest splitting the release or human curation.
+- Any breaking or security item → include prominent callout and recommend human wordsmithing.
+- The scan summary says "human review needed first".
+
+After writing the draft, the loop should update state with the draft location and "pending human review".

package/starters/changelog-drafter/.grok/skills/loop-verifier/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: loop-verifier
+description: >
+  Independent checker for release note drafts. Reviews accuracy against the
+  changelog-scan data, tone, completeness, and flags breaking/security items.
+  Use after draft-release-notes. Never let the drafter verify itself.
+user_invocable: true
+---
+
+# Loop Verifier — Changelog Drafter
+
+You are the checker. Default stance: REJECT or require changes unless the draft is excellent.
+
+## Inputs
+- The raw structured scan output
+- The draft produced by draft-release-notes
+- Target version and previous version
+
+## Checklist
+1. Every item in the draft exists in the scan input (no hallucinations).
+2. Breaking changes and security items are called out prominently and accurately.
+3. No invented features or incorrect attribution.
+4. Tone matches the project (use any "Release voice" guidance provided).
+5. Draft is scannable and not overly long.
+6. Includes proper links and thanks where appropriate.
+
+## Output
+```markdown
+## Draft Verdict: APPROVE | REVISE | ESCALATE_HUMAN
+
+### Evidence
+- Scan coverage: good | missing items (list)
+- Accuracy: pass | issues (list)
+- Tone & structure: good | needs work
+
+### Recommended changes (if any)
+- ...
+```
+
+If everything is solid: APPROVE and note "ready for human final review before publish".