Omniscio

Dev Pipeline (part 2)

The configuration and internals behind Dev Pipeline: the opt-in behaviour modes, the per-phase and per-project instruction layers, the always-on standards phases, the auto-approve marker that lets a run advance itself, and how the skill runs self-contained.

On this page

What it is

The second half of Dev Pipeline. Part 1 covers what the workflow is and how a run moves through its phases; this page covers the switches that change how those phases behave, the instruction layers you can add to a phase, and how the skill is built to run without any setup.

Where to find it

The switches for these modes live with the rest of the workflow's controls in the Dev Pipeline panel. The skill install is not a separate control either: it follows the one master switch (devPipelinePanelEnabled), which installs the skill to ~/.claude/skills/dev-pipeline/ and removes it again when you switch the pipeline off, and each phase's definition travels with it. That switch is also the "Dev Pipeline" row in Settings → Features — the same setting, not a second toggle — where the gate auto-approval controls sit beside it.

How it behaves

Independent-review mode (opt-in)

By default the pipeline's reviews are self-review — the same agent that wrote the plan red-teams it, and the build checks its own work. Ask for a second, genuinely independent opinion — "peer review", "bring in other AIs", "independent review", or /dev-pipeline --peer-review "<task>" — and at two points the run brings in blank-slate reviewer subagents (fresh context, no memory of having written the work) to tear it apart: the plan (after the red team) and the built code (after it verifies). It's an addition, not a replacement — your existing red team still runs, and the independent pass rides on top.

The reviewers are read-only: each sees only the work plus an adversarial brief and returns findings, never editing anything. The orchestrator then verifies each finding before acting on it — aggregating them, discarding false positives, and folding only the real ones in — so a reviewer's mistake (even a bad "drop this check" suggestion) can never turn into a real change. Each affected gate report gains an ## Independent Review summary of what was flagged, confirmed, discarded, and folded in; if reviewer subagents genuinely can't be spawned, the run says "independent review unavailable" rather than implying it happened.

Like the other modes it's per-run, recorded in state.md as ## Review: peer so it survives a mid-run compaction, and it composes freely with autonomous and tiered mode (the reviewers can even run on a cheap model). The default stays self-review, byte-for-byte as before. Details: the dev-pipeline skill CONTRACT.md invariant 33.

