@magnusekdahl/parallix 1.0.3 → 1.0.5

package/README.md

@@ -40,7 +40,7 @@ Each capability below is tied to a use case in [`docs/use-cases.md`](docs/use-ca
 - **Publish work to a Forgejo reviewer surface without making Forgejo your branch authority** *(Confirmed mechanic).* When the review provider is enabled, Parallix syncs the local baseline to a dedicated `review` remote and opens or updates the PR there; if Forgejo is disabled, the branch/worktree flow still runs locally.
 - **Use a repo-local Graphify knowledge graph for smaller codebase context pulls** *(Confirmed mechanic, optional, unproven payoff).* In repositories where the operator has already installed the Graphify skill, the workflow keeps `graphify-out/` isolated per worktree and refreshes it during review/integration, while the installed agent guidance steers codebase questions toward `graphify query` / `path` / `explain` before full reports or raw grep. That should reduce context bloat, but this repo does not currently claim a measured token-usage reduction.
 - **Keep your existing verification gate instead of agent self-reporting** *(UC-5 — Confirmed).* The gate is a configured shell command with a no-op default: declare your existing `make` / `npm` / script command in `workflow.config.json` and it runs verbatim; declare nothing and verification is a documented no-op pass, not an invented gate.
-- **See which agent family actually pays off across every repo one runtime drives** *(UC-6 — Partial).* A single operator-owned `stats.csv` accumulates per-agent telemetry across repositories. Token-cost comparison is complete today only for the families with structured telemetry (codex, claude); two families record honest zeros by design.
+- **See which agent family actually pays off across every repo one runtime drives** *(UC-6 — Partial).* A single operator-owned `stats.csv` accumulates per-agent usage telemetry across repositories. Token-cost comparison is complete today only for the families with structured telemetry (codex, claude, opencode/qwen); vibe/mistral record honest zeros by design.
 
 ## The core workflow
 

package/lib/agents/agents.js

@@ -6,7 +6,7 @@ const { startCodexDraftAgent, resolveCodexCommand } = require('./codex');
 const { startClaudeAgent, resolveClaudeCommand } = require('./claude');
 const { startMistralAgent, resolveMistralCommand } = require('./mistral');
 const { startOpencodeAgent, resolveOpencodeCommand } = require('./opencode');
-const { detectLimitHit } = require('./limit-hit');
+const { detectLimitHit, formatBlockUntil, DEFAULT_FALLBACK_HOURS } = require('./limit-hit');
 const sessions = require('../tools/sessions');
 const storage = require('../core/storage');
 const { resolveAgentModel } = require('../core/product-config');
@@ -820,6 +820,18 @@ async function startAgent(step, opts = {}) {
       });
       tried.add(chosen);
       launched.add(chosen);
+      // Block non-qwen agents on non-limit failures so selectAgent excludes them
+      // on the next retry iteration, and the review-loop fallback path can activate.
+      // qwen (opencode/local AI) is excluded — exit 1 is a temporary local error.
+      if (chosen !== 'qwen') {
+        const blockUntil = formatBlockUntil(new Date(Date.now() + DEFAULT_FALLBACK_HOURS * 60 * 60 * 1000));
+        try {
+          const blockResult = updateAgentBlockFn(chosen, blockUntil);
+          log(fmt.status('INFO', `Wrote blocklist entry for ${fmt.agent(chosen)} -> ${fmt.path(blockResult.path)} (${DEFAULT_FALLBACK_HOURS}h block)`));
+        } catch (err) {
+          log(fmt.status('WARN', `Could not persist blocklist entry for ${fmt.agent(chosen)}: ${err.message}`));
+        }
+      }
       chosen = null;
       continue;
     }

package/lib/agents/opencode-export.js

