@magnusekdahl/parallix 1.3.4 → 1.5.126

package/build/migrations/0014-remove-usage-closed.sql

@@ -0,0 +1,33 @@
+-- 0014-remove-usage-closed
+-- Preserve non-empty historical completion markers only for the task-2367
+-- one-off repair boundary, then remove the competing telemetry contract.
+CREATE TABLE legacy_usage_completion_evidence (
+  usage_id INTEGER PRIMARY KEY,
+  repo TEXT NOT NULL,
+  mission TEXT NOT NULL,
+  closed TEXT NOT NULL
+);
+INSERT INTO legacy_usage_completion_evidence (usage_id, repo, mission, closed)
+  SELECT id, repo, mission, closed FROM usage_statistics
+  WHERE closed IS NOT NULL AND trim(closed) <> '';
+
+CREATE TABLE usage_statistics_next (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  date TEXT, repo TEXT NOT NULL DEFAULT '', mission TEXT NOT NULL DEFAULT '',
+  classification TEXT, implementer TEXT, pr_fix_rounds INTEGER, provider TEXT,
+  model TEXT, implementer_agent TEXT, reviewer_agent TEXT, stage TEXT DEFAULT 'default',
+  input_tokens INTEGER, output_tokens INTEGER, cached_tokens INTEGER,
+  context_tokens INTEGER, tool_calls INTEGER, openai_usage_before REAL,
+  openai_usage_after REAL, openai_usage_delta REAL, duration_minutes REAL,
+  cost_usd REAL, actor_key TEXT NOT NULL DEFAULT '', thoughts_tokens INTEGER
+);
+INSERT INTO usage_statistics_next SELECT id, date, repo, mission, classification,
+  implementer, pr_fix_rounds, provider, model, implementer_agent, reviewer_agent,
+  stage, input_tokens, output_tokens, cached_tokens, context_tokens, tool_calls,
+  openai_usage_before, openai_usage_after, openai_usage_delta, duration_minutes,
+  cost_usd, actor_key, thoughts_tokens FROM usage_statistics;
+DROP TABLE usage_statistics;
+ALTER TABLE usage_statistics_next RENAME TO usage_statistics;
+CREATE INDEX idx_usage_statistics_mission ON usage_statistics(repo, mission, stage);
+CREATE INDEX idx_usage_statistics_date ON usage_statistics(date);
+CREATE UNIQUE INDEX idx_usage_statistics_identity ON usage_statistics(repo, mission, stage, actor_key);

package/build/migrations/0015-current-work-latest-per-mission.sql

@@ -0,0 +1,5 @@
+-- 0015-current-work-latest-per-mission
+-- Serves SqliteOperationalHistoryRepository.findLatestByTypePerMission(), the
+-- board's bounded `mission.current-work` read.
+CREATE INDEX IF NOT EXISTS idx_operational_history_current_work_mission_id
+  ON operational_history(event_type, json_extract(event_data, '$.missionId'), id DESC);

package/build/migrations/0016-review-drop-retry-counters.sql

@@ -0,0 +1,21 @@
+-- TASK-2377.04: drop the persisted review-level retry counters.
+--
+-- Migrations 0009 and 0012 added `gate_failure_retry_count` and
+-- `hook_failure_retry_count` to carry the cumulative auto-bounce budgets of
+-- the pre-kernel gate/hook bounces. The review loop now routes every
+-- pre-review bounce through the rebound kernel, whose budget is per local
+-- failure, in-memory, and persists nothing (ADR 0053: the kernel budget is
+-- the only retry state that exists). The two columns are dead weight — a
+-- second source of truth for a budget that no longer steers loop behavior —
+-- and this forward-only migration drops them.
+--
+-- The per-round `mission_review_rounds.reviewer_retry_count` /
+-- `implementer_retry_count` columns (0008) stay: ADR 0053 describes the
+-- retry counters as round columns and historical values round-trip
+-- unchanged.
+--
+-- The pre-review safety commit still records its hook identity for the
+-- in-process rebase; nothing reads these columns after this migration.
+
+ALTER TABLE mission_reviews DROP COLUMN gate_failure_retry_count;
+ALTER TABLE mission_reviews DROP COLUMN hook_failure_retry_count;

package/build/migrations/0017-retire-mission-import-provenance.sql

@@ -0,0 +1,5 @@
+-- Migration: 0017-retire-mission-import-provenance
+-- Description: Remove the retired Mission compatibility import version snapshot.
+-- Authority: operator-local only
+
+DROP TABLE IF EXISTS import_mission_versions;