Want genuinely different AIs? — the cross-vendor tier (peer-multi). Ask for "peer review with other vendors / GPT / Gemini", "review with different AIs", or /dev-pipeline --peer-multi "<task>", and instead of in-session Claude reviewers the run spins up real sessions on other vendors (GPT, DeepSeek, Kimi, GLM…) to review the plan and the code, then collects and verifies their findings the same way — never Codex or Gemini specifically, since each of those runs its own separate program instead of the one the locked-down reviewer harness can confine. It's off by default and costs real money each run — a per-run cost cap (Want genuinely different AIs? — the cross-vendor tier (peer-multi). Ask for "peer review with other vendors / GPT / Gemini", "review with different AIs", or /dev-pipeline --peer-multi "<task>", and instead of in-session Claude reviewers the run spins up real sessions on other vendors (GPT, DeepSeek, Kimi, GLM…) to review the plan and the code, then collects and verifies their findings the same way — never Codex or Gemini specifically, since each of those runs its own separate program instead of the one the locked-down reviewer harness can confine. It's off by default and costs real money each run — a per-run cost cap ($1 by default) plus a preference for cheap vendors like DeepSeek keeps it small; it auto-skips any vendor you haven't set up, including one you have switched off in Settings → Accounts, and says "cross-vendor review unavailable" if none are. Two things to know: the outside reviewers are only ever handed the work to review — never any token or secret — and because they run on other vendors, peer-multi inherently sends the work-under-review to those vendors' servers. An outside reviewer is locked down for its whole life: it can read and search any file on your computer except credentials (your keys, .env and other secret files), read the app's live data through one read-only data tool — your tasks, sessions and their transcripts, missions, documents and reviews — search the web and read public pages, and nothing else. It cannot run a command, change a file or any app data, message anyone, reach other services on your own computer or local network, or read your keys. When it finishes, the app itself hands its answer to the agent that asked and archives the reviewer, so a finished reviewer never lands in your inbox and never interrupts you with a notification — not when it starts and not when it finishes. The reviewer is archived either way, so a failed hand-over never leaves it sitting there for you to clear, and its findings stay readable in its own history. A reviewer that can't be locked (an AI engine without the lock, or spawn approval switched on) is refused and never started. So is one whose session would be handed its model credential by Omniscio at run time from the session's own identity — a reviewer never holds, and is never given a way to obtain, the app's keys — which is why an engine that could only ever run on Omniscio credits is reported as not run before anything starts — with the reason, and with the exact model id that runs the same model on a key you already have, so switching is one edit. An engine your own key can serve simply runs on that key, whatever order your Who pays & who serves list puts things in, so naming Kimi gets you a Kimi reviewer as long as you have a Kimi key saved. And if one never answers — held up by its vendor's rate limit, say — the run drops it and reports that review as not run, never as done. Omniscio's usage cascade never switches a reviewer to a different AI: the AI you named is the AI that answers, because the review's title and the verdict it hands back both name that engine, and re-running it somewhere else would credit one AI with another's work. When your named AI runs out mid-review it waits for that AI to come back, or ends saying the engine was unavailable. Details: the dev-pipeline skill CONTRACT.md invariant 34 and the locked-reviewer contract (.claude/memory/contracts/ai-code-review-locked-reviewer-contract.md). by default) plus a preference for cheap vendors like DeepSeek keeps it small; it auto-skips any vendor you haven't set up, including one you have switched off in Settings → Accounts, and says "cross-vendor review unavailable" if none are. Two things to know: the outside reviewers are only ever handed the work to review — never any token or secret — and because they run on other vendors, peer-multi inherently sends the work-under-review to those vendors' servers. An outside reviewer is locked down for its whole life: it can read the code in your repository (including the branch under review and the installed libraries), search the web and read public pages, and nothing else — it cannot run a command, change a file, message anyone, reach services on your own computer or local network, or read your keys or the secret files in the project folder such as .env. It reads a frozen copy of the change under review: a code review names its branch's folder, and Omniscio freezes that branch's commit when the reviewer starts and runs the reviewer in a snapshot of it, so what it reads is exactly the change under review rather than whatever checkout happened to be open, and it cannot move mid-review. A code review that names no branch folder is refused instead of being started against the wrong tree, and a review of a change that has already landed names the project folder itself — because then the main checkout is the change under review. Either way Omniscio tells the reviewer exactly which commit it is reading, so you can always see what a verdict was based on. When it finishes, the app itself hands its answer to the agent that asked and archives the reviewer, so a finished reviewer never lands in your inbox and never interrupts you with a notification — not when it starts and not when it finishes. The reviewer is archived either way, so a failed hand-over never leaves it sitting there for you to clear, and its findings stay readable in its own history. A reviewer that can't be locked (an AI engine without the lock, or spawn approval switched on) is refused and never started. So is one whose session would be handed its model credential by Omniscio at run time from the session's own identity — a reviewer never holds, and is never given a way to obtain, the app's keys — which is why an engine that could only ever run on Omniscio credits is reported as not run before anything starts — with the reason, and with the exact model id that runs the same model on a key you already have, so switching is one edit. An engine your own key can serve simply runs on that key, whatever order your Who pays & who serves list puts things in, so naming Kimi gets you a Kimi reviewer as long as you have a Kimi key saved. And if one never answers — held up by its vendor's rate limit, say — the run drops it and reports that review as not run, never as done. Omniscio's usage cascade never switches a reviewer to a different AI: the AI you named is the AI that answers, because the review's title and the verdict it hands back both name that engine, and re-running it somewhere else would credit one AI with another's work. When your named AI runs out mid-review it waits for that AI to come back, or ends saying the engine was unavailable. Details: the dev-pipeline skill CONTRACT.md invariant 34 and the locked-reviewer contract (.claude/memory/contracts/ai-code-review-locked-reviewer-contract.md).