@@ -1,6 +1,9 @@
 'use strict';
 
 const childProcess = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
 
 /**
  * Capture the complete `opencode export <sessionId>` JSON document.
@@ -15,6 +18,10 @@ const childProcess = require('child_process');
  *   - Fails explicitly (resolves null) when output exceeds `maxBytes` rather
  *     than silently truncating into unparseable JSON.
  *
+ * Uses a temp-file fd for stdout to avoid pipe-buffer data loss that occurs
+ * with large (>100 KB) child-process output.  The child writes directly to
+ * the fd; after exit we read the file back as a string.
+ *
  * Never rejects: any error/timeout/oversize resolves to null so telemetry
  * capture stays best-effort and cannot break the launch.
  *
@@ -44,13 +51,21 @@ function captureOpencodeExport(sessionId, opts = {}) {
 
     let settled = false;
     let timer = null;
-    const chunks = [];
     let size = 0;
+    let tmpFd = null;
+    let tmpPath = null;
 
     const finish = (value) => {
       if (settled) return;
       settled = true;
       if (timer) clearTimeout(timer);
+      // Clean up temp file
+      if (tmpFd !== null) {
+        try { fs.closeSync(tmpFd); } catch (_) { /* already closed */ }
+      }
+      if (tmpPath) {
+        try { fs.unlinkSync(tmpPath); } catch (_) { /* already gone */ }
+      }
       resolve(value);
     };
 
@@ -58,18 +73,33 @@ function captureOpencodeExport(sessionId, opts = {}) {
       try { child.kill('SIGKILL'); } catch (_) { /* already gone */ }
     };
 
+    // Create a temp file for stdout to avoid pipe-buffer truncation
+    let tmpFileError = null;
+    try {
+      tmpPath = path.join(os.tmpdir(), `opencode-export-${process.pid}-${Date.now()}.json`);
+      tmpFd = fs.openSync(tmpPath, 'w');
+    } catch (e) {
+      tmpFileError = e;
+    }
+
     let child;
     try {
       child = spawn('opencode', ['export', sessionId], {
         cwd: worktree,
         env: { ...process.env, ...(env || {}) },
-        stdio: ['ignore', 'pipe', 'ignore'],
+        stdio: ['ignore', tmpFd !== null ? tmpFd : 'pipe', 'pipe'],
       });
     } catch (_) {
       finish(null);
       return;
     }
 
