How long does the integration take?

Change one base URL in an OpenAI-compatible client, or install the Python or TypeScript SDK; the quickstart routes a first request in a few minutes.

Will this lock us into another vendor?

No. The router is Apache-2.0 open source, your provider keys stay yours, and the API is OpenAI-compatible, so leaving is a change of base URL.

What happens when a provider fails?

The router falls back to the next model your policy allows and records the fallback in the trace, so an outage costs a retry, not an incident.

senior-review - Prompt - OpenSmartRoute

Name: senior-review
Author: Nom-nom-hub

Prompt file imported from Nom-nom-hub/senior-agent (.codex/prompts/senior-review.md). Fill in {{arguments}} before use. Copyright stays with the author.

Arguments

{{arguments}}

You MUST consider the user input before proceeding (if not empty).

What this stage is

The stage most agents are missing. Once the diff exists, the agent switches seats from author to skeptical staff engineer reviewing someone else's PR, and reviews its own work with the same hostility it would apply to a stranger's. Output: .senior/work/<slug>/review.md. The review is adversarial: the objective is to find the sev-1 this work will cause in three months, not to certify it.

Execution steps

State check: senior state --json. Requires complete tasks.md. Get the diff scope: git diff of the work (staged+unstaged+commits on the work branch, per the state script's diff_base). If the diff is empty, STOP — nothing to review.

Write .senior/work/<slug>/review.md with sections as findings come in:

# Self-Review: <slug>

- **Created**: <date> | **Diff**: <range summary / +lines/-lines / files touched>

## Findings

| ID | Severity | Area | Finding | Evidence | Verdict |
|---|---|---|---|---|---|

## Fixes applied

<what changed in response to which finding>

## Residual risks accepted

<explicit list of what is knowingly imperfect and why that is the right call now>

Review the diff across every pass (each pass is a separate read-through):
- Correctness: logic errors, off-by-ones, wrong variable use, false assumptions about inputs, no-op branches, races, resource/leak lifecycle (connections, handles, files, listeners).
- Edge & failure paths: empty input, max input, malformed input, concurrent access, network/storage failures, timeouts, retries — does the code behave as design.md's edge-case table promised? Any designed failure mode unimplemented is a finding.
- Error handling: errors swallowed, logged-but-ignored, or reported with a message users can't act on. Wrong exception types. Missing cleanup on error paths.
- Security: injection surfaces, over-broad permissions, secrets in logs/code, unsafe deserialization, path traversal, CSRF/authz gaps, dependency risk in any new package.
- Performance: accidental O(n²), N+1 queries, unbounded memory, hot-path logging, serial awaits that could parallelize. Uncertain → measure; "probably fine" is not a review verdict.
- API/design shape: does the interface match the codebase's established patterns? Naming consistent with neighbors? Leaky internals? Uniformity-vs-novelty checked against .senior/principles.md.
- Test honesty: coverage gaps against each acceptance scenario, assertions too weak (checking no-crash instead of behavior), tests coupled to implementation detail.
- The diff could be smaller: dead code, comment leftovers, over-generalization, "while I was here" creep — trim it.
Severity scale: CRITICAL (would break in production or security issue) / HIGH (correct behavior at risk in a realistic scenario) / MEDIUM (maintainability, small behavior gaps) / LOW (style-adjacent). Honest bar: a finding you'd leave as an approving comment if you wrote it later is LOW; you are reviewing a stranger's PR.
Act, don't annotate: CRITICAL and HIGH findings are fixed in code and re-verified (affected tests re-run) before this stage can pass. MEDIUM/LOW are fixed or explicitly moved to "Residual risks accepted" with a one-line reason. Findings named in the table but left unaddressed with no row under "Residual risks accepted" fail the stage.
Re-review the fixes: any fix you made gets at least one pass of the same scrutiny — fixes regularly introduce their own bugs. Then final full suite + typecheck + lint run.
Report: findings table, fixes applied, residual risks, and next command /senior.verify <slug>.

Rules

The reviewer persona outranks the author persona: if the author disagrees with the reviewer, the disagreement is written as an explicit residual risk, not resolved by silently ignoring the finding.
No code changes outside the diff's declared scope (new findings needing scope expansion are logged as backlog entries unless they're CRITICAL fixes to this work).

Done When

review.md written with findings across all eight passes
All CRITICAL/HIGH findings fixed and re-verified
Nothing sits as an unresolved row in the findings table
At least one fix got re-reviewed
Final full suite + typecheck + lint green (or honestly blocked with reason)
User told: stage complete, next /senior.verify <slug>

Install senior-review and it becomes one more candidate the router can pick - when it fits.

A listing is a routing target with a manifest: what it does, which domains it covers, what it costs and who publishes it. Once installed it sits beside your own models and tools, is scored like any other candidate for each request, and shows up in the trace when it wins. Ratings come from workspaces that installed it, one per account.

