@cobusgreyling/loop-init 1.2.2 → 1.3.1

package/README.md

@@ -8,6 +8,7 @@ Scaffold loop engineering starters into your project by pattern and tool.
 
 ```bash
 npx @cobusgreyling/loop-init . --pattern daily-triage --tool grok
+npx @cobusgreyling/loop-init . --pattern daily-triage --tool opencode
 npx @cobusgreyling/loop-init . -p pr-babysitter -t claude
 npx @cobusgreyling/loop-init . -p dependency-sweeper --dry-run
 ```
@@ -41,6 +42,7 @@ Every scaffold also creates:
 - `grok` (default)
 - `claude`
 - `codex`
+- `opencode` — daily-triage ships `minimal-loop-opencode` (`skills/`, `AGENTS.md`, `opencode.json`)
 
 Falls back to Grok starter paths when a per-tool variant is not yet available.
 

package/dist/cli.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { spawn } from 'node:child_process';
 import { cp, mkdir, readFile, writeFile, access } from 'node:fs/promises';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -19,6 +20,7 @@ const TOOL_SUFFIX = {
     grok: '',
     claude: '-claude',
     codex: '-codex',
+    opencode: '-opencode',
 };
 const L2_PATTERNS = new Set(['ci-sweeper', 'dependency-sweeper']);
 const PATTERNS_NEEDING_FIX = new Set([
@@ -99,6 +101,7 @@ async function copyTemplateSkill(templatesRoot, templateFile, targetDir, tool, s
         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'),
+        opencode: path.join(targetDir, 'skills', skillName, 'SKILL.md'),
     };
     const dest = destByTool[tool];
     if (await exists(dest))
@@ -110,6 +113,7 @@ async function copyTemplateVerifier(templatesRoot, targetDir, tool, dryRun) {
         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'),
+        opencode: path.join(targetDir, 'skills', 'loop-verifier', 'SKILL.md'),
     };
     const dest = verifierPaths[tool];
     if (await exists(dest))
@@ -194,6 +198,14 @@ async function scaffoldObservability(pattern, tool, targetDir, templatesRoot, dr
     }
     await copyTemplateSkill(templatesRoot, 'SKILL.md.loop-budget', targetDir, tool, 'loop-budget', dryRun);
 }
+async function scaffoldConstraints(targetDir, templatesRoot, tool, dryRun) {
+    const constraintsPath = path.join(targetDir, 'loop-constraints.md');
+    const constraintsTemplate = path.join(templatesRoot, 'loop-constraints.md');
+    if (!(await exists(constraintsPath)) && (await exists(constraintsTemplate))) {
+        await copyFile(constraintsTemplate, constraintsPath, dryRun);
+    }
+    await copyTemplateSkill(templatesRoot, 'SKILL.md.loop-constraints', targetDir, tool, 'loop-constraints', dryRun);
+}
 async function copyFile(src, dest, dryRun) {
     if (!(await exists(src)))
         return false;
@@ -206,53 +218,112 @@ async function copyFile(src, dest, dryRun) {
     console.log(`  copied: ${src} → ${dest}`);
     return true;
 }
+const OPENCODE_RUN = 'opencode run';
 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.',
+            opencode: `${OPENCODE_RUN} "Run loop-triage. Read STATE.md first. Update High Priority and Watch List. No auto-fix in week one." --agent loop-triage`,
         },
         '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.',
+            opencode: `${OPENCODE_RUN} "Run PR babysitter triage. Read pr-babysitter-state.md first. Report only — no code edits." --title "PR babysitter"`,
         },
         '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.',
+            opencode: `${OPENCODE_RUN} "Run ci-triage on failing CI. Update ci-sweeper-state.md. Report only in week one."`,
         },
         '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.',
+            opencode: `${OPENCODE_RUN} "Run dependency-triage. Update dependency-sweeper-state.md. Report only — escalate majors."`,
         },
         '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.',
+            opencode: `${OPENCODE_RUN} "Run post-merge-scan. Update post-merge-state.md. Report only in week one."`,
         },
         '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.',