Tiered-model execution (opt-in)

Ask for it — "run tiered", "smart planner, middle executor", "plan on Opus, build on Sonnet", or /dev-pipeline --tiered "<task>" — and the run splits the work across two model tiers: a smart model does the planning and judging, a middle model does the heavy execution. By default only the Build phase drops to the middle tier (plan, red-team, elegance, and docs stay smart) — which is exactly "smart plans and judges, middle executes" — but you can reassign any of phases 1–5 (e.g. "tiered, docs on middle too"). The default pair is the smart tier for planning and judging and the worker tier for execution — tier names, never a pinned model id, so the sentence does not go stale when a new model ships. ("Plan on Opus, build on Sonnet" is how you might say it; the pipeline stores the tiers.) You can name a different pair per run.

The smart main loop always keeps the judgment: on a middle phase it delegates only the generative work to a middle-model subagent, then reviews that output and presents the gate itself — the tiering never quietly moves a judgment call to the weaker model. If a middle-model subagent can't actually be run, the pipeline reports "tiered execution unavailable" rather than silently running everything on one model while implying a saving. Like autonomous mode it's per-run, recorded in state.md as ## Models: tiered so it survives a mid-run compaction, and the two compose freely. The default stays a single model for the whole run.

Even without tiered mode, the build already leans cheap by default. In an ordinary single-model run, the Build phase now encourages handing the actual code-writing to cheaper Sonnet-level implementer subagents while the orchestrator reviews and double-checks every diff — the same "cheap writes, smart reviews" economics as the tiered Build tier, but with no opt-in. Crucially this is decoupled from parallelism — even work that can't be fanned out in parallel (a shared-git audit fix-wave committed one finding at a time) still hands each edit to a cheaper implementer and reviews it serially (a sequential cheap-writer), so "can't parallelize" is never by itself a reason to keep the writing on the expensive model. It's a bias, not a rule: a tiny cohesive change, or work that genuinely needs the smart model's own hand, can stay on the main loop. Tiered mode above is just the formal, recorded, per-phase version of that same split. Details: the dev-pipeline skill CONTRACT.md invariant 31.

AI Code Review phase (opt-in — a review step after ANY phase)

Independent-review mode above adds fresh-eyes reviewers at two fixed points. If you want that review as a proper step you can put wherever you like, turn on the AI Code Review phase: Dev Pipeline panel → Setup → AI code review, one switch per phase (after Plan, Red Team, Build, Elegance, or Docs). Switch on one, several, or all five. It's off everywhere by default, and with nothing switched on the pipeline runs exactly as it did before.

Each point you enable becomes a real phase with its own gate — ## 🧭 🟢 AI Code Review — and the review's own verdict decides whether it interrupts you. A review that came back clean, or whose findings the run already confirmed and fixed, closes green and the pipeline moves straight on: nothing lands in your inbox. A review that turned up something you should actually weigh in on stops the run and waits for you, exactly like any other gate. That's why there's no auto-approve switch for it — the gate isn't a blanket stop you'd want to turn off, it's a stop that only happens when there's something for you. While the review is still running, the run is waiting, not asking: it holds quiet and the review's own result wakes it, so a run that has just posted its review request never shows up in your inbox asking you to approve a wait you cannot end.

While the review is running, the session stays out of your inbox. The agent usually posts its gate report and asks for the review in the same turn, then ends its turn to wait. Omniscio knows the review's results are on their way, so it keeps the session quietly running, with a ⏱ Auto-waited tag that reads "waiting for its own AI review to come back", instead of dropping it into your inbox. The results wake the session the moment they arrive and the run carries on. It still reaches your inbox right away when the turn asks you a question, carries a HOLD, is tagged for you to read now, or runs on a cloud machine, or when a machine (not you) woke it while you still had something unread from it. The wait is capped at four hours as a safety net, and a review normally comes back in a few minutes.