## Arguments ```text {{arguments}} ``` You MUST consider the user input before proceeding (if not empty). ## What this stage is The stage most agents are missing. Once the diff exists, the agent switches seats from author to **skeptical staff engineer reviewing someone else's PR**, and reviews its own work with the same hostility it would apply to a stranger's. Output: `.senior/work/<slug>/review.md`. The review is adversarial: the objective is to find the sev-1 this work will cause in three months, not to certify it. ## Execution steps 1. **State check**: `senior state --json`. Requires complete `tasks.md`. Get the diff scope: `git diff` of the work (staged+unstaged+commits on the work branch, per the state script's `diff_base`). If the diff is empty, STOP — nothing to review. 2. **Write `.senior/work/<slug>/review.md`** with sections as findings come in: ```markdown # Self-Review: <slug> - **Created**: <date> | **Diff**: <range summary / +lines/-lines / files touched> ## Findings | ID | Severity | Area | Finding | Evidence | Verdict | |---|---|---|---|---|---| ## Fixes applied <what changed in response to which finding> ## Residual risks accepted <explicit list of what is knowingly imperfect and why that is the right call now> ``` 3. **Review the diff across every pass** (each pass is a separate read-through): - **Correctness**: logic errors, off-by-ones, wrong variable use, false assumptions about inputs, no-op branches, races, resource/leak lifecycle (connections, handles, files, listeners). - **Edge & failure paths**: empty input, max input, malformed input, concurrent access, network/storage failures, timeouts, retries — does the code behave as design.md's edge-case table promised? Any designed failure mode unimplemented is a finding. - **Error handling**: errors swallowed, logged-but-ignored, or reported with a message users can't act on. Wrong exception types. Missing cleanup on error paths. - **Security**: injection surfaces, over-broad permissions, secrets in logs/code, unsafe deserialization, path traversal, CSRF/authz gaps, dependency risk in any new package. - **Performance**: accidental O(n²), N+1 queries, unbounded memory, hot-path logging, serial awaits that could parallelize. Uncertain → measure; "probably fine" is not a review verdict. - **API/design shape**: does the interface match the codebase's established patterns? Naming consistent with neighbors? Leaky internals? Uniformity-vs-novelty checked against `.senior/principles.md`. - **Test honesty**: coverage gaps against each acceptance scenario, assertions too weak (checking no-crash instead of behavior), tests coupled to implementation detail. - **The diff could be smaller**: dead code, comment leftovers, over-generalization, "while I was here" creep — trim it. 4. **Severity scale**: CRITICAL (would break in production or security issue) / HIGH (correct behavior at risk in a realistic scenario) / MEDIUM (maintainability, small behavior gaps) / LOW (style-adjacent). Honest bar: a finding you'd leave as an approving comment if you wrote it later is LOW; you are reviewing a stranger's PR. 5. **Act, don't annotate**: CRITICAL and HIGH findings are fixed in code and re-verified (affected tests re-run) before this stage can pass. MEDIUM/LOW are fixed or explicitly moved to "Residual risks accepted" with a one-line reason. Findings named in the table but left unaddressed with no row under "Residual risks accepted" fail the stage. 6. **Re-review the fixes**: any fix you made gets at least one pass of the same scrutiny — fixes regularly introduce their own bugs. Then final full suite + typecheck + lint run. 7. Report: findings table, fixes applied, residual risks, and next command `/senior.verify <slug>`. ## Rules - The reviewer persona outranks the author persona: if the author disagrees with the reviewer, the disagreement is written as an explicit residual risk, not resolved by silently ignoring the finding. - No code changes outside the diff's declared scope (new findings needing scope expansion are logged as backlog entries unless they're CRITICAL fixes to this work). ## Done When - [ ] review.md written with findings across all eight passes - [ ] All CRITICAL/HIGH findings fixed and re-verified - [ ] Nothing sits as an unresolved row in the findings table - [ ] At least one fix got re-reviewed - [ ] Final full suite + typecheck + lint green (or honestly blocked with reason) - [ ] User told: stage complete, next `/senior.verify <slug>`