+            opencode: `${OPENCODE_RUN} "Run changelog-scan. Draft RELEASE_NOTES_DRAFT.md. Human review only — no publish."`,
         },
         'issue-triage': {
             grok: '/loop 2h Run issue-triage. Update issue-triage-state.md. Propose labels and priority only. No auto-apply. Human reviews the needs-human slice.',
             claude: '/loop 2h $issue-triage — update issue-triage-state.md. Suggest labels on allowlisted areas only. Report mode week one.',
             codex: 'Automation 2h: issue-triage → issue-triage-state.md. Propose only.',
+            opencode: `${OPENCODE_RUN} "Run issue-triage. Update issue-triage-state.md. Propose labels only — no auto-apply."`,
         },
     };
     return cmds[pattern][tool];
 }
+async function resolveAuditCli() {
+    const monorepo = path.resolve(PACKAGE_ROOT, '../loop-audit/dist/cli.js');
+    if (await exists(monorepo))
+        return monorepo;
+    try {
+        const { createRequire } = await import('node:module');
+        const require = createRequire(import.meta.url);
+        const pkg = require.resolve('@cobusgreyling/loop-audit/package.json');
+        return path.join(path.dirname(pkg), 'dist/cli.js');
+    }
+    catch {
+        return null;
+    }
+}
+async function runAuditJson(cli, targetDir) {
+    return new Promise((resolve, reject) => {
+        const child = spawn('node', [cli, targetDir, '--json'], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        child.stdout.on('data', (chunk) => {
+            stdout += chunk.toString();
+        });
+        child.on('error', reject);
+        child.on('close', () => {
+            if (stdout.trim())
+                resolve(stdout);
+            else
+                reject(new Error('loop-audit produced no output'));
+        });
+    });
+}
+async function runAuditSummary(targetDir) {
+    const cli = await resolveAuditCli();
+    if (!cli)
+        return null;
+    try {
+        const stdout = await runAuditJson(cli, targetDir);
+        return JSON.parse(stdout);
+    }
+    catch {
+        return null;
+    }
+}
+function formatScoreBar(score, width = 20) {
+    const filled = Math.max(0, Math.min(width, Math.round((score / 100) * width)));
+    return `${'█'.repeat(filled)}${'░'.repeat(width - filled)}  ${score}/100`;
+}
+function auditTargetArg(target, targetDir) {
+    return target === '.' ? '.' : targetDir;
+}
 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>
+  loop-init [target-dir] --pattern <name> --tool <grok|claude|codex|opencode>
 
 Patterns:
   daily-triage (default)
@@ -272,6 +343,7 @@ Options:
 Examples:
   npx @cobusgreyling/loop-init . --pattern daily-triage --tool grok
   npx @cobusgreyling/loop-init . -p pr-babysitter -t claude
+  npx @cobusgreyling/loop-init . -p daily-triage -t opencode
 `);
         process.exit(0);
     }
@@ -305,33 +377,52 @@ Examples:
         ? 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);
+    if (tool === 'opencode') {
+        const skillsDir = path.join(effectiveStarter, 'skills');
+        if (await exists(skillsDir)) {
+            const entries = await readDirNames(skillsDir);
+            for (const entry of entries) {
+                await copyDir(path.join(skillsDir, entry), path.join(targetDir, 'skills', entry), dryRun);
+            }
+        }
+        const agentsMd = path.join(effectiveStarter, 'AGENTS.md');
+        if (await exists(agentsMd)) {
+            await copyFile(agentsMd, path.join(targetDir, 'AGENTS.md'), dryRun);
+        }
+        const opencodeJson = path.join(effectiveStarter, 'opencode.json.example');
+        if (await exists(opencodeJson)) {
+            await copyFile(opencodeJson, path.join(targetDir, 'opencode.json'), 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);
+    else {
+        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 copyFile(path.join(src, entry), path.join(dest, entry), dryRun);
+                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);
+                }
             }
         }
     }
@@ -352,7 +443,8 @@ Examples:
     }
     await copyL2Templates(pattern, tool, targetDir, templatesRoot, dryRun);
     await scaffoldObservability(pattern, tool, targetDir, templatesRoot, dryRun);
-    if (!dryRun && !(await exists(path.join(targetDir, 'AGENTS.md')))) {
+    await scaffoldConstraints(targetDir, templatesRoot, tool, dryRun);
+    if (tool !== 'opencode' && !dryRun && !(await exists(path.join(targetDir, 'AGENTS.md')))) {
         const agentsTemplate = `# AGENTS.md
 
 ## Test commands
@@ -366,10 +458,29 @@ npm run lint
         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(`  npx @cobusgreyling/loop-cost --pattern ${pattern}`);
-    console.log(`  First loop command (${tool}):\n  ${firstLoopCommand(pattern, tool)}\n`);
+    const auditArg = auditTargetArg(target, targetDir);
+    if (!dryRun) {
+        const audit = await runAuditSummary(targetDir);
+        if (audit) {
+            console.log('');
+            console.log(`✓ Loop Ready: ${audit.score}/100 (${audit.level})`);
+            console.log(`  ${formatScoreBar(audit.score)}`);
+            console.log(`  ${audit.assessment}`);
+            console.log('');
+            console.log('Paste badge in README:');
+            console.log(`  npx @cobusgreyling/loop-audit ${auditArg} --badge`);
+        }
+        else {
+            console.log('\n=== Loop Ready score ===');
+            console.log(`  npx @cobusgreyling/loop-audit ${auditArg} --suggest`);
+        }
+    }
+    console.log('');
+    console.log(`First loop (${tool}):`);
+    console.log(`  ${firstLoopCommand(pattern, tool)}`);
+    console.log('');
+    console.log(`Estimate cost: npx @cobusgreyling/loop-cost --pattern ${pattern} --level L1`);
+    console.log('');
 }
 async function readDirNames(dir) {
     const { readdir } = await import('node:fs/promises');

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@cobusgreyling/loop-init",
-  "version": "1.2.2",
-  "description": "Scaffold loop engineering patterns and starters into any project. Supports Grok, Claude Code, Codex and more. npx @cobusgreyling/loop-init . --pattern daily-triage --tool grok",
+  "version": "1.3.1",
+  "description": "Scaffold loop engineering patterns and starters into any project. Supports Grok, Claude Code, Codex, Opencode and more. npx @cobusgreyling/loop-init . --pattern daily-triage --tool opencode",
   "type": "module",
   "bin": {
     "loop-init": "./dist/cli.js"
@@ -31,6 +31,7 @@
     "claude-code",
     "grok",
     "codex",
+    "opencode",
     "github-actions",
     "patterns"
   ],
@@ -48,6 +49,9 @@
   "publishConfig": {
     "access": "public"
   },
+  "dependencies": {
+    "@cobusgreyling/loop-audit": "^1.5.0"
+  },
   "devDependencies": {
     "@types/node": "^26.0.0",
     "typescript": "^6.0.3"

package/starters/README.md

@@ -14,6 +14,7 @@ npx @cobusgreyling/loop-init . -p pr-babysitter -t claude
 | [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/` |
+| [minimal-loop-opencode](./minimal-loop-opencode/) | Opencode | `skills/` + `AGENTS.md` |
 
 ## L2 assisted patterns
 
@@ -31,4 +32,4 @@ After copying:
 ```bash
 npx @cobusgreyling/loop-audit .
 npx @cobusgreyling/loop-audit . --suggest
-```
+```

package/starters/changelog-drafter/changelog-drafter-state.md.example

@@ -13,6 +13,13 @@ Last release tag: v2.14.0 (2026-06-01)
 ## Recently Published
 - v2.14.0 — published 2026-06-01 (human reviewed draft)
 
+## Post-Run Critique (from last run)
+- **Missed items**: 0 reported
+- **False positives**: 2 internal chore PRs — tightened bot filter
+- **Grouping issues**: 1 fix in Features — add label check
+- **Retries**: 0
+- **Prompt/policy adjustments**: None needed this run
+
 ## Scan Window Notes
 - Ignore Dependabot / Renovate PRs (handled by dependency-sweeper)
 - Direct commits on main are included if they have conventional type or linked issue

package/starters/minimal-loop/STATE.md.example

@@ -8,5 +8,12 @@ Last run: never
 
 ## Recent Noise (ignored this run)
 
+## Post-Run Critique (from last run)
+- High-noise: dependabot PRs surfaced again — add to ignore list
+- False positives: 1 CI flake (known flaky test)
+- Deprioritize: lint warnings moved to Watch List
+- Friction: triage missed nightly deploy failure (was infra, not code)
+- Adjustment: include infra check status in scan
+
 ---
 Run log: —

package/starters/minimal-loop-opencode/AGENTS.md

@@ -0,0 +1,23 @@
+# AGENTS.md — Opencode Minimal Loop
+
+These rules are loaded by opencode before loop work.
+
+## Loop Mode
+
+- Start in L1 report-only mode.
+- Read `STATE.md` before any triage.
+- Update `STATE.md` after every loop run.
+- Do not edit source code until the human explicitly enables L2.
+
+## Safety
+
+- Never push or merge without human approval.
+- Never edit `.env`, `.env.*`, `auth/`, `payments/`, `secrets/`, or `credentials/`.
+- Use a git worktree for every code-changing attempt.
+- Max 3 fix attempts per item; escalate after that.
+
+## Verification
+
+- For L2+ changes, dispatch a verifier sub-agent after implementation.
+- Run the project's documented tests before proposing a fix.
+- Record test evidence in `STATE.md`.

package/starters/minimal-loop-opencode/LOOP.md

@@ -0,0 +1,33 @@
+# Loop Configuration — Minimal Triage (Opencode)
+
+## Active Loops
+
+| Pattern | Cadence | Status | Command |
+|---------|---------|--------|---------|
+| Daily Triage | 1d | L1 report-only | `opencode run "Run loop-triage" --agent loop-triage` via cron/systemd |
+
+## Human Gates
+
+- No auto-fix until L2 checklist complete.
+- All high-risk paths require human review (see docs/safety.md denylist).
+
+## Worktrees
+
+- Use an explicit `git worktree` and run opencode with `--dir <worktree>` for implementer runs (L2+).
+- One worktree per fix attempt; discard after verifier REJECT.
+
+## Connectors (MCP)
+
+- MCP optional for L1 report-only loops.
+- For L2+: GitHub MCP can read CI/issues; scope connectors to read + comment until trusted.
+
+## Budget
+
+- Max sub-agent spawns per run: 0 (L1).
+- Review STATE.md daily.
+- If token spend hits 80% of daily cap, switch to report-only.
+
+## Links
+
+- Pattern: [daily-triage](../../patterns/daily-triage.md)
+- Checklist: [loop-design-checklist](../../docs/loop-design-checklist.md)

package/starters/minimal-loop-opencode/README.md

@@ -0,0 +1,50 @@
+# Minimal Loop Starter — Opencode
+
+Clone this into your project root to run a **report-only daily triage loop** (L1 readiness) with opencode.
+
+## Quick Start
+
+1. Scaffold (recommended):
+
+   ```bash
+   npx @cobusgreyling/loop-init . --pattern daily-triage --tool opencode
+   ```
+
+   Or copy manually:
+
+   ```bash
+   cp -r starters/minimal-loop-opencode/skills .
+   cp starters/minimal-loop-opencode/AGENTS.md .
+   cp starters/minimal-loop-opencode/LOOP.md .
+   cp starters/minimal-loop-opencode/STATE.md.example STATE.md
+   cp starters/minimal-loop-opencode/opencode.json.example opencode.json
+   ```
+
+2. Customize `STATE.md` project name.
+
+3. Start the loop:
+
+   ```bash
+   opencode run "Run loop-triage. Read STATE.md first. Append high-priority and watch items. Update Last run timestamp. Do not auto-fix anything in week one." --agent loop-triage
+   ```
+
+4. Read `STATE.md` each morning for 1-2 weeks. Tune the triage skill.
+
+5. When triage quality is good, add `minimal-fix` from `templates/SKILL.md.minimal-fix` and enable small auto-wins with a verifier agent in a worktree.
+
+## What's Included
+
+| File | Purpose |
+|------|---------|
+| `STATE.md.example` | State spine template |
+| `skills/loop-triage/SKILL.md` | Triage skill |
+| `AGENTS.md` | Always-on project rules for opencode |
+| `LOOP.md` | Loop config doc for your team |
+| `opencode.json.example` | Example opencode agent definitions |
+
+## Next Steps
+
+- [Loop Design Checklist](../../docs/loop-design-checklist.md)
+- [Daily Triage pattern](../../patterns/daily-triage.md)
+- [Opencode example](../../examples/opencode/daily-triage.md)
+- Run `npx @cobusgreyling/loop-audit .` for readiness score

package/starters/minimal-loop-opencode/STATE.md.example

@@ -0,0 +1,12 @@
+# Loop State — My Project
+
+Last run: never
+
+## High Priority (loop is acting or waiting on human)
+
+## Watch List
+
+## Recent Noise (ignored this run)
+
+---
+Run log: —

package/starters/minimal-loop-opencode/opencode.json.example

@@ -0,0 +1,35 @@
+{
+  "$schema": "https://opencode.ai/config.json",
+  "agent": {
+    "loop-triage": {
+      "name": "loop-triage",
+      "description": "Report-only daily triage loop. Reads STATE.md, updates high-priority items, and does not edit source code in L1 mode.",
+      "mode": "primary",
+      "prompt": "Read AGENTS.md, LOOP.md, STATE.md, and skills/loop-triage/SKILL.md. Run report-only triage. Update STATE.md. Do not edit source code unless the human has explicitly enabled L2.",
+      "permission": {
+        "bash": "ask",
+        "edit": "ask"
+      }
+    },
+    "implementer": {
+      "name": "implementer",
+      "description": "L2 implementer agent for minimal scoped fixes inside an isolated worktree.",
+      "mode": "subagent",
+      "prompt": "Implement only the requested minimal fix. Stay within the supplied worktree, respect AGENTS.md and LOOP.md, run documented tests, and stop for human approval on denylisted paths.",
+      "permission": {
+        "bash": "ask",
+        "edit": "ask"
+      }
+    },
+    "verifier": {
+      "name": "verifier",
+      "description": "Checker agent for L2+ changes. Reviews diffs and test evidence; APPROVE or REJECT only.",
+      "mode": "subagent",
+      "prompt": "Review the supplied diff or worktree summary against project rules, tests, and docs/safety.md. Do not edit files. Respond with APPROVE or REJECT and concise evidence.",
+      "permission": {
+        "bash": "ask",
+        "edit": "deny"
+      }
+    }
+  }
+}

package/starters/minimal-loop-opencode/skills/loop-triage/SKILL.md

@@ -0,0 +1,59 @@
+---
+name: loop-triage
+description: >
+  Triage recent changes, CI failures, issues, and conversations.
+  Produces a concise, actionable findings report suitable for a loop to consume.
+  Writes structured output to a state file or issue tracker.
+user_invocable: true
+---
+
+# Loop Triage Skill
+
+You are an expert engineering triage agent. Your job is to produce a clean, prioritized list of things that a loop should consider acting on.
+
+## Inputs (the loop will provide these)
+
+- Recent CI / test failures (last 24h)
+- Open issues / tickets assigned to the team
+- Recent commits on main (last 24-48h)
+- Any chat threads the loop has visibility into
+- The current state file (what the loop already knows about)
+
+## Output Format
+
+Produce a markdown report with these sections:
+
+### 1. High-Priority Items (act on these)
+
+- Clear, one-line description
+- Why it matters (impact, risk, or customer pain)
+- Suggested next action for the loop (for example, "draft minimal fix in isolated worktree")
+- Rough effort estimate
+
+### 2. Watch Items (monitor, do not act yet)
+
+- Same format but lower urgency
+
+### 3. Noise / Ignore
+
+- Brief list of things the loop looked at and decided were not worth action
+
+### 4. State Updates
+
+- Any facts the loop should remember for the next run (for example, "PR #1234 now has 2 approvals")
+
+## Rules
+
+- Be brutally concise. The loop and the human reading the state will thank you.
+- Only put something in "High-Priority" if a reasonable engineer would want to know about it today.
+- When in doubt, put it in Watch or Noise rather than creating work.
+- Never propose architectural overhauls during triage — this skill is for signal, not invention.
+- Respect the project's existing skills and conventions (they will be provided in context).
+
+## Example Invocation (in an opencode loop)
+
+```bash
+opencode run "Call loop-triage and append high-priority items to STATE.md. Do not edit code."
+```
+
+The triage skill should be the "eyes" of the loop. Keep it focused and honest.

package/templates/SKILL.md.loop-constraints

@@ -0,0 +1,48 @@
+---
+name: loop-constraints
+description: >
+  Read loop-constraints.md at the start of every run and enforce every rule.
+  This skill runs BEFORE triage or any action skill. Constraints are binding.
+user_invocable: true
+---
+
+# Loop Constraints Enforcer
+
+You are the guardrail. Before any other work begins, you MUST:
+
+1. Read `loop-constraints.md` from the project root.
+2. Load every rule into your working memory.
+3. Check if `loop-pause-all` is active → exit immediately.
+4. Apply these rules to EVERY action that follows.
+
+## How to enforce
+
+- Before pushing: re-read the Push & Merge section. If ANY rule blocks it, stop and tell the human.
+- Before editing a file: re-read the Paths section. If the path matches a denylist pattern, escalate.
+- Before proposing a fix: re-read the Code section. Run tests. One fix per run.
+- Before merging: re-read the Push & Merge section. Human must approve.
+
+## Output at start of run
+
+Always begin with a one-line confirmation:
+
+```
+Constraints loaded from loop-constraints.md: N rules active.
+```
+
+If no `loop-constraints.md` exists, say so and proceed with default safety rules from `docs/safety.md`.
+
+## Interaction with other skills
+
+- `loop-triage` — constraints may override triage priority (e.g. "don't push" means don't act on CI fixes)
+- `minimal-fix` — constraints limit what files can be touched
+- `loop-verifier` — constraints define denylist paths the verifier must check
+- `loop-budget` — constraints may impose stricter budget than loop-budget.md
+
+## Default constraints (when no file exists)
+
+If `loop-constraints.md` is absent, enforce these minimums:
+- Never edit `.env`, `.env.*`, `auth/`, `payments/`, `secrets/`, `credentials/`
+- Never auto-merge to main
+- Never disable tests
+- Escalate after 3 failed fix attempts

package/templates/loop-constraints.md

@@ -0,0 +1,31 @@
+# Loop Constraints
+
+> Add rules below with `/constraints <rule>` in your agent.
+> The `loop-constraints` skill reads this file at the start of every run.
+> Constraints here are **binding** — the agent MUST follow them.
+
+## Push & Merge
+- Don't push before telling me
+- Never auto-merge to main without human approval
+- Always create a draft PR first; let me review before marking ready
+
+## Paths
+- Never edit .env, .env.*, auth/, payments/, secrets/, credentials/
+- Never edit infrastructure configs without human approval
+
+## Code
+- Always run tests before proposing a fix
+- Never disable tests to make CI green
+- Never refactor unrelated code — one fix per run
+- Max 3 fix attempts per item; escalate after
+
+## Communication
+- Always tell me what you're about to do before doing it
+- Never close an issue or PR without my approval
+
+## Budget
+- If token spend hits 80% of daily cap, switch to report-only
+- If loop-pause-all is active, exit immediately
+
+---
+<!-- Add your own rules below. Use plain English. The loop reads this verbatim. -->