package/build/migrations/0018-adhoc-mission-counter.sql

@@ -0,0 +1,19 @@
+-- Migration: 0018-adhoc-mission-counter
+-- DB-owned, repository-scoped identity for free-text adhoc intakes (task-2468).
+--
+-- Backlog-backed missions keep their identity in a Backlog task file. Adhoc
+-- missions have no such file in an adhoc-only repository, so their identity is
+-- minted here instead: a monotonic counter owned per repository, allocated
+-- atomically, so `parallix-adhoc-<NNNN>` can never collide with, or be confused
+-- for, Backlog.md task numbering. No content hash in the identity: slug,
+-- mission id, branch, and worktree suffix all derive from this counter.
+--
+-- The counter row is intentionally sparse — only repository identity and the
+-- last allocated number — because the adhoc identity is fully derivable from
+-- it. It carries no status, assignee, or lifecycle column: a second lifecycle
+-- authority must not be reachable by adding columns here.
+
+CREATE TABLE IF NOT EXISTS adhoc_mission_counters (
+  repository_id TEXT PRIMARY KEY,
+  counter INTEGER NOT NULL DEFAULT 0 CHECK (counter >= 0)
+);

package/build/migrations/0019-custom-agent-leases.sql

@@ -0,0 +1,12 @@
+-- Machine-scoped custom-agent admission leases (TASK-2475).
+CREATE TABLE IF NOT EXISTS custom_agent_leases (
+  lease_id TEXT PRIMARY KEY,
+  repository_root TEXT NOT NULL,
+  capacity INTEGER,
+  launcher_pid INTEGER NOT NULL,
+  launcher_start_id TEXT,
+  child_pid INTEGER,
+  child_start_id TEXT,
+  created_at TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS custom_agent_leases_live ON custom_agent_leases(child_pid, launcher_pid);

package/build/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "@magnusekdahl/parallix",
+  "version": "1.5.126",
+  "type": "module"
+}

package/{prompts/act-on-review.md → build/prompts/act-on-review-core.md}

@@ -1,3 +1,4 @@
+# Act-on-review core
 Mode: act-on-review. Branch: {{branch}}.
 Mission: {{missionPath}}
 
@@ -8,15 +9,16 @@ Latest reviewer outcome was: {{review_outcome}}
 Entrypoint: {{act_on_review_entrypoint}}
 
 Minimum loop contract:
+- Before acting on findings, compact the implementation context and reload the locked mission goal and scope; committed checkpoint or gate evidence when present; current review round and disposition; unresolved findings and implementer resolutions; and the exact revision under review. This requirement applies even when `MISSION.md` declares no gates.
 - Load the locked mission at `{{missionPath}}` and `AGENTS.md` before acting.
-- Read the review outcome and findings from `missions/{{slug}}/review-events/` — the latest `reviewer_outcome-*` file has the verdict and `reviewer_findings-*` has the findings. Alternatively, read `missions/{{slug}}/review-state.json` for the current round/phase/disposition.
+- Read the review outcome and findings from `missions/{{slug}}/review-events/` — the latest `reviewer_outcome-*` file has the verdict and `reviewer_findings-*` has the findings.
+- Get the current round, phase, and disposition from `px status {{slug}}`, which reports them on its `Review:` line. That line is projected from the operator database, which is the authority for review-loop state. Do not read `review-state.json` to learn the round or phase; it is a compatibility artifact, not the source of truth, and it may lag the database.
 - For each finding: fix, push back (with a clear reason), or park (record in a tracked follow-up such as a Backlog task).
+- If a finding is a rebasing artifact caused by branch stale-ness rather than this mission's diff, push back with the rationale: `Not a mission change - will be resolved by parallix rebase.`
 - Update the checkpoint document if needed, run the relevant gate, and commit before handoff.
 - Write `{{artifactDir}}/{{slug}}-round-resolution.md` with `fixed_items`, `pushed_back_items`, `parked_items`, and `blocked_reason` (when blocked).