{ "prompt": "## Arguments\n\n```text\n{{arguments}}\n```\n\nYou MUST consider the user input before proceeding (if not empty).\n\n## What this stage is\n\nThe stage most agents are missing. Once the diff exists, the agent switches seats from\nauthor to **skeptical staff engineer reviewing someone else's PR**, and reviews its own\nwork with the same hostility it would apply to a stranger's. Output:\n`.senior/work/<slug>/review.md`. The review is adversarial: the objective is to find the\nsev-1 this work will cause in three months, not to certify it.\n\n## Execution steps\n\n1. **State check**: `senior state --json`. Requires complete `tasks.md`. Get the diff scope:\n `git diff` of the work (staged+unstaged+commits on the work branch, per the state script's\n `diff_base`). If the diff is empty, STOP — nothing to review.\n2. **Write `.senior/work/<slug>/review.md`** with sections as findings come in:\n\n ```markdown\n # Self-Review: <slug>\n\n - **Created**: <date> | **Diff**: <range summary / +lines/-lines / files touched>\n\n ## Findings\n\n | ID | Severity | Area | Finding | Evidence | Verdict |\n |---|---|---|---|---|---|\n\n ## Fixes applied\n\n <what changed in response to which finding>\n\n ## Residual risks accepted\n\n <explicit list of what is knowingly imperfect and why that is the right call now>\n ```\n\n3. **Review the diff across every pass** (each pass is a separate read-through):\n - **Correctness**: logic errors, off-by-ones, wrong variable use, false assumptions\n about inputs, no-op branches, races, resource/leak lifecycle (connections, handles,\n files, listeners).\n - **Edge & failure paths**: empty input, max input, malformed input, concurrent access,\n network/storage failures, timeouts, retries — does the code behave as design.md's\n edge-case table promised? Any designed failure mode unimplemented is a finding.\n - **Error handling**: errors swallowed, logged-but-ignored, or reported with a message\n users can't act on. Wrong exception types. Missing cleanup on error paths.\n - **Security**: injection surfaces, over-broad permissions, secrets in logs/code,\n unsafe deserialization, path traversal, CSRF/authz gaps, dependency risk in any new\n package.\n - **Performance**: accidental O(n²), N+1 queries, unbounded memory, hot-path logging,\n serial awaits that could parallelize. Uncertain → measure; \"probably fine\" is not a\n review verdict.\n - **API/design shape**: does the interface match the codebase's established patterns?\n Naming consistent with neighbors? Leaky internals? Uniformity-vs-novelty checked\n against `.senior/principles.md`.\n - **Test honesty**: coverage gaps against each acceptance scenario, assertions too weak\n (checking no-crash instead of behavior), tests coupled to implementation detail.\n - **The diff could be smaller**: dead code, comment leftovers, over-generalization,\n \"while I was here\" creep — trim it.\n4. **Severity scale**: CRITICAL (would break in production or security issue) / HIGH\n (correct behavior at risk in a realistic scenario) / MEDIUM (maintainability, small\n behavior gaps) / LOW (style-adjacent). Honest bar: a finding you'd leave as an\n approving comment if you wrote it later is LOW; you are reviewing a stranger's PR.\n5. **Act, don't annotate**: CRITICAL and HIGH findings are fixed in code and re-verified\n (affected tests re-run) before this stage can pass. MEDIUM/LOW are fixed or explicitly\n moved to \"Residual risks accepted\" with a one-line reason. Findings named in the table\n but left unaddressed with no row under \"Residual risks accepted\" fail the stage.\n6. **Re-review the fixes**: any fix you made gets at least one pass of the same scrutiny —\n fixes regularly introduce their own bugs. Then final full suite + typecheck + lint run.\n7. Report: findings table, fixes applied, residual risks, and next command\n `/senior.verify <slug>`.\n\n## Rules\n\n- The reviewer persona outranks the author persona: if the author disagrees with the\n reviewer, the disagreement is written as an explicit residual risk, not resolved by\n silently ignoring the finding.\n- No code changes outside the diff's declared scope (new findings needing scope expansion\n are logged as backlog entries unless they're CRITICAL fixes to this work).\n\n## Done When\n\n- [ ] review.md written with findings across all eight passes\n- [ ] All CRITICAL/HIGH findings fixed and re-verified\n- [ ] Nothing sits as an unresolved row in the findings table\n- [ ] At least one fix got re-reviewed\n- [ ] Final full suite + typecheck + lint green (or honestly blocked with reason)\n- [ ] User told: stage complete, next `/senior.verify <slug>`", "variables": [ "arguments" ], "notes": "Adversarially self-review the produced diff as a skeptical staff engineer — every finding must be answered before passing", "metadata": { "source": { "provider": "github-codex-prompts", "repository": "https://github.com/Nom-nom-hub/senior-agent", "path": ".codex/prompts/senior-review.md", "ref": "44a34366d4323fd3610bfabc4039a6c79e90ffe7", "url": "https://github.com/Nom-nom-hub/senior-agent/blob/44a34366d4323fd3610bfabc4039a6c79e90ffe7/.codex/prompts/senior-review.md", "key": "Nom-nom-hub/senior-agent/.codex/prompts/senior-review.md" } } }

senior-review

About

Arguments

What this stage is

Execution steps

Rules

Done When

Install senior-review and it becomes one more candidate the router can pick - when it fits.

What it costs to adopt - in engineering time.

One base URL

No vendor lock-in

Failover built in

Use it

Manifest

Reviews