opencode-froggy 1.1.1 → 1.1.3

package/README.md

@@ -146,7 +146,7 @@ A primary agent that delivers a development request end-to-end through coordinat
 1. **Decompose** — split the request into tasks of kind `implementation`, `research`, or `verification`, with disjoint file scopes for parallel implementation tasks (overlapping scopes are serialized through dependencies), each rated `complex` or `normal`, forming a dependency DAG. Exploration can go to `explore`, hard planning to `architect`.
 2. **Worktrees and snapshots** — verify the repo is clean, then capture the base branch and its commit. Each implementation task gets its own worktree and branch (per the environment's conventions), created only once all its prerequisites are validated, starting from the base commit plus its validated implementation ancestors merged in topological order (single ancestor: fast-path from its commit; transitive ancestors count even through research tasks). Verification tasks run in their own worktree at that same prepared snapshot and report the verified SHA and results. Research findings are passed in the prompt instead of merged. Comparison candidates share the same snapshot.
 3. **Dispatch** — after the user approves the decomposition, spawn a `general` sub-agent per ready task in the background, with the model picked from the pool matching its complexity. Sub-agents work inside their worktree (they move their session there so all their work stays isolated); the complete delivery commit is produced during the quality gate, after simplification. Comparison tasks run the same task on every model of the pool in parallel.
-4. **Quality gate** — on each implementation delivery, `code-reviewer` reviews all working-tree states; blocking issues go back by resuming the implementer's session (full context kept), optionally under a different model — escalate when stuck, downgrade when slow or costly. The implementer then commits exactly what was reviewed; the task is validated when build/tests pass at that exact commit in a clean worktree, recording its `validated_commit` SHA. Max 2 rework rounds; a failed task transitively fails its pending dependents while independent tasks continue.
+4. **Quality gate** — on each implementation delivery, `code-reviewer` reviews all working-tree states; blocking issues go back by resuming the implementer's session (full context kept), optionally under a different model — escalate when stuck, downgrade when slow or costly. The implementer then commits exactly what was reviewed; the task is validated when build/tests pass at that exact commit in a clean worktree, recording its `validated_commit` SHA. Max 2 rework rounds; a failed task transitively fails its pending dependents while independent tasks continue. Comparison tasks are reviewed by a single `code-reviewer` session across all candidates, which ends with a comparative verdict; recommended parts of discarded candidates are adopted by resuming the winner's implementer for one rework round, then re-gated.
 5. **Integration and simplification** — once **all** tasks are delivered, merge the `validated_commit` SHAs into the base branch in one topologically ordered pass, cleaning up after each integrated task (worktree, merged branch, temporary artifacts no longer needed). A conflicting merge is aborted in the base checkout first, then delegated: the implementer merges the current integration commit in its worktree, commits the resolution, re-passes the quality gate, and a replacement SHA is recorded before retrying. Dependent revalidation is bounded to one cascade. Never forced, never leaving an unfinished merge behind. After the final merge, a single `code-simplifier` pass refines the integrated changes, its edits get a focused review, build/tests re-run, and the result is committed. Then remove remaining worktrees (research, verification, failed, excluded) and stray temporary artifacts, and report a per-task summary.
 
 #### Model configuration

package/agent/build-orchestrator.md

@@ -40,7 +40,7 @@ normal: provider/model-c
    - `objective`: what to build, find, or verify, with acceptance criteria
    - `scope`: files or directories it may touch (empty for research and verification)
    - `complexity`: `complex` or `normal`
-   - `compare`: optional, `true` to run the task on every model of the pool and keep the best delivery
+   - `compare`: optional, `true` to run the task on every model of the pool and keep the best delivery, possibly with parts adopted from the others
    - `depends_on`: ids of tasks that must be validated before this one starts
 3. **Isolation rule:** implementation tasks running in parallel must have disjoint scopes; overlapping scopes are serialized through `depends_on`. Research and verification tasks touch no code but still wait for their prerequisites.
 4. If the request is ambiguous, ask the user before decomposing. Then present the plan (tasks, kinds, models, parallel groups) and get the user's approval before launching any task sub-agent. Read-only preparatory sub-agents (`explore`, `architect`) may run before approval — they build the plan, not code.
@@ -73,12 +73,13 @@ normal: provider/model-c
 
 Research and verification reports are assessed directly against their acceptance criteria.
 
-1. **Review:** a `code-reviewer` sub-agent reviews the delivered code in the worktree — committed, staged, unstaged, and untracked alike.
+1. **Review:** a `code-reviewer` sub-agent reviews the delivered code in the worktree — committed, staged, unstaged, and untracked alike. Comparison tasks use a single `code-reviewer` session for every candidate, in pool order — resume that session for each candidate and each rework round, so all candidates are judged against one baseline.
 2. **Rework loop:** blocking issues go back to the session that produced the delivery (resume it, full context kept), optionally under a different model — escalate when stuck, downgrade when slow or costly. Each round repeats review until no blocking issues remain.
 3. **Commit:** the implementer commits the complete delivery — exactly what was reviewed; any further change goes through the rework loop.
 4. **Validation:** build and tests pass at that commit and the worktree is clean → record the commit SHA as the task's `validated_commit`.
-5. **Comparison tasks:** once every candidate passed the gate (or after one review round), keep the best delivery against the acceptance criteria and discard the others.
-6. **Limits:** at most 2 rework rounds per task, then `failed`: remove its worktree, keep its branch for possible later recovery. When a task fails, transitively mark its pending dependents `failed` (recording the failing prerequisite) and continue independent tasks so the final barrier stays reachable.
+5. **Comparison tasks:** once every candidate passed the gate (or after one review round), the same reviewer session delivers a comparative verdict — each candidate against each acceptance criterion, a recommended winner, and optional partial-adoption suggestions (parts of a discarded candidate worth keeping). Keep discarded candidates' worktrees and branches until the winner is fully validated, then discard them.
+6. **Hybrid adoption:** when the verdict recommends adopting parts of a discarded candidate, resume the winning candidate's implementer session (full context kept) with the adoption instructions and a pointer to the discarded branch to borrow from. The reworked delivery re-passes the full gate — review by the same reviewer session, build, tests — before its commit is recorded as the `validated_commit`. At most one adoption round, then fall back to the winning candidate as delivered.
+7. **Limits:** at most 2 rework rounds per task, then `failed`: remove its worktree, keep its branch for possible later recovery. When a task fails, transitively mark its pending dependents `failed` (recording the failing prerequisite) and continue independent tasks so the final barrier stays reachable.
 
 ## Phase 5 — Final integration and simplification
 

package/agent/code-reviewer.md

@@ -26,6 +26,27 @@ permissions:
   - action: shell
     resource: "git rev-parse*"
     effect: allow
+  - action: shell
+    resource: "git remote -v"
+    effect: allow
+  - action: shell
+    resource: "printf*"
+    effect: allow
+  - action: shell
+    resource: "gh pr view*"
+    effect: allow
+  - action: shell
+    resource: "gh pr diff*"
+    effect: allow
+  - action: shell
+    resource: "gh api repos/*"
+    effect: allow
+  - action: shell
+    resource: "gh api repos/* --method*"
+    effect: deny
+  - action: shell
+    resource: "gh api repos/* -X*"
+    effect: deny
 ---
 
 # Code Review Agent

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-froggy",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "description": "OpenCode plugin with a hook layer (tool.before.*, session.idle...), agents (code-reviewer, doc-writer), and commands (/review-pr, /commit)",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",