-- Write `{{artifactDir}}/{{slug}}-review-disposition.txt` with one of `CHANGES_MADE|PUSHBACK_ALL|PARKED|BLOCKED`.
+- Write `{{artifactDir}}/{{slug}}-review-disposition.txt` with one of `CHANGES_MADE|PUSHBACK_ALL|PARKED|BLOCKED`. `PUSHBACK_ALL` records your response to every remaining finding and sends the mission back to the active reviewer for the next formal decision; it is not an approval.
 - Do not post to Forgejo directly; the workflow loop consumes the artifacts.
 - In standalone mode (no Forgejo), the review loop reads your artifacts directly — no CLI commands needed.
 
 Safety: If {{review_outcome}} is not approved AND you cannot read the review outcome, DO NOT post PUSHBACK_ALL. Post BLOCKED instead.
-
-Graphify-first: before acting on findings, check if `graphify-out/graph.json` exists. If it does, use `graphify query` and `graphify path` to understand affected code areas before making changes. Run `graphify update .` after modifying code.

package/build/prompts/act-on-review.md

@@ -0,0 +1 @@
+Graphify-first: before acting on findings, check if `graphify-out/graph.json` exists. If it does, use `graphify query` and `graphify path` to understand affected code areas before making changes. Run `graphify update .` after modifying code.

package/{prompts/draft.md → build/prompts/draft-core.md}

@@ -1,3 +1,4 @@
+# Draft core
 Mode: draft. Do not implement the mission — produce the mission contract document only.
 Mission slug: {{slug}}
 Mission path: {{missionPath}}
@@ -25,11 +26,17 @@ Drafting requirements:
 - preserve `{{taskPath}}`: update content as needed but do not delete, rename, or move the file
 - do not edit the backlog `assignee` field; the workflow records ownership itself
 - Refinement Signals section must use net engineering lines (NEL) bucket format (`Predicted NEL bucket: Small (0–80) / Medium (81–235) / Large (235+)`) and must NOT use the old agent-percentage-usage format
+- Every generated `MISSION.md` MUST keep the scaffolded `### Checkpoint Documentation Requirements` block under `## Checkpoints` and fill it with concrete instructions for the implementer.
+- That block must tell the agent to use the exact heading `## Goal Check` and the 3-column table `| Criterion | Evidence | Status |`.
+- That block must lead with durable evidence forms Parallix verifies today: exact test names, ADR references, test file paths, and recognized repo commands/paths such as backticked `npm ...`, `node ...`, `git ...`, `px ...`, or `./...`. It may mention file:line references parenthetically as accepted but discouraged because line numbers rot.
+- That block must make the weak-agent failure mode explicit: raw `stat`/`ls` output or generic prose alone is not enough; pair shell output with one of the accepted references above.
+- Every `## Gates` checklist item must contain only the exact runnable repository command (for example, `- [ ] ./scripts/verify-local.sh all`). Optional Markdown backticks around the whole command are allowed.
+- Never append outcome or explanatory prose to a gate command, including phrases such as "passes on the final tree". Put outcome expectations in Success Criteria or checkpoint documentation instead.
 
 Bug-labeled missions (regression-test-first / "lock the bug"):
 - this section applies only when the backlog task at `{{taskPath}}` carries a `bug` label (in addition to its `ai_sdlc` or `user_value` classification). If there is no `bug` label, ignore this section entirely.
 - make the **first checkpoint** the authoring of a failing reproduction test that locks the bug before any fix is written. Describe in that checkpoint: the test file location (under `test/`), the reproduction scenario, and the assertion that fails at the mission's parent commit (red) and will pass once the fix lands (green).
-- record the reproduction test's path in `{{missionPath}}` on its own line in the exact form `Reproduction-Test: <path>` (e.g. `Reproduction-Test: test/task-1354-repro.test.js`). The handoff red→green gate reads this line to locate the test, so it must be present and accurate.
+- record the reproduction test's path in `{{missionPath}}` on its own line in the exact form `Reproduction-Test: <path>` (e.g. `Reproduction-Test: test/task-1354-repro.test.ts`). The handoff red→green gate reads this line to locate the test, so it must be present and accurate.
 - do not author the fix during draft — the reproduction test and its `Reproduction-Test:` declaration are the only bug-specific drafting outputs.
 
 Graphify-first: before drafting, check if `graphify-out/graph.json` exists. If it does, run `graphify query "{{slug}} mission scope and dependencies"` to understand the codebase context before filling in the mission contract. After drafting, run `graphify update .` if you modified any code files.

package/build/prompts/execute-core.md