+    if (tmpFileError) {
+      killChild(child);
+      finish(null);
+      return;
+    }
+
     timer = setTimeout(() => {
       // Hung or slow export: kill it and degrade to null. Do not block.
       killChild(child);
@@ -80,29 +110,42 @@ function captureOpencodeExport(sessionId, opts = {}) {
     // ref'd keeps the timeout deterministic under Node's test runner (an unref'd
     // timer can be skipped when the loop is otherwise idle, cancelling the test).
 
-    if (!child || !child.stdout) {
-      finish(null);
-      return;
+    // Consume stderr to prevent pipe-buffer issues with the opencode binary
+    if (child.stderr) {
+      child.stderr.on('data', () => { /* drain stderr */ });
     }
 
-    child.stdout.on('data', (chunk) => {
+    child.on('error', () => finish(null));
+
+    child.on('close', (code) => {
       if (settled) return;
-      size += chunk.length;
+      if (tmpFd === null) {
+        finish(null);
+        return;
+      }
+
+      try {
+        fs.closeSync(tmpFd);
+      } catch (_) { /* already closed */ }
+      tmpFd = null;
+
+      let content;
+      try {
+        content = fs.readFileSync(tmpPath, 'utf8');
+      } catch (_) {
+        finish(null);
+        return;
+      }
+
+      size = Buffer.byteLength(content);
       if (size > maxBytes) {
         // Explicit failure rather than silent truncation: a partial JSON
         // document would parse to null/garbage and fabricate zero telemetry.
-        killChild(child);
         finish(null);
         return;
       }
-      chunks.push(chunk);
-    });
 
-    child.on('error', () => finish(null));
-
-    child.on('close', () => {
-      if (settled) return;
-      finish(Buffer.concat(chunks).toString('utf8'));
+      finish(content);
     });
   });
 }

package/lib/commands/integrate.js

@@ -2,7 +2,7 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const child_process = require('child_process');
-const { git, getCurrentBranch } = require('../core/git');
+const { detectRebaseState, git, getCurrentBranch } = require('../core/git');
 const { resolveTaskFile, getTaskStatus, setTaskStatus, completeTask, getTaskAssignee } = require('../tools/backlog');
 const { toVirtual, toActual } = require('../core/state-map');
 const { getPrStatus, getLatestReviewDecision, syncMerged, readToken, resolveTokenFile, resolveForgejoUser, resolveForgejoHome, isForgejoPath, listOpenPrsForSlug } = require('../tools/forgejo');
@@ -935,6 +935,7 @@ function printIntegrationPreflight(
   {
     readTokenFn = readToken,
     resolveTokenFileFn = resolveTokenFile,
+    detectRebaseStateFn = detectRebaseState,
     getUnresolvedIndexConflictsFn = getUnresolvedIndexConflicts,
     findMissionDocInBranchesFn = findMissionDocInBranches,
     isForgejoReviewEnabledFn = isForgejoReviewEnabled,
@@ -1088,6 +1089,23 @@ function printIntegrationPreflight(
     log(fmt.status('INFO', `Retry with: git -C ${baseWorktree} checkout ${expectedPrimaryBranch}`));
   }
 
+  const rebaseState = detectRebaseStateFn(baseWorktree);
+  if (rebaseState.inProgress) {
+    failures.push('rebase-in-progress');
+    log(fmt.status('FAIL', `Integration checkout rebase: rebase in progress in ${baseWorktree}`));
+    if (rebaseState.rebaseHead) {
+      log(fmt.status('INFO', `Current rebase head: ${rebaseState.rebaseHead}`));
+    }
+    if (rebaseState.unmergedFiles.length > 0) {
+      rebaseState.unmergedFiles.forEach(file => log(fmt.status('INFO', `  - ${file}`)));
+    }
+    log(fmt.status('INFO', 'Finish or abort the existing rebase before retrying:'));
+    log(fmt.status('INFO', `  git -C ${baseWorktree} rebase --continue`));
+    log(fmt.status('INFO', `  git -C ${baseWorktree} rebase --abort`));
+    log(fmt.status('INFO', `  git -C ${baseWorktree} rebase --skip`));
+    log(fmt.status('INFO', `Retry with: px integrate ${context.slug} --dry-run`));
+  }
+
   const indexConflicts = getUnresolvedIndexConflictsFn(baseWorktree);
   if (!indexConflicts.ok) {
     failures.push('main-index-conflict-check');

package/lib/commands/rebase.js

@@ -1,5 +1,5 @@
 const path = require('path');
-const { git, getCurrentBranch } = require('../core/git');
+const { detectRebaseState, git, getCurrentBranch } = require('../core/git');
 const { resolveConflictsForMission } = require('./integrate');
 const { findMissionDir, findMissionArea, inferSlug, resolveWorktree, conventionalWorktreePath, getPrimaryWorktree, getPrimaryBranch, missionBranchName, missionDirForSlug, getMissionYear } = require('../core/mission-utils');
 const { startAgent } = require('../agents/agents');
@@ -28,6 +28,7 @@ async function rebase(args, {
   resolveForgejoUserFn = resolveForgejoUser,
   resolveTaskFileFn = resolveTaskFile,
   getTaskImplementerFn = getTaskImplementer,
+  detectRebaseStateFn = detectRebaseState,
   gitFn = git,
   exitFn = (code) => process.exit(code),
   isForgejoReviewEnabledFn = isForgejoReviewEnabled,
@@ -47,6 +48,24 @@ async function rebase(args, {
   const area = missionDir ? findMissionAreaFn(missionDir) : 'docs';
   const branch = missionBranchName(slug);
 
+  const existingRebase = detectRebaseStateFn(process.cwd());
+  if (existingRebase.inProgress) {
+    fmt.log.fail(`Rebase already in progress for ${fmt.branch(branch)}.`);
+    if (existingRebase.rebaseHead) {
+      fmt.log.info(`Current rebase head: ${existingRebase.rebaseHead}`);
+    }
+    if (existingRebase.unmergedFiles.length > 0) {
+      fmt.log.info('Unmerged files:');
+      existingRebase.unmergedFiles.forEach(file => fmt.log.info(`  - ${file}`));
+    }
+    fmt.log.info('Recovery commands:');
+    fmt.log.info(`  ${fmt.command('git rebase --continue')}`);
+    fmt.log.info(`  ${fmt.command('git rebase --abort')}`);
+    fmt.log.info(`  ${fmt.command('git rebase --skip')}`);
+    exitFn(1);
+    return;
+  }
+
   const performPush = async () => {
     if (!isPush) return;
     if (!isForgejoReviewEnabledFn(process.cwd())) {

package/lib/commands/status.js

@@ -1,4 +1,4 @@
-const { getCurrentBranch, getUncommittedCount, getLastThreeCommits, run } = require('../core/git');
+const { detectRebaseState, getCurrentBranch, getUncommittedCount, getLastThreeCommits, run } = require('../core/git');
 const { findTaskFile, getTaskStatus } = require('../tools/backlog');
 const { findMissionDir, findCheckpoints, getFirstLine, inferSlug, missionBranchPrefix, missionBranchName } = require('../core/mission-utils');
 const { WORKFLOW_AGENT_NAMES, eligibleAgentsForStep, readAgentConfigOrExit, workflowLauncherStatus } = require('../agents/agents');
@@ -77,6 +77,7 @@ function findStaleMissionWorktrees({
       return {
         slug,
         path: entry.path,
+        branch: branchRef,
         taskStatus: taskStatus || 'missing',
         cleanupCommand: taskStatus === 'done'
           ? `scripts/cleanup-mission-worktree.sh ${slug}`
@@ -86,6 +87,19 @@ function findStaleMissionWorktrees({
     .filter(Boolean);
 }
 
+function formatWorktreeBranch(ref) {
+  if (!ref) return '(detached HEAD)';
+  return ref.replace(/^refs\/heads\//, '');
+}
+
+function logRebaseDiagnostics(log, label, rebaseState) {
+  const detachedText = rebaseState.detached ? 'detached HEAD, ' : '';
+  log(`${label}: ${detachedText}${rebaseState.unmergedFiles.length} unmerged file(s)`);
+  rebaseState.unmergedFiles.forEach(file => {
+    log(`  - ${file}`);
+  });
+}
+
 function status(args, options = {}) {
   const exit = options.exit || process.exit;
   const log = options.log || fmt.log.plain;
@@ -104,6 +118,7 @@ function status(args, options = {}) {
   const workflowLauncherStatusFn = options.workflowLauncherStatusFn || workflowLauncherStatus;
   const getLastThreeCommitsFn = options.getLastThreeCommitsFn || getLastThreeCommits;
   const getUncommittedCountFn = options.getUncommittedCountFn || getUncommittedCount;
+  const detectRebaseStateFn = options.detectRebaseStateFn || detectRebaseState;
 
   const explicitSlug = args[0];
   const slug = inferSlugFn(explicitSlug);
@@ -112,6 +127,15 @@ function status(args, options = {}) {
   log(`Branch: ${fmt.branch(getCurrentBranchFn())}`);
   log(`Worktree: ${fmt.path(process.cwd())}`);
 
+  try {
+    const rebaseState = detectRebaseStateFn(process.cwd());
+    if (rebaseState.inProgress && rebaseState.detached) {
+      logRebaseDiagnostics(log, 'Detached HEAD: rebase in progress', rebaseState);
+    }
+  } catch (_) {
+    // Ignore transient worktree/git-state failures in status output.
+  }
+
   if (slug) {
     const taskFile = findTaskFileFn(slug);
     const taskStatus = getTaskStatusFn(taskFile);
@@ -146,6 +170,14 @@ function status(args, options = {}) {
     const staleWorktrees = findStaleMissionWorktreesFn();
     staleWorktrees.forEach(entry => {
       log(`Stale worktree: ${fmt.path(entry.path)} (task: ${entry.taskStatus})`);
+      try {
+        const rebaseState = detectRebaseStateFn(entry.path);
+        if (rebaseState.inProgress) {
+          logRebaseDiagnostics(log, `Rebase in progress on ${formatWorktreeBranch(entry.branch)}`, rebaseState);
+        }
+      } catch (_) {
+        // Ignore stale worktrees that disappear during inspection.
+      }
       log(`  Cleanup: ${fmt.command(entry.cleanupCommand)}`);
     });
   }

package/lib/core/git.js

@@ -50,6 +50,51 @@ function getUncommittedCount(cwd = process.cwd()) {
   return result.stdout.trim().split('\n').length;
 }
 
+function parseUnmergedFiles(output = '') {
+  return Array.from(new Set(
+    output
+      .split('\n')
+      .map(line => line.trim())
+      .filter(Boolean)
+      .map(line => line.split('\t')[1])
+      .filter(Boolean)
+  ));
+}
+
+function detectRebaseState(cwd = process.cwd(), { gitRunner = git, fsModule = require('fs'), pathModule = require('path') } = {}) {
+  const gitDirResult = gitRunner(['-C', cwd, 'rev-parse', '--git-dir']);
+  const resolvedGitDir = gitDirResult.status === 0
+    ? gitDirResult.stdout.trim()
+    : '.git';
+  const gitDir = pathModule.isAbsolute(resolvedGitDir)
+    ? resolvedGitDir
+    : pathModule.join(cwd, resolvedGitDir);
+  const rebaseMergeDir = pathModule.join(gitDir, 'rebase-merge');
+  const rebaseApplyDir = pathModule.join(gitDir, 'rebase-apply');
+  const rebaseDir = fsModule.existsSync(rebaseMergeDir)
+    ? rebaseMergeDir
+    : (fsModule.existsSync(rebaseApplyDir) ? rebaseApplyDir : null);
+
+  const headResult = gitRunner(['-C', cwd, 'symbolic-ref', '--quiet', '--short', 'HEAD']);
+  const detached = headResult.status !== 0;
+
+  const showCurrentResult = gitRunner(['-C', cwd, 'rebase', '--show-current']);
+  const rebaseHead = showCurrentResult.status === 0 ? showCurrentResult.stdout.trim() : '';
+
+  const unmergedResult = gitRunner(['-C', cwd, 'ls-files', '-u']);
+  const unmergedFiles = unmergedResult.status === 0 ? parseUnmergedFiles(unmergedResult.stdout) : [];
+
+  const inProgress = Boolean(rebaseDir || rebaseHead || unmergedFiles.length > 0);
+
+  return {
+    inProgress,
+    rebaseHead,
+    detached,
+    unmergedFiles,
+    rebaseDir
+  };
+}
+
 function getLastCommit() {
   const result = git(['log', '-1', '--format=%H|%ad|%s']);
   const [sha, date, subject] = result.stdout.trim().split('|');
@@ -68,6 +113,7 @@ module.exports = {
   getWorktreeStatus,
   isDirty,
   getUncommittedCount,
+  detectRebaseState,
   getLastCommit,
   getLastThreeCommits
 };

package/lib/review/review-loop.js

@@ -593,10 +593,19 @@ async function startReviewLoop(slug, opts = {}) {
 
   log(fmt.status('INFO', `Selected reviewer: ${reviewer} (${reviewerSource})`));
 
-  // Build the canonical ReviewState instance — either from persisted state or fresh
-  const state = persisted && persisted.reviewer === reviewer && persisted.implementer === implementer
-    ? ReviewState.from(slug, persisted)
-    : new ReviewState(slug, { reviewer, implementer });
+  // Build the canonical ReviewState instance. When persisted state exists we
+  // resume from it — preserving round, startedAt, phase, disposition, retry
+  // counts, and metadata — and only overwrite the identities with the ones
+  // selected for this launch (which may differ after a reviewer/implementer
+  // fallback). Constructing fresh would silently reset all persisted progress.
+  let state;
+  if (persisted) {
+    state = ReviewState.from(slug, persisted);
+    state.reviewer = reviewer;
+    state.implementer = implementer;
+  } else {
+    state = new ReviewState(slug, { reviewer, implementer });
+  }
   persistNormalizedPhaseRepair(slug, state, worktree, { log, writeReviewStateFn });
 
   if (persisted && state.round > 1 && !dryRun) {

package/lib/review/review.js

@@ -70,6 +70,7 @@ module.exports.consumeReviewerArtifacts = consumeReviewerArtifacts;
 module.exports.consumeImplementerArtifacts = consumeImplementerArtifacts;
 
 // From review-loop
+module.exports.recordStageStatsSafe = recordStageStatsSafe;
 module.exports.maybeUpdateGraphifyBeforeReview = maybeUpdateGraphifyBeforeReview;
 module.exports.commitSafeMissionArtifacts = commitSafeMissionArtifacts;
 module.exports.rebaseBeforeReviewRound = rebaseBeforeReviewRound;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magnusekdahl/parallix",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "AI mission workflow toolkit with a px CLI — local-first, human-in-the-loop multi-agent development",
   "license": "AGPL-3.0-or-later",
   "private": false,

package/prompts/draft.md

@@ -1,10 +1,22 @@
-Mode: draft. No execution.
+Mode: draft. Do not implement the mission — produce the mission contract document only.
 Mission slug: {{slug}}
 Mission path: {{missionPath}}
 Backlog task: {{taskPath}}
 
 The harness has already created the mission branch, worktree, scaffolded `{{missionPath}}`, and ensured the backlog task exists. Your job is to read the user's intent from `{{taskPath}}` and fill `{{missionPath}}` with a real mission contract.
 
+Allowed actions:
+- read files (backlog task, MISSION.md scaffold, graphify index if present)
+- write/edit files (MISSION.md, backlog task labels)
+- run graphify queries and updates
+- run `{{verifyCmd}}` to verify the draft
+
+Forbidden actions:
+- implement any feature or fix described in the mission
+- modify source code outside MISSION.md and the backlog task file
+- run tests beyond the single `{{verifyCmd}}` gate
+- start a review, execute, or integrate phase
+
 Drafting requirements:
 - fill every scaffolded section in `{{missionPath}}` with concrete, non-generic content (no placeholders, no "TBD")
 - include a Goal, Why now, Scope, Out of scope, Success criteria, Risks/assumptions, Checkpoints, Gates, Restricted areas, and Stop rules

package/prompts/review-verbose.md

@@ -16,5 +16,21 @@ Requirements:
 - write the formal review message to `{{artifactDir}}/{{slug}}-review-outcome.md`
 - write the formal review verdict (`approve` or `request-changes`) to `{{artifactDir}}/{{slug}}-review-verdict.txt`; `comment` is not a valid outcome — if you have findings but the criteria pass, use `request-changes`
 - do not post to Forgejo directly; `px` will consume the artifact files, publish them, and advance review state
-- do not edit repo files
 - stop once the artifact files are written
+
+Separation of duties — you are the reviewer, not the implementer. Stay in review-only mode:
+
+You MUST NOT:
+- edit, create, or delete any repo source, config, test, or doc file to fix a problem — report it as a finding instead of touching the file
+- fix bugs, refactor, complete unfinished work, or otherwise "improve" the diff under review; reviewing is not implementing
+- run branch-history operations: no rebase, squash, amend, `git reset`, force-push, or branch deletion
+- run merge or PR operations: no merge, push, opening/closing/merging PRs, or posting to Forgejo directly
+- mutate workflow state: do not write or edit checkpoint documents, mission artifacts, act-on-review files, or any review-loop/review-state files
+
+You MUST:
+- review the full mission diff, confirm the final checkpoint's goal-check evidence, and write the findings, outcome, and verdict artifacts
+- report any inconsistency (workflow state, prompts, PR history) as a finding rather than resolving it yourself
+
+You MAY (these writes are the sole exceptions to "no repo edits"):
+- write to the artifact directory `{{artifactDir}}` (findings, outcome, verdict)
+- create temporary diagnostic files under `/tmp`

package/prompts/review.md

@@ -1,17 +1,104 @@
-Mode: review. No code changes, no repo-state edits.
+<<<<<<< Updated upstream
+Mode: review. No code changes, commits, repo-state edits, or implementer behavior.
+=======
+Mode: review. No code changes, , commits, repo-state edits, or implementer behavior.
+>>>>>>> Stashed changes
 Mission: {{missionPath}}
 Attempt: {{attempt}}. Focus: {{focus}}.
-
 Entrypoint: {{review_entrypoint}}
 
+Load before reviewing:
+- `AGENTS.md`
+- locked mission at `{{missionPath}}`
+- final checkpoint document, if present
+- diff: `git diff {{primaryBranch}}..HEAD`
+
 Minimum loop contract:
 - Load the locked mission at `{{missionPath}}` and `AGENTS.md` before reviewing.
 - Run `px review {{slug}} --verify`.
-- Review the diff with `git diff {{primaryBranch}}..HEAD`. Do a detailed review, since agents tend to miss stuff and just check off boxes in the checkpoints, which is not the intent here.
+- Review as an independent senior engineer. Approve only if the mission is satisfied, verification is credible for the risk level, and the diff is safe to integrate.
+- Request changes for actionable issues introduced or materially worsened by this mission.
 - Confirm the final checkpoint document in the mission directory contains a Goal Check table citing real evidence (file:line, test names).
+Check:
+- mission scope and acceptance criteria
+- final checkpoint claims vs actual diff
+- correctness and regressions
+- tests / gates / verification evidence
+- security and unsafe operations
+- integration with existing code, config, APIs, schemas, docs, or workflows
+- maintainability issues that materially affect future work
+
 - Write findings to `{{artifactDir}}/{{slug}}-review-findings.md`.
 - Write the formal outcome to `{{artifactDir}}/{{slug}}-review-outcome.md` and the legacy verdict (`approve` | `request-changes`) to `{{artifactDir}}/{{slug}}-review-verdict.txt`. `comment` is not a valid outcome: if you have findings but the criteria pass, use `request-changes`.
-- Do not post to Forgejo directly; `px review {{slug}} --start` or `--submit` publishes the artifacts.
-- Do not edit repo files; do not switch into implementer behavior.
-- If workflow state, prompts, or PR history are inconsistent, report that inconsistency as a finding rather than fixing it.
-- Graphify-first: before reviewing, check if `graphify-out/graph.json` exists. If it does, run `graphify query "review {{slug}} for correctness and completeness"` to get a graph-based view of the mission scope before examining the diff.
+- Do not call px directly, the workflow will do that for you
+<<<<<<< Updated upstream
+- Do not post to Forgejo directly; `px` will consume the artifact files, publish them, and advance review state
+
+Separation of duties — you are the reviewer, not the implementer. Stay in review-only mode:
+
+You MUST NOT:
+- Edit, create, or delete any repo source, config, test, or doc file to fix a problem — report it as a finding instead of touching the file
+- Fix bugs, refactor, complete unfinished work, or otherwise "improve" the diff under review; reviewing is not implementing
+- Run branch-history operations: no rebase, squash, amend, `git reset`, force-push, or branch deletion
+- Run merge or PR operations: no merge, push, opening/closing/merging PRs, or posting to Forgejo directly
+- Mutate workflow state: do not write or edit checkpoint documents, mission artifacts, act-on-review files, or any review-loop/review-state files
+
+You MAY (these writes are the sole exceptions to "no repo edits"):
+- Write to the artifact directory `{{artifactDir}}` (findings, outcome, verdict)
+- Create temporary diagnostic files under `/tmp`.
+=======
+
+
+Do not report:
+- unrelated pre-existing issues
+- speculative risks
+- style preferences
+- alternative designs that are merely different
+- improvements outside mission scope
+
+Findings must cite specific files/lines where possible and explain impact plus suggested fix.
+
+Write:
+
+1. `{{artifactDir}}/{{slug}}-review-findings.md`
+
+Include either:
+
+- actionable findings with file references, impact, and suggested fix
+
+or:
+
+- `No actionable findings`
+- explicit evidence checked:
+  - mission reviewed
+  - diff reviewed
+  - final checkpoint reviewed or not present
+  - `px review {{slug}} --verify` result or limitation
+  - main changed areas inspected
+
+2. `{{artifactDir}}/{{slug}}-review-outcome.md`
+
+Include:
+
+- verdict: `approve` or `request-changes`
+- short rationale
+- required changes, or `None`
+- verification result or limitation
+- non-blocking notes, if any
+
+3. `{{artifactDir}}/{{slug}}-review-verdict.txt`
+
+Write exactly one word:
+
+`approve`
+
+or
+
+`request-changes`
+
+Rules:
+- `comment` is not valid.
+- If there are actionable findings that should be fixed before integration, verdict is `request-changes`.
+- If workflow state, prompt state, PR history, checkpoint evidence, or artifacts are inconsistent, report the inconsistency as a finding instead of fixing it.
+- Do not post to Forgejo directly; Parallix publishes the artifacts.
+>>>>>>> Stashed changes