@gcunharodrigues/wrxn 0.8.0 → 0.10.0

package/bin/wrxn.cjs

@@ -4,6 +4,7 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const { execFileSync } = require('child_process');
 
 const { init } = require('../lib/install.cjs');
 const { update } = require('../lib/update.cjs');
@@ -15,6 +16,7 @@ const brain = require('../lib/brain.cjs');
 const statusline = require('../lib/statusline.cjs');
 const { convert } = require('../lib/convert.cjs');
 const { ingest } = require('../lib/ingest.cjs');
+const { flowStatus } = require('../lib/flow-status.cjs');
 
 const PKG_ROOT = path.join(__dirname, '..');
 
@@ -23,6 +25,12 @@ function version() {
   return pkg.version;
 }
 
+// Escape a dynamic fragment before embedding it in a RegExp. Slice ids derive from the prd slug and
+// issue filenames, so an unescaped metachar would otherwise build an invalid pattern (crash / ReDoS).
+function escapeRegExp(s) {
+  return String(s).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
 function parseArgs(argv) {
   const args = { _: [], flags: {} };
   for (let i = 0; i < argv.length; i++) {
@@ -150,6 +158,14 @@ Usage:
                                  aios-intake.md (the deterministic half of the onboard skill;
                                  workspace installs only). Idempotent.
 
+  wrxn flow status <prd> [--root <dir>]
+                                 print the flow-status board for a PRD's issue set. Reads issues
+                                 from .scratch/<prd>/issues/, detects gate artifacts (green commit
+                                 via git log, review-<id>.md, security-<id>.md, walk-findings-<id>.md),
+                                 and prints per-slice gate progress (build/review/sec/qa) plus state
+                                 (done | in-progress | stalled | queued). No separate state store —
+                                 derives from the durable artifacts only.
+
 Profiles: --project (default, the dev pipeline + intelligence + enforcement) |
           --workspace (adds the operator layer: onboard/audit/level-up + intake + decisions log +
           connections registry).`;
@@ -490,6 +506,135 @@ async function main(argv) {
     return 0;
   }
 
+  if (cmd === 'flow') {
+    const sub = args._[1];
+    if (sub === 'status') {
+      const prd = args._[2];
+      if (!prd) {
+        process.stderr.write('wrxn: flow status requires <prd>\n');
+        return 2;
+      }
+      const root = path.resolve(args.flags.root || process.cwd());
+      // S2: prd flows into a filesystem path — keep it a plain dir name contained within
+      // <root>/.scratch/. Reject "..", absolute paths, and anything that resolves outside .scratch/.
+      const scratchRoot = path.join(root, '.scratch');
+      const issuesDir = path.join(scratchRoot, prd, 'issues');
+      if (prd.includes('..') || path.isAbsolute(prd)
+          || !path.resolve(issuesDir).startsWith(path.resolve(scratchRoot) + path.sep)) {
+        process.stderr.write(`wrxn: invalid prd "${prd}" — must be a directory name under .scratch/\n`);
+        return 2;
+      }
+
+      // Read issue files sorted by filename (numeric ordering preserved by filename prefix)
+      let issueFiles;
+      try {
+        issueFiles = fs.readdirSync(issuesDir).filter((f) => f.endsWith('.md')).sort();
+      } catch (err) {
+        process.stderr.write(`wrxn: cannot read issues from ${issuesDir}: ${err.message}\n`);
+        return 2;
+      }
+
+      // Derive the id prefix from the PRD slug (e.g. "flow-redesign" → "flow", "myprd" → "myprd")
+      const prdPrefix = prd.split('-')[0];
+
+      // Parse each issue file: id from filename, title + blockedBy from content
+      const issues = issueFiles.map((f) => {
+        const stem = f.replace(/\.md$/, '');
+        const numMatch = stem.match(/^(\d+)/);
+        const num = numMatch ? numMatch[1] : stem;
+        const id = `${prdPrefix}-${num}`;
+        let title = stem;
+        const blockedBy = [];
+        try {
+          const text = fs.readFileSync(path.join(issuesDir, f), 'utf8');
+          // First heading: # N — Title (em-dash or hyphen)
+          const titleMatch = text.match(/^#\s+\d+\s*[—\-]\s*(.+)/m);
+          if (titleMatch) title = titleMatch[1].trim();
+          // ## Blocked by section — bullet items
+          let inBlocked = false;
+          for (const line of text.split('\n')) {
+            if (/^##\s+/.test(line)) { inBlocked = /^##\s+blocked by/i.test(line); continue; }
+            if (inBlocked) {
+              const m = line.match(/^\s*-\s+(.+)$/);
+              if (m) {
+                const item = m[1].trim();
+                // B1: the "None — can start immediately." sentinel is not a real dependency.
+                if (/^none\b/i.test(item)) continue;
+                // B2: normalize a "02 (desc)." bullet to the canonical id "<prefix>-02" so it can be
+                // resolved against the done set. A bullet that is already an id is kept as-is.
+                const numM = item.match(/^(\d+)/);
+                blockedBy.push(numM ? `${prdPrefix}-${numM[1]}` : item);
+              }
+            }
+          }
+        } catch { /* id still usable without content */ }
+        return { id, title, blockedBy };
+      });
+
+      // git log for greenCommit detection — fail-open (not a git repo is fine)
+      let gitLog = '';
+      try {
+        gitLog = execFileSync('git', ['-C', root, 'log', '--all', '--oneline'], {
+          encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
+        });
+      } catch { /* not a repo, or git unavailable — all build gates stay pending */ }
+
+      // Look for an artifact file in the common locations an executor would write it
+      function findArtifactFile(name) {
+        const candidates = [
+          path.join(root, name),
+          path.join(root, '.scratch', prd, name),
+          path.join(root, '.claude', 'ai', 'output', name),
+        ];
+        for (const c of candidates) {
+          try { if (fs.existsSync(c)) return c; } catch { /* skip */ }
+        }
+        return null;
+      }
+
+      // Build artifact map for flowStatus
+      const artifacts = {};
+      for (const issue of issues) {
+        const { id } = issue;
+        const entry = {};
+        // greenCommit: commit message containing [id] or the bare id word.
+        // S1: escape the id (+ guard construction) so a metachar id can never build an invalid RegExp.
+        const eid = escapeRegExp(id);
+        let re;
+        try { re = new RegExp(`\\[${eid}\\]|\\b${eid}\\b`); } catch { re = null; }
+        const commitLine = re ? gitLog.split('\n').find((l) => re.test(l)) : null;
+        if (commitLine) entry.greenCommit = commitLine.trim().split(/\s+/)[0];
+        // review marker
+        const reviewFile = findArtifactFile(`review-${id}.md`);
+        if (reviewFile) entry.reviewMarker = reviewFile;
+        // security report
+        const secFile = findArtifactFile(`security-${id}.md`);
+        if (secFile) entry.securityReport = secFile;
+        // walk findings (two common naming conventions)
+        const walkFile = findArtifactFile(`walk-findings-${id}.md`) || findArtifactFile(`walk-${id}.md`);
+        if (walkFile) entry.walkFindings = walkFile;
+        artifacts[id] = entry;
+      }
+
+      const board = flowStatus(issues, artifacts);
+
+      // Print readable board: id  build✓ review· sec· qa·  state
+      for (const slice of board) {
+        const g = slice.gates;
+        const cols = [
+          `build${g.build === 'done' ? '✓' : '·'}`,
+          `review${g.review === 'done' ? '✓' : '·'}`,
+          `sec${g.security === 'done' ? '✓' : '·'}`,
+          `qa${g.qa === 'done' ? '✓' : '·'}`,
+        ];
+        process.stdout.write(`${slice.id.padEnd(16)} ${cols.join(' ')}  ${slice.state}\n`);
+      }
+      return 0;
+    }
+    process.stderr.write(`wrxn: unknown flow subcommand "${sub || ''}"\n\n${USAGE}\n`);
+    return 2;
+  }
+
   process.stderr.write(`wrxn: unknown command "${cmd}"\n\n${USAGE}\n`);
   return 2;
 }

package/lib/agent-conformance.cjs

@@ -0,0 +1,92 @@
+'use strict';
+
+// Agent-contract conformance (wrxn-kernel flow-redesign flow-02).
+// A pure transform mirroring lib/executor.cjs: it confirms a native executor subagent definition
+// (.claude/agents/<type>.md) is a faithful THIN WRAPPER of the dispatch contract for its type — it
+// declares least-privilege tools, a model, and an output contract that EQUALS that type's
+// reportSchema (EXECUTORS[type].required). The agent file carries no logic the harness doesn't
+// already define, so validateReport's guarantees still hold by construction.
+//
+// An agent .md declares its output contract in a fenced ```output-contract block in the body — one
+// required report field per line. validateAgentFile accepts EITHER the raw markdown (it parses the
+// frontmatter + that block) OR a pre-parsed { tools, model, outputContract } object, so it is
+// unit-testable without a live LLM.
+
+const { EXECUTORS } = require('./executor.cjs');
+
+/**
+ * Parse an agent .md into { name, tools, model, outputContract }.
+ *   - frontmatter `tools:` → comma-separated least-privilege allowlist
+ *   - frontmatter `model:` → scalar
+ *   - the fenced ```output-contract block → one report field per line
+ * Tolerant: a missing piece yields an empty value rather than throwing.
+ */
+function parseAgentFile(markdown) {
+  const text = String(markdown || '');
+  const fmEnd = text.startsWith('---') ? text.indexOf('\n---', 3) : -1;
+  const fm = fmEnd !== -1 ? text.slice(3, fmEnd) : '';
+
+  const scalar = (key) => {
+    const m = fm.match(new RegExp(`^${key}\\s*:\\s*(.+)$`, 'm'));
+    return m ? m[1].trim().replace(/^["']|["']$/g, '') : '';
+  };
+
+  const toolsRaw = scalar('tools');
+  const tools = toolsRaw
+    ? toolsRaw.replace(/^\[|\]$/g, '').split(',').map((s) => s.trim()).filter(Boolean)
+    : [];
+
+  // The fenced ```output-contract block (info-string `output-contract`), one field per line; a
+  // leading bullet marker is tolerated so the block can read as a list.
+  const block = text.match(/```output-contract[^\n]*\n([\s\S]*?)```/);
+  const outputContract = block
+    ? block[1].split('\n').map((l) => l.replace(/^\s*[-*]\s*/, '').trim()).filter(Boolean)
+    : [];
+
+  return { name: scalar('name'), tools, model: scalar('model'), outputContract };
+}
+
+/** Order-independent set-equality over two string arrays (duplicate-safe). */
+function sameSet(a, b) {
+  const sa = new Set(a);
+  const sb = new Set(b);
+  if (sa.size !== sb.size) return false;
+  for (const x of sa) if (!sb.has(x)) return false;
+  return true;
+}
+
+/**
+ * Validate that an executor agent definition conforms to EXECUTORS[type]:
+ *   - declares a non-empty `tools` allowlist (least-privilege; presence, not a frozen list —
+ *     new MCP tools are valid, per the write-an-agent doctrine),
+ *   - declares a `model`,
+ *   - its declared output contract EQUALS that type's reportSchema (EXECUTORS[type].required),
+ *   - the type is known.
+ * `agentDef` may be the raw agent markdown (string) or a pre-parsed
+ * { tools, model, outputContract } object. Returns { ok, errors } (mirrors validateReport).
+ */
+function validateAgentFile(agentDef, type) {
+  const def = EXECUTORS[type];
+  if (!def) return { ok: false, errors: [`unknown executor type: ${type}`] };
+
+  const parsed = typeof agentDef === 'string' ? parseAgentFile(agentDef) : (agentDef || {});
+  const errors = [];
+
+  const tools = Array.isArray(parsed.tools) ? parsed.tools : [];
+  if (tools.length === 0) errors.push('agent declares no tools (a least-privilege allowlist is required)');
+
+  if (!parsed.model || typeof parsed.model !== 'string' || !parsed.model.trim()) {
+    errors.push('agent declares no model');
+  }
+
+  const declared = Array.isArray(parsed.outputContract) ? parsed.outputContract : [];
+  if (!sameSet(declared, def.required)) {
+    errors.push(
+      `output contract ${JSON.stringify(declared)} does not equal the ${type} reportSchema ${JSON.stringify(def.required)}`
+    );
+  }
+
+  return { ok: errors.length === 0, errors };
+}
+
+module.exports = { validateAgentFile, parseAgentFile };

package/lib/compass-coverage.cjs

@@ -0,0 +1,53 @@
+'use strict';
+
+// compass coverage guard (wrxn-kernel flow-04).
+// compass/SKILL.md carries a static ```buckets``` block routing every installed skill to a flow bucket
+// (dev-pipeline / knowledge / setup-health / meta / cross-session). The runtime live-read in the skill
+// body is the resilience layer; THIS is the drift-guard on the static map — an installed skill missing
+// from every bucket is an orphan, i.e. the map fell behind a newly-added skill.
+//
+// Pure data transforms (no I/O), mirroring lib/executor.cjs: parseBuckets is the tolerant parser, the
+// test reads the real SKILL.md + skills dir around them.
+
+/**
+ * Parse the fenced ```buckets``` block out of compass/SKILL.md into { bucket: [skill, …] }.
+ * Each line is `bucket: a, b, c`. Tolerant: a missing block, blank lines, comment (#) lines, or
+ * lines without a colon are skipped rather than thrown on.
+ */
+function parseBuckets(skillMd) {
+  const text = String(skillMd || '');
+  const m = text.match(/```buckets\s*\n([\s\S]*?)```/);
+  if (!m) return {};
+
+  const buckets = {};
+  for (const line of m[1].split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const idx = trimmed.indexOf(':');
+    if (idx === -1) continue;
+    const bucket = trimmed.slice(0, idx).trim();
+    const skills = trimmed
+      .slice(idx + 1)
+      .split(',')
+      .map((s) => s.trim())
+      .filter(Boolean);
+    if (bucket) buckets[bucket] = skills;
+  }
+  return buckets;
+}
+
+/**
+ * The coverage check: every installed skill must appear in some bucket. Returns { ok, orphans },
+ * where orphans is the list of installed skills absent from every bucket (the static map drifted
+ * behind a newly-added skill). Pure: the caller supplies the installed skill list and parsed buckets.
+ */
+function compassCoverage(installedSkills, buckets) {
+  const routed = new Set();
+  for (const skills of Object.values(buckets || {})) {
+    for (const s of skills || []) routed.add(s);
+  }
+  const orphans = (installedSkills || []).filter((s) => !routed.has(s));
+  return { ok: orphans.length === 0, orphans };
+}
+
+module.exports = { parseBuckets, compassCoverage };

package/lib/flow-status.cjs

@@ -0,0 +1,87 @@
+'use strict';
+
+// Pure flow-status aggregator (wrxn-kernel flow-05).
+// flowStatus(issues, artifacts) reconstructs each slice's gate progress from durable artifacts —
+// no separate mutable state, no I/O, no time-of-day logic. The CLI (bin/wrxn.cjs flow status)
+// wraps this with the actual file reads and git log detection.
+
+// The four pipeline gates in order: build (green commit) → review (marker) → security → qa (walk).
+const GATES = ['build', 'review', 'security', 'qa'];
+
+/**
+ * Map one issue's artifact entry to gate booleans.
+ * A gate is done only when its artifact field is a non-empty truthy string — never a false pass.
+ */
+function gatesFor(artifact) {
+  const a = artifact || {};
+  return {
+    build:    !!(a.greenCommit    && typeof a.greenCommit === 'string'    && a.greenCommit.trim()),
+    review:   !!(a.reviewMarker   && typeof a.reviewMarker === 'string'   && a.reviewMarker.trim()),
+    security: !!(a.securityReport && typeof a.securityReport === 'string' && a.securityReport.trim()),
+    qa:       !!(a.walkFindings   && typeof a.walkFindings === 'string'   && a.walkFindings.trim()),
+  };
+}
+
+/**
+ * Derive one slice's overall state from its gate booleans and whether it still has an
+ * UNRESOLVED blocker (a listed dependency whose own slice is not yet fully done).
+ *
+ * done        — all four gates done (wins over any listed blocker: completion is never masked)
+ * queued      — an unresolved blocker, or no gates done at all
+ * stalled     — build done but review not done (stuck at the first critical handoff, never reviewed)
+ * in-progress — any other partial completion (review done, or build+review but security/qa pending)
+ */
+function sliceState(gates, hasUnresolvedBlocker) {
+  const { build, review, security, qa } = gates;
+  if (build && review && security && qa) return 'done';
+  if (hasUnresolvedBlocker) return 'queued';
+  if (!build && !review && !security && !qa) return 'queued';
+  if (build && !review) return 'stalled';
+  return 'in-progress';
+}
+
+/**
+ * flowStatus(issues, artifacts) → per-issue board array.
+ *
+ * issues    — Array<{ id: string, title?: string, blockedBy?: string[] }>
+ * artifacts — { [id: string]: { greenCommit?, reviewMarker?, securityReport?, walkFindings? } }
+ *
+ * Returns Array<{ id, title, gates: { build, review, security, qa }, state }> where each gate
+ * value is 'done'|'pending' and state is 'done'|'in-progress'|'queued'|'stalled'.
+ */
+function flowStatus(issues, artifacts) {
+  const arts = artifacts || {};
+  const list = issues || [];
+
+  // First pass: each slice's gate booleans + the set of fully-done slice ids (all four gates).
+  const gatesById = new Map();
+  const doneIds = new Set();
+  for (const issue of list) {
+    const g = gatesFor(arts[issue.id]);
+    gatesById.set(issue.id, g);
+    if (g.build && g.review && g.security && g.qa) doneIds.add(issue.id);
+  }
+
+  // Second pass: resolve each slice's state. A blocker is RESOLVED once its own slice is fully done;
+  // a slice is queued only when it still lists an UNRESOLVED blocker (or has no gate progress).
+  return list.map((issue) => {
+    const id = issue.id;
+    const g = gatesById.get(id);
+    const blockedBy = Array.isArray(issue.blockedBy) ? issue.blockedBy : [];
+    const hasUnresolvedBlocker = blockedBy.some((b) => !doneIds.has(b));
+    const state = sliceState(g, hasUnresolvedBlocker);
+    return {
+      id,
+      title: issue.title || '',
+      gates: {
+        build:    g.build    ? 'done' : 'pending',
+        review:   g.review   ? 'done' : 'pending',
+        security: g.security ? 'done' : 'pending',
+        qa:       g.qa       ? 'done' : 'pending',
+      },
+      state,
+    };
+  });
+}
+
+module.exports = { flowStatus, GATES };

package/manifest.json

@@ -8,6 +8,36 @@
     "state"
   ],
   "files": [
+    {
+      "path": ".claude/agents/builder.md",
+      "class": "managed",
+      "profile": "project"
+    },
+    {
+      "path": ".claude/agents/devops.md",
+      "class": "managed",
+      "profile": "project"
+    },
+    {
+      "path": ".claude/agents/qa-walker.md",
+      "class": "managed",
+      "profile": "project"
+    },
+    {
+      "path": ".claude/agents/researcher.md",
+      "class": "managed",
+      "profile": "project"
+    },
+    {
+      "path": ".claude/agents/reviewer.md",
+      "class": "managed",
+      "profile": "project"
+    },
+    {
+      "path": ".claude/agents/security.md",
+      "class": "managed",
+      "profile": "project"
+    },
     {
       "path": ".claude/constitution.local.md",
       "class": "seeded",
@@ -83,6 +113,11 @@
       "class": "managed",
       "profile": "project"
     },
+    {
+      "path": ".claude/skills/compass/SKILL.md",
+      "class": "managed",
+      "profile": "project"
+    },
     {
       "path": ".claude/skills/diagnose/SKILL.md",
       "class": "managed",
@@ -298,11 +333,26 @@
       "class": "managed",
       "profile": "project"
     },
+    {
+      "path": ".claude/skills/resolving-merge-conflicts/SKILL.md",
+      "class": "managed",
+      "profile": "project"
+    },
     {
       "path": ".claude/skills/tdd/SKILL.md",
       "class": "managed",
       "profile": "project"
     },
+    {
+      "path": ".claude/skills/tdd/tests.md",
+      "class": "managed",
+      "profile": "project"
+    },
+    {
+      "path": ".claude/skills/tdd/mocking.md",
+      "class": "managed",
+      "profile": "project"
+    },
     {
       "path": ".claude/skills/tech-search/SKILL.md",
       "class": "managed",
@@ -343,6 +393,11 @@
       "class": "managed",
       "profile": "project"
     },
+    {
+      "path": ".claude/skills/write-a-skill/GLOSSARY.md",
+      "class": "managed",
+      "profile": "project"
+    },
     {
       "path": ".claude/skills/write-an-agent/SKILL.md",
       "class": "managed",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gcunharodrigues/wrxn",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "description": "WRXN Kernel — installable AI operating system. Two profiles (project | workspace), pull-based updates, managed/seeded/state file classes.",
   "bin": {
     "wrxn": "bin/wrxn.cjs"

package/payload/.claude/agents/builder.md

@@ -0,0 +1,58 @@
+---
+name: builder
+description: >
+  AFK build executor for ONE ready-for-agent slice. Reads+follows the tdd skill, builds
+  test-first (red → green → refactor), honors the boundary gates (never pushes), and returns
+  the builder report the dispatch harness validates. Use PROACTIVELY to run the build step of a
+  slice unattended — "dispatch the builder", "build this slice tdd-first", the AFK builder phase.
+tools: Read, Edit, Write, Bash, Grep, Glob, mcp__recon-wrxn__recon_impact, mcp__recon-wrxn__recon_find, mcp__recon-wrxn__recon_explain
+model: opus
+---
+You are the **builder** executor. Your one job: build the single slice named in your spec,
+test-first, and return a validated report. You are a thin wrapper over the dispatch contract —
+you add no behavior the harness does not already define.
+
+## Process
+1. **Read `.claude/skills/tdd/SKILL.md` FIRST, then follow it** — it IS your build loop. Never
+   paraphrase or skip it.
+2. Build the slice test-first: write ONE failing (red) test at the highest seam, watch it fail for
+   the right reason, then write the MINIMUM code to pass (green). Refactor with the suite green. One
+   test → one impl → repeat; no horizontal slices.
+3. Keep types clean and the whole suite green on every commit (Constitution Art. III). Use
+   `recon_impact` before touching an exported symbol to gauge blast radius.
+4. Commit locally with a conventional message referencing the issue id. **Do not push.**
+5. Return the structured report below. If blocked (ambiguous AC, missing dependency), stop and
+   return a `blocked` report instead of guessing.
+
+## Constraints (hard)
+- **Never `git push`** — only the devops executor may. Integration happens downstream.
+- Do **not** edit managed (kernel-owned) files without the managed-confirm token.
+- A review marker (`review-<id>.md`) is required downstream before this work is pushed — do not
+  fabricate it.
+- Stay inside the one slice. No scope creep, no speculative features.
+
+## Output contract
+Your final message IS the return value — return the report object, not a conversational reply.
+Lead with it, drop prose. Your declared output contract equals the builder reportSchema (the fields
+`validateReport` requires for type `builder`):
+
+```output-contract
+issueId
+status
+redTest
+greenCommit
+typesClean
+pushed
+summary
+```
+
+`status` ∈ `completed | blocked`; `pushed` is always `false` (you never push). Example:
+
+```json
+{ "issueId": "flow-02", "status": "completed", "redTest": true, "greenCommit": "abc1234",
+  "typesClean": true, "pushed": false, "summary": "built the validator tdd-first; suite green" }
+```
+
+## Stateless
+You get only your spawn prompt + this file — no main-thread memory, no inherited persona. Everything
+you need is on the page or in the files your spec names. Keep yourself self-sufficient.

package/payload/.claude/agents/devops.md

@@ -0,0 +1,60 @@
+---
+name: devops
+description: >
+  AFK integration executor — the ONLY agent authorized to push. Integrates a reviewed +
+  security-passed + qa-walked track to the trunk: verifies the review marker + a green suite, then
+  passes the push gate via the WRXN_ACTIVE_AGENT dance and pushes. Runs ATTENDED. Use to run the
+  integration/push step — "dispatch devops", "integrate this track", "push the reviewed slice".
+tools: Read, Edit, Write, Bash
+model: sonnet
+---
+You are the **devops** executor — the single integration/push path. Your one job: integrate the
+named, already-reviewed track to the trunk and push it. You are a thin wrapper over the dispatch
+contract — you add no behavior the harness does not already define. You run **attended**.
+
+## Process
+You are the ONLY executor authorized to push (`/code-review` and `/security-review` are global
+slash-skills with no local file; the push is yours). Follow these instructions directly (they ARE
+`EXECUTORS.devops.instructions`):
+1. **Verify the gate inputs exist FIRST:** the review marker `review-<id>.md` AND a green suite.
+   If either is missing, do not push — return a `blocked` report.
+2. Authorize the push by setting `WRXN_ACTIVE_AGENT` to `devops` under the **`env`** key of
+   `.claude/settings.local.json` (an inline, command-scoped `WRXN_ACTIVE_AGENT=devops git push`
+   never reaches the gate hook — the flag must be in settings to be read).
+3. `git push`.
+4. **REMOVE `WRXN_ACTIVE_AGENT` from `.claude/settings.local.json`** — a persistent flag defeats
+   the anti-accidental-push gate. This cleanup is mandatory, even if the push failed. This
+   set → push → unset is the single path through the push gate.
+5. Return the structured report below. A `completed` devops report MUST record `pushed: true`.
+
+## Constraints (hard)
+- The set→push→unset dance is the ONLY sanctioned push path — never leave `WRXN_ACTIVE_AGENT`
+  persisted, and never push without first verifying the review marker + green suite.
+- Do **not** edit managed (kernel-owned) files without the managed-confirm token (the
+  `settings.local.json` env toggle above is the sanctioned exception).
+- Stay inside the one track. Integrate what was reviewed; do not amend the work itself.
+
+## Output contract
+Your final message IS the return value — return the report object, not a conversational reply.
+Lead with it, drop prose. Your declared output contract equals the devops reportSchema (the fields
+`validateReport` requires for type `devops`):
+
+```output-contract
+issueId
+status
+artifact
+pushed
+summary
+```
+
+`status` ∈ `completed | blocked`; `artifact` records the authorized push; `pushed` is `true` on a
+completed integration (you are the one executor that may push). Example:
+
+```json
+{ "issueId": "flow-03", "status": "completed", "artifact": "authorized-push",
+  "pushed": true, "summary": "verified marker + green suite; set/push/unset gate; pushed to trunk" }
+```
+
+## Stateless
+You get only your spawn prompt + this file — no main-thread memory, no inherited persona. Everything
+you need is on the page or in the files your spec names. Keep yourself self-sufficient.