@@ -0,0 +1,37 @@
+# Execute core
+Mode: execute after lock.
+Mission: {{missionPath}}
+Mission dir: {{missionDir}}
+Slug: {{slug}}
+Backlog task: {{taskPath}}
+
+Harness preflight already confirmed:
+- branch/worktree shape
+- mission doc presence
+- Backlog task presence
+
+Execution requirements:
+- execute checkpoint-by-checkpoint per the contract in `{{missionPath}}`
+- after each completed checkpoint, write `CP-N.md` in `{{missionDir}}` containing: a summary of work done, a Goal Check table with durable evidence such as runnable project commands, test names, decision-record references, or test paths, and a non-generic `Next action:` line
+- Completing a checkpoint is **non-terminal**: after committing its `CP-N.md`, immediately continue to the next incomplete checkpoint declared in the mission. Do not send a final response or exit merely because one checkpoint is complete; break large checkpoints into safe slices and keep progressing.
+- You may terminate this execution only when exactly one of these conditions applies: (a) every declared checkpoint is committed and every mission-declared gate passes, (b) a mission stop rule applies, or (c) a genuine external dependency blocks progress. Checkpoint size, uncertainty, or needing further investigation are not terminal conditions.
+- Keep Goal Check evidence durable: prefer stable file references and commands that can be rerun against the committed tree. Do not claim that `git diff HEAD` proves a committed change—its expected output is empty after committing. If historical diff evidence is needed, state the exact non-HEAD baseline or describe the observed change without implying that an empty post-commit diff will reproduce it.
+- the final checkpoint document MUST contain a Goal Check table citing real, durable evidence such as runnable project commands, test names, decision-record references, or test paths
+- **Heading requirement:** Use the exact section header `## Goal Check`.
+- **Goal Check table format:** Use a 3-column pipe-delimited markdown table: `| Criterion | Evidence | Status |` followed by a separator row `|---|---|---|`, then one evidence row per criterion.
+- **Accepted evidence forms** (each row's Evidence column must cite at least one verifiable reference from this list):
+  1. **Runnable project commands or stable paths** — e.g., `` `make test` ``, `` `go test ./...` ``, or `` `tests/integration/` ``
+  2. **Test names** — e.g., `"saving a record preserves its identifier"` (must match a test name found in the project)
+  3. **Decision-record references** — e.g., `ADR 0048` (when the project uses ADRs or an equivalent decision record)
+  4. **Test paths** — e.g., `tests/integration/` (must be an existing test path)
+  5. **File:line references** — accepted when needed, but line numbers eventually rot; prefer the forms above
+- **Not sufficient by themselves:** raw `stat`/`ls` output or generic prose claims. You may include them as supporting context, but the same Evidence cell must also cite at least one accepted reference from the list above.
+- verify all mission-declared Gates pass before handoff
+- Immediately after **each successful mission-declared Gate**, compact your working context before starting the next gate, checkpoint work, or handoff work. Reload only the locked mission goal and scope plus committed checkpoint or successful-gate evidence that is present. Do not compact for a failed gate: retain its failure diagnostic while repairing it.
+- preserve `{{taskPath}}`: update mission-relevant content as needed but do not delete, rename, or move the file
+- do not change the Backlog task's status, assignee, labels, or lifecycle metadata, and do not run `px active`, `px review`, or `px integrate`; Parallix performs lifecycle transitions itself
+- do not hand off to review if `{{missionPath}}` or checkpoint documents are uncommitted
+
+Graphify-first: before executing, check if `graphify-out/graph.json` exists. If it does, use `graphify query "<question>"` for codebase questions, `graphify path "<A>" "<B>"` for relationships, and `graphify explain "<concept>"` for focused concepts. Read `graphify-out/GRAPH_REPORT.md` only for broad architecture review. Run `graphify update .` after modifying code. If `graphify-out/wiki/index.md` exists, use it for broad navigation.
+
+{{checkpoint_context}}

package/build/prompts/review-core.md

@@ -0,0 +1,71 @@
+# Review core
+Mode: review. No code changes, commits, repo-state edits, or implementer behavior.
+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 {{reviewBaseline}}..HEAD`
+- review history: `px status {{slug}}`, whose `Review:` block reports the current round, phase, and disposition, then each recorded round with its reviewer and implementer families, verdict, comment, findings, fixes, and pushbacks. This is projected from the operator database, not from your own context.
+
+Review history is not optional context:
+- You may not be the agent family that reviewed the previous round. When a family is usage-blocked the workflow reroutes the launch, so the round-1 reviewer's context is simply gone. `px status {{slug}}` is how that continuity is preserved.
+- Do not re-raise a finding a previous round already settled. If the implementer fixed it, verify the fix instead of restating the finding. If the implementer pushed back, engage with their rationale — accept it, or explain specifically why it does not hold.
+- Treat a `PUSHBACK_ALL` in the history as a response awaiting your decision, not as an approval and not as a fresh set of findings.
+
+Minimum loop contract:
+- When `{{attempt}}` is 2 or later, before beginning this review round compact the prior-round working context. Reload the locked mission goal and scope; committed checkpoint or gate evidence when present; current round and disposition; unresolved findings and implementer resolutions; and the exact post-rebase revision and review baseline shown by `git diff {{reviewBaseline}}..HEAD`. This review-loop compaction is independent of `MISSION.md` gates.
+- Load the locked mission at `{{missionPath}}` and `AGENTS.md` before reviewing.
+- The block below reports which controls the workflow has already executed for this mission and which it has not, derived from machine records rather than from anyone's prose. Do not re-run a listed command whose recorded status is `passed`; cite the recorded result from this block instead. Re-running is permitted only when the block reports no recorded gate result, reports a `failed` status, reports a control as not yet run, or the command you need is not listed here.
+{{completedControls}}
+- Do not invoke `px` yourself, with one exception: `px status {{slug}}` is read-only and is the required way to load review history. Never run any other `px` subcommand.
+- 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.
+- Findings must be grounded in `git diff {{reviewBaseline}}..HEAD`, mission/checkpoint evidence, or inability to identify the reviewed revision.
+- PR metadata, commit ancestry, and historical commits outside `git diff {{reviewBaseline}}..HEAD` are context only. They must not produce a mission finding, request-changes verdict, or workflow block unless the mission introduced or materially worsened the inconsistency, or the review surface cannot identify the exact reviewed revision.
+- Confirm the final checkpoint document in the mission directory contains a Goal Check table citing real, durable evidence such as backticked commands, test names, ADR references, or test file paths.
+- Treat checkpoint evidence as a record of the work at the time it was performed. A command such as `git diff HEAD` is expected to be empty after a checkpoint is committed; that alone is not a finding. Flag evidence only when it is materially false, unverifiable from the committed tree, or conceals a mission change. Prefer the mission diff against `{{reviewBaseline}}` and stable file/test evidence when checking claims.
+- Write findings to `{{artifactDir}}/{{slug}}-review-findings.md`, outcome to `{{artifactDir}}/{{slug}}-review-outcome.md`, and verdict to `{{artifactDir}}/{{slug}}-review-verdict.txt`.
+
+Rebasing Artifacts:
+- Ignore diff entries that are only present because the branch is behind `{{primaryBranch}}` and will be resolved by parallix rebase before integration.
+- Treat missing files that were added on `{{primaryBranch}}`, deletions that already happened on `{{primaryBranch}}`, and similar stale-baseline noise as rebasing artifacts, not mission changes.
+- If a questioned change disappears when compared to the mission's actual parent or merge-base and the mission did not introduce it, do not file a finding for it.
+- Still flag real scope or correctness problems when this mission actually changes the file; only ignore branch stale-ness that is not a mission change.
+
+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
+
+  - Artifact handoff is mandatory: your final chat response does **not** submit a review. Before stopping, create all three files: `{{artifactDir}}/{{slug}}-review-findings.md`, `{{artifactDir}}/{{slug}}-review-outcome.md`, and `{{artifactDir}}/{{slug}}-review-verdict.txt`.
+- Write findings to `{{artifactDir}}/{{slug}}-review-findings.md`, then write the outcome and verdict files alongside it.
+- The findings file must contain findings (write `No findings.` when approving). For request-changes, give every finding a parser-stable heading such as `## F1: summary`, `## F2: summary`; round-prefixed headings such as `## R3-1` are invalid. The outcome file must state `Outcome: approve` or `Outcome: request-changes`. The verdict file must contain exactly `approve` or `request-changes` and a newline. `comment` is not valid.
+- After writing them, run `ls -l {{artifactDir}}/{{slug}}-review-findings.md {{artifactDir}}/{{slug}}-review-outcome.md {{artifactDir}}/{{slug}}-review-verdict.txt` and read back the verdict file. If any file is absent or the verdict is not exact, fix the files before stopping.
+- Do not call px directly, the workflow will do that for you — except for the read-only `px status {{slug}}` above, which you must run to load review history
+- 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.
+- 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.
+
+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
+
+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`.