Dual-Session Story Flow: Builder & Read-Only Reviewer

    1

    Two separate AI sessions per story on the tool you already use: one implements in an isolated worktree, one reviews read-only. A verifier exit code, not agent prose, decides when it is done.

    Free

    1 useSecurity scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Dual-Session Story Flow: Builder & Read-Only Reviewer

    Example session with this skill installed

    Run story CAN-002 with the dual-agent Codex flow.

    • Read your context and instructions
    • Compiled the dual-session story flow

    Summary

    CAN-002 is implemented, verified and independently reviewed in its own worktree. Verdict: PASS. The flow stopped before push; the branch is ready for your review.

    Illustrative example of the stages and artifacts the bundled scripts produce. It is not a recorded run.

    StageWhat runsOutput
    Worktreenew-story.sh CAN-002.agent-worktrees/CAN-002 on branch codex/CAN-002, from the fetched base. Your current branch is untouched.
    Buildcodex exec -s workspace-writeImplementer commits specs/CAN-002.md, line_count() and its tests on the story branch
    Verifyscripts/verify.shscripts/verify-project.sh exits 0
    Reviewseparate codex exec -s read-only.codex-flow/CAN-002/CAN-002-review.md starts with VERDICT: PASS
    Fix passskippedonly runs on VERDICT: CHANGES_REQUESTED, at most once, followed by verify and one re-review

    Review finding format (when changes are requested): P0, P1 or P2 severity, file and line, a reachable failure scenario, and the smallest safe correction. Style-only or speculative findings are excluded.

    Traces: every Codex run writes JSONL under .codex-flow/CAN-002/.

    Next steps

    • Read the diff of codex/CAN-002 against the base
    • Push, open the PR and merge yourself
    • After the merge, clean up with Merged Worktree Cleanup

    Connects securely to your tools. The creator never sees your data.

    About this skill

    What it does

    The problem. A single AI coding session that writes and reviews its own code agrees with itself. Long review loops burn tokens without converging, and an agent with push rights can ship before you look.

    What the skill does. It starts a fresh implementer session with write access inside a dedicated Git worktree, requires it to commit spec, code and tests, runs your verifier, then starts a separate reviewer session in read-only mode. Works out of the box with Codex CLI (AGENT_CLI=codex), and supports Claude Code (AGENT_CLI=claude), Gemini CLI (AGENT_CLI=gemini), OpenCode (AGENT_CLI=opencode), or IDE sessions in Cursor, Google Antigravity, and Windsurf via --from review. Findings must name severity, file and line, a failure scenario and a minimal fix. At most one fix pass and one re-review follow.

    Why not just prompt for it. The isolation is real: separate processes, separate context windows, read-only review enforcement, a separate worktree, and an exit code as the gate.

    Use it when you use one primary AI coding tool or subscription and still want an independent review on a story with checkable acceptance criteria.

    Known limits.

    • Quota is consumed by two sessions per story, more when a fix pass runs.
    • If the review stage stops (for example on quota) or you implemented the story interactively in an IDE, resume with story.sh <ID> --from review; it skips only the build and reruns verification first.
    • Non-mechanical judgments must be recorded as human gates.

    Where it fits

    1. Project Setup, once per repository: plan, backlog, verifier
    2. Multi-Agent Story Flow or Dual-Session Story Flow (this skill), once per story: build, verify, independent review
    3. You: read the diff, push, open the PR, merge
    4. Merged Worktree Cleanup, after the merge: remove the worktree and branch

    Project Setup is optional but recommended: without it the story flows fall back to auto-detected checks, with no backlog or project-owned verifier.

    How to use

    1. Unzip once into a shared folder that every agent can use: mkdir -p ~/.agents/skills/dual-session-story-flow && unzip -o dual-session-story-flow-<version>.zip -d ~/.agents/skills/dual-session-story-flow. Codex CLI and Gemini CLI read ~/.agents/skills directly. Point the others at the same folder instead of making a second copy:

      • Claude Code: mkdir -p ~/.claude/skills && ln -sfn ~/.agents/skills/dual-session-story-flow ~/.claude/skills/dual-session-story-flow
      • Cursor: mkdir -p ~/.cursor/skills && ln -sfn ~/.agents/skills/dual-session-story-flow ~/.cursor/skills/dual-session-story-flow
      • Antigravity: mkdir -p ~/.gemini/config/skills && ln -sfn ~/.agents/skills/dual-session-story-flow ~/.gemini/config/skills/dual-session-story-flow

      Keep only this one copy: a second install of the same skill can make the agent pick the wrong one.

    2. Add scripts/verify-project.sh with your real checks.

    3. Write specs/<ID>.md from the bundled template, then run the story (AGENT_CLI=codex by default, or AGENT_CLI=claude|gemini|opencode). The ID must match PREFIX-nnn.

    4. Review the diff, push, open the PR and merge yourself.

    Requirements

    git, bash 3.2+, tee, at least one supported agent CLI (codex, claude, gemini, or opencode), and your project's toolchain. macOS, Linux, or Windows through WSL.

    Works best with: Project Setup (verifier and backlog) and Merged Worktree Cleanup (after the merge).

    Codex-only; for a Claude Code implementer use Story Flow. Two Codex sessions per story, more with a fix pass. At most one fix pass and one re-review, then unresolved findings come back to you. If the review stage fails, resume with story.sh <ID> --from review. Push, PR and merge are always yours.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    1 use

    Times used to date

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 7 days ago

    • Free with an Agensi account

    Requires

    Git
    Codex CLI

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Network Access
    Environment Variables

    File Scopes

    .agent-worktrees/**
    .codex-flow/**
    specs/**

    Network: `git fetch` (skip with `FETCH_BASE=0`), plus your chosen `AGENT_CLI` for the implementer and read-only reviewer sessions. Writes: the worktree at `.agent-worktrees/<ID>` and traces under `.codex-flow/<ID>/`. Never: pushes, opens a pull request, or merges.

    Listed16 days ago
    Updated7 days ago

    What's inside

    Frequently Asked Questions

    No. Push, PR creation and merge stay human gates. The implementer may only commit on its isolated story branch.

    No. The worktree helper creates codex/<ID> under .agent-worktrees/<ID> and never switches, resets or cleans your primary checkout.

    It is a separate codex exec process with an explicit read-only sandbox. It starts from the branch diff and inspects related code only to validate a concrete finding.

    The implementer gets one fix pass, then verification and one re-review run. Unresolved design decisions come back to you instead of starting an agent-to-agent loop.

    For a Claude Code implementer with a Codex reviewer, use Story Flow, which automates exactly that pairing.

    Any stack whose checks run as one command that exits non-zero on failure. Before you write scripts/verify-project.sh, Rust, Node.js, Go, Java, Python and .NET projects are detected automatically.