In chat it reads as one of the family: its bubble draws the same row of phase discs as every other gate, with its own 🧭 disc lit immediately after the phase it reviews, so you can see at a glance where the review sat in the run.

The 202 is not the step done — a run cannot finish over a review that is still out. The step's check-in is the review the app holds plus the run's recorded verdicts on it, so while the review is still running the step stays owed: the next phase's check-in is refused naming it, and the ready tag cannot be earned over it. Once the review lands, a serious finding (blocker or major) keeps the step owed until it is fixed, or carries an explicit reason — a dismissal ("not a problem, because…") or a deliberate deferral ("real, but out of scope because…"). Leaving it unexamined, or recording an outcome with no reason, leaves it outstanding. A review that genuinely could not run is handled so a dead reviewer never strands a run, and which shape it was matters (2026-10-26). A review that settled with no reviewer answering — a timed-out round, or every seat answering could_not_start — closes a required step as not run: the run's later phases check in normally, and the ready tag still NAMES that step, because a review nobody performed is never counted as one that ran. A request the app refused, or one never made at all, leaves no review behind and keeps the step owed — so the next phase's check-in is refused naming it, and the fix is to ask for the review again. An optional step in any of those states is simply waived. Before 2026-10-20 a running review was misread as a review that could not run, and one run landed while its own review was still in flight; that review then found a real fail-open. A review that names a BRANCH rather than a folder (a patch-road branch, or a returned cloud branch) is read through a checkout the app builds for it, and until 2026-11-08 that checkout could be deleted by an unrelated release while it was still being built — which is why nearly every patch-road review on the second computer came back with no reviewer answer at all. The build now owns its folder until it finishes, so that round answers like any other.

What it does at each point is the same blank-slate mechanic peer-review mode uses: 2–3 fresh-context reviewers see only the work — the diff at a late point, the plan at an early one — plus a fixed review brief, never the orchestrator's reasoning. There are exactly two briefs, and neither is improvised on the spot: after Plan or Red Team every reviewer gets the plan-review brief (it attacks the plan from seven angles — the user who hits the edge case, the attacker, the operator mid-crash, the future maintainer, the bill payer, the tester, the skeptic) and reads the repository the RUN is working in, whichever repo the asking session itself lives in (on a cloud box it reads the checkout on your computer and the plan carries a note saying so), and after any other phase it gets the code-review brief. Both were tuned on measured runs to find real problems without inventing ones that aren't there — "no issues found" is a perfect answer on clean work — and every finding must name a concrete failure and the defense the reviewer checked. The skill keeps them as review-briefs/plan-review.md and review-briefs/code-review.md. They're read-only and return findings; the orchestrator verifies each one, discards false positives, fixes the real ones, and re-verifies. By default the reviewers are free in-session subagents, and a review switched on that way will never spin up paid other-vendor sessions on its own — that stays behind the per-run peer-multi opt-in above. Name another company in that phase's reviewer setting instead (Dev Pipeline panel → Setup → AI code review; the field's placeholder reads worker, codex, gemini) and it does start real sessions at that vendor on purpose: naming one is the authorization, so it spends money at their rates on every run and the work under review leaves this machine for them — the same trade peer-multi makes, chosen once when you set the phase up rather than per run, and under the same rules: the reviewer is locked to reading your code and the web, a reviewer that never answers is reported as not run, and when one finishes the app hands its findings to the run and archives it — it does not appear in your inbox.

Every one of those reviewer sessions — here and in peer-multi — is titled the same way: [Plan Review] GLM: <what it reviews> when it checks the plan, [Code Review] GLM: <what it reviews> when it checks the work, with the AI's name filled in by the app and the subject written by the run that asked for the review. More in review-session-titles.md.

A reviewer never waits on you. Each reviewer is archived the moment it answers. Once every reviewer on a review has answered — or the review's 45-minute limit passes with no reviewer still working — Omniscio hands you the WHOLE review's results in one go, waking the session that asked for it if it had gone to sleep (archived by the app, or its program stopped or crashed), but never one you paused or closed. A session you paused isn't skipped, though: the result is held and arrives the moment you next run it, rather than being quietly dropped. A reviewer that never finishes at all — because it was stopped, its program died, or it never got going — clears itself off the board about fifteen minutes after it goes quiet, without you removing it by hand; it deliberately leaves alone any reviewer it can see the app is already bringing back, such as one waiting out its AI company's rate limit. A reviewer that has gone silent no longer holds the review. After thirty minutes with no output and no file read or search — and no more than thirty-two, because the app checks every two minutes — its seat is closed with its own sentence and the review settles and comes back to you, rather than waiting out the 45-minute limit: "it never started producing output" for one that took no turn at all, "it stopped producing output" for one that spoke and then went quiet. A reviewer that is still working — producing output or reading and searching files — is never cut off by any clock: the review waits for it past the 45-minute limit (owner decision 2026-11-19, "the reviews are not constrained at all - they can investigate anything"). A reviewer may read and search anything on the computer except files that hold credentials, and there is no reading budget. If a closed seat does answer later its answer replaces the write-off and the corrected result is delivered to you. That same early settle is why a review slot can free before the 45-minute limit — and why a session told it already has two reviews running is also told which reviews hold them and how long the wait is. A reviewer the app has given up on — its turn went quiet and three automatic continue nudges did not bring it back — settles the moment that happens, with the app's own explanation on its row and nothing counted as a verdict, so the review hands back the OTHER reviewers' findings and the asking session gets its review slot back instead of waiting out the 45-minute limit with its result unreadable. And a reviewer whose session ends without an answer is reported with the reason — the app repeats the same explanation it wrote on that session, such as the engine being one it cannot run on — instead of the review waiting out its 45-minute limit only to be told that time passed. Nothing is lost when a delivery doesn't land: Omniscio keeps the result and delivers it as soon as it safely can. A reviewer also opens in the same hub as the session that asked for it, whatever project the request named, so you find it next to the work it reviews and it can read that work's code.

A reviewer that could not read the code gives no verdict. If a reviewer tried to open the code and every attempt failed — for example its connection to the app dropped mid-review — its answer is recorded as "could not review", never as a pass, even if it said "ship" from the change summary alone. It gets one automatic fresh try, and a review where nobody actually read the code does not count as a completed review step.

Where a reviewer reads is decided by the lock, not by luck. The folder a review names is also the folder the reviewer is started in, so a code review reads its branch by default. A code review that names no branch folder — or names one that is not a checkout of that project — is refused rather than started against the wrong code, and a review of something already merged names the project folder itself. That refusal is the point: before this, a review whose branch was not named simply read whatever was open and reported on it confidently, and nothing in its answer said which tree it had read.

Two practical notes. Each point you enable spends reviewer tokens on every run, so switching all five on roughly triples the review work in a pipeline — start with one or two. And where a review lands next to the pre-merge Standards Audit (both can sit after Docs), the review runs first and the audit stays last. Your choice is stored alongside your custom phases so the pipeline picks it up on every run, and your own custom phases are never touched by these switches. Details: the dev-pipeline skill CONTRACT.md invariant 34a.

A repo's shared review steps are the team default — your own settings win on your machine. A repo can commit review steps in its shared .claude/dev-pipeline/phases.json, and they run for everyone who hasn't set that step up themselves. Once you change any review setting for a step in your own Setup tab — which AIs, how many, or whether it's required — your settings run for that step on your machine, and your Setup tab never copies them into the shared file. A step you switch on without changing anything keeps the shared settings, and your Setup tab shows them, so if you then change one setting you start from the team's values. Changing the team default itself means editing the shared file and committing it. You can always switch a shared step off for yourself, though — a step that comes from the repo is drawn in your Setup tab too, marked as one the repo sets for everyone, and its switch turns it off for you alone: your team keeps its reviews, and switching it back on restores the repo's step on the repo's settings — which is also how you go back to the team default after changing a shared step's settings. Details: CONTRACT.md invariant 24b.

One switch turns every review step off at once — even in runs already under way. At the top of the same card, Run AI code review steps (on by default) stops every review step on this computer, including a shared step from a repo's committed file. It reaches runs that are already going: the app stops listing review steps for every session, whatever that session's own copy of the pipeline files says; any reviewer asked for while it is off is refused and the run is told to skip it (never a failure, even for a required review); and a session already waiting at a review step still moves on. Your per-step choices stay saved, so switching it back on restores them. The one reviewer it never stops is the app's own crew mission review, which is turned on and off separately from this switch. It is the live twin of the DEV_PIPELINE_DISABLE_BUNDLED_AI_REVIEW=1 environment switch, which still works. Details: dev-pipeline-panel-contract.md (ai-review-switch-reaches-running-work) and ai-code-review-locked-reviewer-contract.md (switched-off-reviewer-never-starts).

Keeping score — which AI finds the most, for the money. Every reviewer ranks each finding Blocker, Major or Minor; the scorecard counts Blocker and Major as serious (it would break behavior, lose data, open a security hole, crash, or break the build) and Minor as minor (real but low-stakes). The pipeline checks every finding, and it — not the reviewer — decides what counts: serious and minor include only problems it confirmed, and anything that turned out not to be real is counted as a false alarm. Omniscio then logs one result per reviewer it tried, including one that never answered, and adds what that reviewer cost from the reviewer's own session — none of this needs the pipeline to ask for it. If a reviewer the round had given up on answers afterwards, its entry is corrected to that answer — a miss becomes an answered review with its findings counted — so no reviewer is left scored as a no-answer when it did answer. Two more things are logged with each review: whose work was reviewed (the model the requesting session runs on, unless it names the AI that actually wrote the work — for instance a cheaper builder it handed the coding to), and the pipeline's own approve or disapprove of each answered review (disapprove means mostly false alarms, a serious problem it missed that the pipeline then found, or an answer it couldn't use). See the totals in Dev Pipeline panel → Setup → AI code review → How each AI has done, one row per model: reviews, no-answers, serious, minor, false alarms, how often its reviews were approved (blank — never 0% — until one is rated), total cost and cost per review. Below it, Whose work was reviewed lists each AI whose work got reviewed, with how many reviews and how many serious problems per review were found in it — which AIs need more review, and which need less. A dash in the cost column means the cost isn't reported — a reviewer that runs inside the pipeline's own session is billed with it, and some AI companies (Gemini, for one) don't report cost to Omniscio yet. Nothing is logged while every review step is switched off, results are kept for a year, and only counts and names are stored — never code or the findings themselves. Agents read the same numbers with GET /dev-pipeline/ai-review/scorecard. The review instructions reach the pipeline from the app (GET /dev-pipeline/phases), so improving them takes effect on the next run. Details: ai-review-scorecard-contract.md.

Per-phase custom instructions (persist across updates)

Append your own standing instructions to any phase and they're honored on every run — and they survive updates to the skill. Because Dev Pipeline is a bundled skill, an update overwrites its shipped files under ~/.claude/skills/dev-pipeline/; your custom text therefore lives in a separate folder Omniscio never touches: ~/.claude/dev-pipeline/custom/ (override the base dir with $DEV_PIPELINE_CUSTOM_DIR). Drop phase-1.md … phase-6.md to target a single phase, or all-phases.md to apply to every phase. Each file is optional and invisible until you create it; at the start of each phase the pipeline reads the matching file(s) and honors them as ADDITIONAL instructions — your text, appended to the phase's built-in steps. They're additive and bounded: custom text can never skip a gate, change a gate header, or make the pipeline push or merge (Phase 6 still never does). Set one up by dropping a markdown file in the folder, or just ask an agent to "add <instruction> to phase 3 of the dev-pipeline custom instructions."

Project-level phases (shared with your whole team)

Custom phases — extra gated steps woven into the flow (distinct from the per-phase instructions above) — can be committed to a repo so they become the project's standard and travel to every developer who works on it. Two sources are read and merged, project-first:

  • Project manifest — <repo>/.claude/dev-pipeline/phases.json, committed to the repo. It applies automatically to anyone running the pipeline in that repo — no per-dev setup, and independent of the personal "Enable custom phases" toggle — and never leaks to other repos or to people running the pipeline on their own projects, because it lives inside that repo's code.
  • Personal manifest — ~/.claude/dev-pipeline/phases.json, your own private phases, applied on whatever project you run the pipeline in (gated by your personal toggle).

On a same-name clash the project phase wins, so a shared standard can't be quietly overridden by one dev's personal config. With no project file and the personal toggle off, the pipeline is exactly the built-in six. The same file can now also change the built-in steps themselves — remove, rename, move, rewrite or un-gate any of them, lock steps, and build on a shared company pack: see Dev Pipeline packs. Project gates are still manual by default (a real stop), so an auto-activated standard never advances or spends on its own.

A run on a cloud machine still gets your review steps. The pipeline asks Omniscio for the exact list a repo is held to, naming the folder the run is working in — and on a cloud machine that folder is on the other computer, which Omniscio can't read. It doesn't refuse and leave the run with nothing: it answers with the list for that same repository as YOUR computer holds it, and when even that can't be resolved, with the default pipeline — the built-in phases, the two standards phases and every AI Code Review step you switched on. The answer also says which folder it couldn't read. The one thing it never does is hand back an empty list, because a run that reads "no review step" skips the review silently. Because project wins, editing such a phase in the Setup-tab panel writes your change THROUGH to that committed project file (and the editor shows the effective, what-actually-runs value), so a personal edit to a shared phase takes effect instead of being silently overridden — you still commit the file yourself. AI Code Review steps are the one exception: your own review settings win on your machine, so the editor shows them and never writes them into the shared file (see the AI Code Review section above). Details: dev-pipeline-panel.md and the dev-pipeline skill CONTRACT.md invariant 24b.

Always-on standards phases (every run)

Beyond the six built-in phases, every run also gets two always-on standards phases — a 🚦 Standards Check just after the red team (before building) and a 🔬 Standards Audit just after docs (before git-prep). By default they're auto-approving — they self-advance unless they find a real problem — so they don't add stops to your flow. If you'd rather review one yourself, you can switch either gate to manual in the Dev Pipeline panel → Setup → Gate auto-approval (those two live there only; Settings → Features shows the built-in five), and Omniscio then holds it for your approval like any other gate.

Instead of hardcoding any one project's rules, each phase reads a standards file, resolved in this order:

  • Your repo's own <repo>/.claude/dev-pipeline/standards.md — a plain-markdown file with two sections, ## Before you build (read by the check) and ## Before you merge (read by the audit). Commit it and it travels to everyone on the project; put the repo's real standards in it (point at its design system, its contracts, its docs). This is the file you customize per repo.
  • A bundled general fallback — if a repo has no standards file of its own, the phases fall back to a general staff-engineer standards file shipped with the skill (standards/general.md), so the check and audit still do something useful in any repo.

A repo's own file wins over the fallback section-by-section; if a section is missing it uses the general one, and if neither file exists the phases apply general engineering judgment and say so — a missing standards file never blocks a run. The standards file is additive and bounded: it can't skip a gate, change a gate header, or make the pipeline push or merge. To turn the two phases off entirely, set DEV_PIPELINE_DISABLE_BUNDLED_STANDARDS=1. Details: the dev-pipeline skill CONTRACT.md invariant 29.

The auto-approve marker (how a run can advance itself)

Every gate message ends with one machine-readable line — the last line, on its own:

  • Gates 1–5: [DEV-PIPELINE | GATE <n> | AUTO-APPROVE: OK] when the phase is done and you have nothing to decide or act on, or [DEV-PIPELINE | GATE <n> | AUTO-APPROVE: HOLD — <reason>] when you genuinely do (a real decision, a question, or a blocker). An informational caveat the agent just wants on the record — an environment/test quirk, an acceptable coverage gap, a coordination note — is NOT a HOLD: it stays OK and rides in the report body, so the run flows on instead of stopping you.
  • Gate 6 (the finish): [DEV-PIPELINE | GATE 6 | READY-TO-MERGE] once the branch is tagged ready, or [DEV-PIPELINE | GATE 6 | NOT-READY — <reason>] if it couldn't be.

It is the single line an automation reads to decide whether to advance a run for you: OK means "safe to approve", HOLD means "a human should look first". You never type these — they're for the machinery, and they ride below your plain-English gate report. The header's status dot agrees with this marker: 🟢 pairs with OK, 🟡 / 🔴 with HOLD. A gate that asks you a real question always carries HOLD, and even if an OK ever slipped through, the question-widget veto (above) still holds it for you. Custom/standards gate ids are drift-tolerant: the canonical form is GATE CUSTOM_<SLUG> (e.g. CUSTOM_STANDARDS_AUDIT), but if an agent drops the CUSTOM_ prefix Omniscio folds it back to canonical instead of stranding the run — the recognition widens, the safety proofs don't. Full rules: the repo's pipeline-auto-advance-contract.md (in .claude/memory/contracts/).

Bug-report runs and the one hold you can switch off

A pipeline run does not always start because you asked for it. A bug report can start one on its own — a Sentry error, a GitHub issue, an in-app report, an emailed bug, or a Help Desk ticket — and that run is working a report someone else wrote.

Such a run is held at every gate above the plan, whatever your per-gate switches say, so an outsider's report cannot reach your product master with no human in the loop. The Plan gate is unaffected (it answers to its own switch), and the hold is on for every install by default.

One setting lifts it: "Let bug-report runs use these gates too" — in the Dev Pipeline panel's Setup tab, and in Settings → Optional Features under the same gate list. It is off by default.

  • Off (the default): those runs stop at every gate for you. Nothing about your own runs changes.
  • On: they clear the same gates a run you started does, through the same switches — which also means a finished one can reach the ready tag and be landed for you. Switch it on only if that is what you want for work on other people's reports.
  • What still stops, either way: a gate that asks you a real question, reports a blocker, or carries a HOLD. Your Plan switch keeps deciding whether the plan gate clears itself.
  • Not from a phone. Like the per-gate switches beside it, this one is refused from a paired device; it is a desktop decision.

The full rules — what the switch may and may not reach, and the tests that hold it — are in the repo's pipeline-auto-advance-contract.md.

Resuming

The skill is re-entrant: if a run's state.md exists, invoking it again resumes from the recorded phase instead of restarting — after a mid-run compaction, or when you reply at a gate. Resume is owner-scoped, which is what makes it safe to run many pipelines at once: each run stamps its state.md with an owner id (inside Omniscio, the session's id), and a resuming agent picks up ONLY its own run — another agent's in-flight run is invisible to it and is never touched. The state lives in the run's worktree (<worktree>/.claude/pipeline/state.md) for a normal repo task, or in a private per-session dir (~/.claude/dev-pipeline-runs/<owner>/) when there's no repo to isolate in — so two agents working the same project never share one file.

  • Dev Pipeline — the end-to-end flow this page fills in the detail for.
  • Dev Pipeline panel — where every control and toggle for this workflow lives.
  • Dev Pipeline Maintenance — the housekeeping jobs that ride alongside it.

Last verified 2026-10-03