@event4u/agent-config 9.0.0 → 9.2.0

package/dist/agent-src/commands/pr/create.md

@@ -140,6 +140,12 @@ completion is read from the checkbox counts.
 Run `/create-pr:description-only` Steps 1–4 to generate the PR title and body.
 This handles: Jira ticket extraction, diff analysis, commit messages, **PR template filling**.
 
+The generation honors the cached content flags from step 1 (§4e):
+`detail_level` sets the Description tier (default `min`), `api_examples`
+adds a grounded JSON block for API-endpoint changes, and `screenshots`
+(capability-gated) adds frontend screenshots. Critical-info callouts
+(breaking changes / migrations / security / rollback) appear at every tier.
+
 **CRITICAL**: The PR body MUST use the project's PR template (`.github/pull_request_template.md`).
 Read the template file and fill in its sections. If the template does not exist, use the
 fallback structure defined in `/create-pr:description-only`. NEVER invent a custom body structure.
@@ -316,11 +322,16 @@ an actual Jira API call succeeded** — never announce "skipped".
 
 #### 4e. Settings short-circuit — single read per run
 
-`verbosity.routine_confirmations`, `verbosity.post_action_reports`, and
-`commands.create_pr.preview_description` are read **once** at the top
-of the run and cached for the whole `/create-pr` invocation. Do **not**
-re-read `.agent-settings.yml` in 4b / 4d — both branches resolve from
-the cached values from step 1.
+`verbosity.routine_confirmations`, `verbosity.post_action_reports`,
+`commands.create_pr.preview_description`, `commands.create_pr.detail_level`,
+`commands.create_pr.api_examples`, `commands.create_pr.screenshots`,
+`commands.create_pr.ui_paths`, and `commands.create_pr.api_paths` are read
+**once** at the top of the run and cached for the whole `/create-pr`
+invocation. Do **not** re-read `.agent-settings.yml` in Step 2 or 4b / 4d —
+every branch resolves from the cached values from step 1. The content flags
+(`detail_level`, `api_examples`, `screenshots`, `ui_paths`, `api_paths`) are
+consumed by the `/create-pr:description-only` generation step (Step 2); the
+confirmation/report flags by steps 3–4.
 
 When all three resolve to their silent defaults (`false` / `minimal` /
 `false`), steps 4b + 4d collapse to the single `→ #N opened: <url>` line

package/dist/agent-src/commands/review/changes.md

@@ -130,6 +130,28 @@ If picked **1**:
 
 If picked **2** → continue with internal judges only.
 
+### 4c. Optional adversarial verification council (opt-in, high-risk)
+
+Read `subagents.adversarial_council` from `.agent-settings.yml` (default
+`off`):
+
+- `off` (default): skip silently.
+- `ask`: when the diff is explicitly high-risk (security, tenant, migration,
+  public API), offer it (in the user's language):
+
+  > 1. Run the adversarial verification council on this high-risk diff? (distinct-model skeptics red-team for finding coverage)
+  > 2. Skip — the five internal judges are enough
+
+- `on`: run it automatically on a high-risk diff.
+
+When run, dispatch the
+[`adversarial-verification-council`](../../skills/subagent-orchestration/SKILL.md)
+mode (Mode 9): distinct-model skeptics red-team the diff for defect FINDING
+coverage; the reconciled findings-by-severity envelope is folded into step 5 as
+an **advisory** input, clearly marked. Like the external council it **never
+auto-gates** — a human decides what is actionable. This is defect coverage, not
+a go/no-go verdict.
+
 ### 5. Consolidate
 
 Consolidate via [`judge-synthesis`](../../skills/judge-synthesis/SKILL.md) — the

package/dist/agent-src/contexts/execution/subagent-modes-detail.md

@@ -1,10 +1,11 @@
-# Subagent Modes — worktree + live-app-judge detail
+# Subagent Modes — worktree + live-app-judge + adversarial-council detail
 
-Extended detail for the two heaviest [`subagent-orchestration`](../../skills/subagent-orchestration/SKILL.md)
-modes — `do-in-worktrees` (mode 7) and `do-with-live-app-judge` (mode 8).
-Split out of the skill body to keep it under the size budget; the mode list,
-selection rules, and the six common modes stay inline in the skill. Pull this
-when you actually dispatch one of these two modes.
+Extended detail for the heaviest [`subagent-orchestration`](../../skills/subagent-orchestration/SKILL.md)
+modes — `do-in-worktrees` (mode 7), `do-with-live-app-judge` (mode 8), and
+`adversarial-verification-council` (mode 9). Split out of the skill body to keep
+it under the size budget; the mode list, selection rules, and the six common
+modes stay inline in the skill. Pull this when you actually dispatch one of these
+modes.
 
 ## Mode 7 — do-in-worktrees
 
@@ -82,3 +83,37 @@ Rules:
   mechanism for this mode's judge once dependable screenshot tooling lands.
   Recorded from road-to-opt-design-polish; gate it behind the same
   `verdict_changed_outcome` adoption evidence above.
+
+## Mode 9 — adversarial-verification-council (gated — opt-in, advisory)
+
+A panel of N (default 2) **distinct-model** skeptics red-teams a real,
+already-verified change through the `judge-*` lenses. Each skeptic is prompted to
+*break* the change, returns a structured findings array (+ optional refutations),
+and the returns are reconciled by
+[`_lib/adversarial_reconcile.ts`](../../../scripts/_lib/adversarial_reconcile.ts)
+into one [`adversarial-findings.json`](../../../skills/subagent-orchestration/schemas/adversarial-findings.json)
+envelope. Scope: defect **finding coverage**, not a go/no-go decision (that is
+mode 6). Full contract: ADR-122; skeptic prompt:
+[`prompts/adversarial-verification-council.md`](../../../skills/subagent-orchestration/prompts/adversarial-verification-council.md).
+
+| When to use | When not | Model pairing |
+|---|---|---|
+| High-risk change (security, tenant, migration, public API) where finding coverage matters, opted-in | Default flow, routine change, `subagents.adversarial_council: off`, or a plain go/no-go (use mode 6) | skeptics = ≥2 distinct models; cross-*vendor* for the registered claim + high-risk tier; cross-model Iron Law across all |
+
+Invariants:
+
+- **Advisory only — never auto-gates the change (Hard Floor).** The reconciler
+  ranks and annotates findings; a human decides what is actionable.
+- **Default-off.** `subagents.adversarial_council` (`off|ask|on`, default `off`).
+  Fires only on an explicit high-risk change under an opted-in setting.
+- **Cross-model Iron Law** across all skeptics; the registered finding-coverage
+  claim and the high-risk tier require cross-*vendor* skeptics (the backed
+  `cross-vendor-parity` signal is provider-level).
+- **Reconciliation is deterministic TS with tests** — dedup, severity-quorum
+  confidence, false-positive suppression (demote, never drop). Never
+  LLM-computed prose (ADR-122 anti-lesson).
+- **N cap** from the verify budget; no daemon / no persistent runtime; each
+  skeptic return uses the `subagent-status.json` envelope before reconciliation.
+- **Prove-or-drop.** The mode stays default-off until the
+  `adversarial-council-finding-coverage` claim is `backed` by the two-stage
+  residual-detection benchmark (roadmap Phase 4); honest-null keeps it inert.

package/dist/agent-src/contexts/execution/verify-budget.md

@@ -30,6 +30,20 @@ verification recorded as `none`, or a non-trivial change verified only
 deterministically, is a **gap** that is surfaced to the user — it never passes
 silently. This is the audit-visible enforcement of the Iron Law.
 
+## Opt-in escalation — adversarial verification council (default-off)
+
+For an explicitly high-risk change (security, tenant, migration, public API)
+AND `subagents.adversarial_council != off`, the verify step MAY escalate from a
+single cross-model judge to the **adversarial-verification-council** panel
+(subagent-orchestration Mode 9, ADR-122) — recorded as `verify_mode: council`.
+
+This escalation is **strictly opt-in and advisory**: it never fires when the
+setting is `off` (the default), and the panel finds defects but **never
+auto-gates the change** (Hard Floor). It replaces neither the deterministic
+floor nor the standard judge — it adds finding-coverage on top for changes where
+a single judge is too easy to fool. Stays default-off until the
+`adversarial-council-finding-coverage` claim is `backed` (prove-or-drop).
+
 ## Why this does not weaken the floor
 
 `deterministic` is still verification — a real diff + dry-run + structural
@@ -48,3 +62,4 @@ small to carry risk, where the deterministic check is sufficient evidence.
 - [`verify-before-complete`](../../rules/verify-before-complete.md) — the Iron Law this preserves.
 - [`subagent-orchestration`](../../skills/subagent-orchestration/SKILL.md) — the cross-model judge law.
 - [`orchestration-telemetry`](orchestration-telemetry.md) — where `verify_mode` is recorded.
+- [`subagent-response-contract`](subagent-response-contract.md) — a low-confidence mutating finding forces the full judge path (`forcesJudge`).

package/dist/agent-src/rules/cross-source-consistency.md

@@ -0,0 +1,92 @@
+---
+type: "auto"
+tier: "2a"
+description: "Two sources disagree (ticket text vs mockup, spec silent on a needed behavior, spec vs code) → surface + ask before proceeding, never silently guess"
+triggers:
+  - keyword: "ticket"
+  - keyword: "refine"
+  - keyword: "acceptance criteria"
+  - keyword: "AC"
+  - keyword: "mockup"
+  - keyword: "screenshot"
+  - keyword: "attachment"
+  - keyword: "roadmap"
+  - keyword: "estimate"
+  - phrase: "plan this ticket"
+  - phrase: "refine this ticket"
+  - phrase: "is this ticket clear"
+  - phrase: "implement the ticket"
+applies_to_user_types:
+  - "developer"
+  - "founder"
+  - "consultant"
+routes_to:
+  - "guideline:agent-infra/cross-source-consistency-mechanics"
+workspaces: [engineering, product]
+packs: [engineering-base, product-basic]
+---
+
+# Cross-Source Consistency
+
+When the agent works from **more than one source** — ticket text, an attached
+image / mockup / screenshot, the spec, the codebase — those sources can
+disagree. The failure this rule prevents: the agent notices (or should notice)
+the disagreement, picks one reading, and proceeds silently — **even when its
+pick is correct**. A good guess on a real contradiction still robs the user of
+the decision that was theirs to make.
+
+## The Iron Law
+
+```
+TWO PRESENT SOURCES DISAGREE → SURFACE THE DISCREPANCY AND ASK BEFORE PROCEEDING.
+A SILENT GUESS ON A REAL CONTRADICTION IS A VIOLATION — EVEN IF THE GUESS IS RIGHT.
+AN INFERRED-BUT-UNSPECIFIED BEHAVIOR IS A SCOPE EXPANSION: ASK, NEVER ADD IT SILENTLY.
+OBVIOUS-TO-THE-AGENT ≠ IN-SCOPE.
+```
+
+## What counts as a discrepancy
+
+- **(a) text ↔ image** — ticket text contradicts an attached mockup / screenshot / diagram (canonical case: text says "show birthdays **today**", the mockup shows a birthday from two days ago).
+- **(b) silent-but-needed** — the spec is silent on a behavior that is clearly required (a weekend/holiday shift, an empty state, an error path). Surface it and ask **before** implementing — do not expand scope on a plausible inference (canonical case: the spec specifies weekend-shifting only; the agent also adds public-holiday shifting without asking).
+- **(c) spec ↔ codebase/reality** — the spec contradicts what the code actually does or what a real source shows.
+- **(d) intra-ticket** — the acceptance criteria, description, and comments contradict each other.
+
+## When it fires — and when NOT
+
+**Fires** while planning, refining, estimating, roadmapping, or implementing from
+a ticket/spec that carries a second source (an attachment, a code reality, or an
+internal contradiction), gated by `consistency.cross_source` in
+`.agent-settings.yml` (`on` default · `auto` = high-confidence only · `off` = inert).
+
+**Does NOT fire** on a single clear source with no second source to compare
+against (that is plain vagueness — it belongs to `ask-when-uncertain`), on
+trivial edits, or when the user has already resolved the discrepancy this turn.
+
+## How to surface it (subordinate to the ask discipline)
+
+- **Subordinate to [`ask-when-uncertain`](ask-when-uncertain.md).** Fold the
+  discrepancy into the SAME turn's single question — batch all discrepancies for
+  one artefact into ONE numbered-options block. Never emit a second question
+  block; one-question-per-turn holds.
+- **Defer to [`scope-control`](scope-control.md)** as the permission authority
+  for the type-(b) silent-scope-expansion case.
+- **Precedes [`design-fidelity`](design-fidelity.md).** This rule fires first,
+  at decision time ("text says X, the mockup says Y — which wins?"); once the
+  user resolves it, `design-fidelity` governs build-time 1:1 fidelity.
+- **Pass the [`no-cheap-questions`](no-cheap-questions.md) Pre-Send Self-Check.**
+  Fire only on a genuine contradiction or silent-scope-expansion carrying a real
+  trade-off — never a content-free "are you sure?". Under an autonomous mandate a
+  detected discrepancy is a blocking decision and is NOT suppressed, but an
+  off-hand non-contradiction must not become a continuation prompt.
+
+The taxonomy, the scan procedure, the confidence-tiered noise control, worked
+examples, and the precedence table live in
+[`cross-source-consistency-mechanics`](../docs/guidelines/agent-infra/cross-source-consistency-mechanics.md).
+
+## See also
+
+- [`ask-when-uncertain`](ask-when-uncertain.md) — the one-question-per-turn ask discipline this folds into (missing info → ask; this adds conflicting present sources → ask).
+- [`scope-control`](scope-control.md) — the permission authority for the silent-scope-expansion (type b) case.
+- [`design-fidelity`](design-fidelity.md) — governs build-time fidelity once a text↔image conflict is resolved.
+- [`active-remediation`](active-remediation.md) — the never-silently-ignore ladder this rule mirrors for source discrepancies.
+- [`no-cheap-questions`](no-cheap-questions.md) — the floor the discrepancy ask must clear.

package/dist/agent-src/rules/delegation-policy.md

@@ -90,7 +90,7 @@ primitive → run in-session (clean no-op).
 
 ## See also
 
-- [`subagent-orchestration`](../skills/subagent-orchestration/SKILL.md) — the form gate + 8 modes this selects.
+- [`subagent-orchestration`](../skills/subagent-orchestration/SKILL.md) — the form gate + 9 modes this selects.
 - [`subagent-boundary`](../docs/contracts/subagent-boundary.md) — what a subagent owns vs never owns (task-meaning, memory, pack-surface, safety-floor bypass).
 - [`auto-orchestration-activation`](../contexts/execution/auto-orchestration-activation.md) — the gate.
 - [`reasoning-orchestrator`](../skills/reasoning-orchestrator/SKILL.md) — RDP dispatch, now gated here.

package/dist/agent-src/skills/estimate-ticket/SKILL.md

@@ -77,6 +77,8 @@ If the ticket scores low on estimability (vague AC, no out-of-scope,
 no mention of deps), set `uncertainty = Underspecified` and
 emit a single-line redirect to `/refine-ticket` at the top of the output.
 
+A **cross-source discrepancy** (per [`cross-source-consistency`](../../rules/cross-source-consistency.md), gated by `consistency.cross_source`) — ticket text contradicting an attached mockup, or a clearly-needed-but-unstated behavior (weekend/holiday shift) — is not estimable as-is: it hides an open scope decision. Raise `uncertainty` and name the discrepancy in the redirect rather than sizing over a contradiction.
+
 ### 3. Apply sizing heuristics
 
 Score across four axes; each axis contributes to the final size:

package/dist/agent-src/skills/feature-planning/SKILL.md

@@ -28,7 +28,7 @@ Do NOT use when:
 
 ## Procedure: Plan a feature
 
-1. **Gather requirements** — What problem does this solve? Who benefits? What's the expected outcome?
+1. **Gather requirements** — What problem does this solve? Who benefits? What's the expected outcome? Run a **cross-source discrepancy scan** (per [`cross-source-consistency`](../../rules/cross-source-consistency.md), gated by `consistency.cross_source`): where the source ticket carries text + an attachment/mockup, or leaves a clearly-needed behavior unstated (weekend/holiday shift, empty/error state, timezone), surface the conflict/gap as an *Open question* before drafting phases — an inferred behavior is a scope expansion to confirm, not to bake in. See [`cross-source-consistency-mechanics`](../../../docs/guidelines/agent-infra/cross-source-consistency-mechanics.md).
 2. **Analyze scope** — Which modules, routes, models, services are affected?
 3. **Write the plan** — Create a feature plan document (see template below).
 4. **Verify** — Confirm all affected areas are identified, no missing dependencies.

package/dist/agent-src/skills/llm-provider-knowledge/SKILL.md

@@ -0,0 +1,146 @@
+---
+model_tier: inherit
+name: llm-provider-knowledge
+description: "Before stating any specific fact about an LLM provider's product — models, pricing, limits, context windows, SDK/API — for OpenAI, Gemini, Claude & others, verify against official docs, not memory."
+source: package
+domain: process
+personas: []
+workspaces:
+  - agent-config-maintainer
+  - engineering
+  - product
+  - founder
+  - small-business
+  - gtm
+  - ops
+packs:
+  - meta
+trust:
+  level: experimental
+install:
+  removable: true
+execution:
+  type: manual
+---
+
+# llm-provider-knowledge
+
+Verify LLM-provider product facts against **official documentation**, never
+memory. This skill is the multi-provider sibling of Claude Code's bundled
+`product-self-knowledge` — extended to OpenAI, Google Gemini, Anthropic,
+Mistral, xAI, DeepSeek, Cohere, and Meta Llama, and portable to every host this
+package projects to (not just Claude Code).
+
+**This skill is a signpost, not a library.** It routes you to the authoritative
+source and forces a source-cited answer. It does **not** cache model IDs,
+context windows, prices, or rate limits — those churn constantly, and a cached
+copy is exactly the stale "from memory" answer this skill exists to prevent.
+
+## When to use
+
+- Your reply would state a specific fact about a provider's product: a model ID
+  or its context window, token pricing, a rate/quota limit, an SDK/API detail
+  (endpoint, parameter, auth, batch, streaming, function-calling shape), or a
+  consumer-app plan limit (ChatGPT/Gemini/Claude app tiers).
+- Coding against a provider SDK where a wrong model name, parameter, or limit
+  would break at runtime.
+- Content or comparisons that assert provider capabilities or pricing.
+- Any time you would otherwise answer such a fact from training data — it may be
+  outdated or wrong.
+
+## When NOT to fire
+
+- Ordinary SDK code that asserts **no** product fact (wiring a call whose model
+  and params the user already gave).
+- The user already supplied the verified fact — use it; don't re-litigate.
+- Writing provider-specific prompt grammar → `prompt-engineering-patterns`.
+- Choosing which model to use for the host → `model-recommendation` (never
+  recommend another vendor's model over the host's; this skill only reports
+  facts, it does not steer model choice).
+- Image-provider selection → `image-provider-routing`.
+
+## Core principles
+
+1. **Accuracy over guessing** — if unsure, route to the docs; never assert.
+2. **Distinguish products** — a provider's API, its developer platform, and its
+   consumer app are separate surfaces with separate facts and separate docs.
+3. **Source everything** — every product fact in the reply carries an official
+   URL. No URL → not verified → don't state it as fact.
+4. **Route, don't cache** — hand off to the live docs; do not transcribe
+   volatile specs into the reply as if durable.
+
+## Provider routing table
+
+Route to the **stable root** and read live from there — do not deep-link to
+pages that churn. Prefer a provider's machine-readable index where one exists.
+
+| Provider | Docs root | API reference | Product / support |
+|---|---|---|---|
+| **OpenAI** (GPT) | `platform.openai.com/docs` | `platform.openai.com/docs/api-reference` | `help.openai.com` |
+| **Google Gemini** | `ai.google.dev/gemini-api/docs` | `ai.google.dev/api` | `support.google.com` (Gemini app) |
+| **Anthropic** (Claude) | `docs.claude.com/en/docs` (index: `/en/docs_site_map.md`) | `docs.claude.com/en/api/overview` | `support.claude.com` |
+| **Mistral** | `docs.mistral.ai` | `docs.mistral.ai/api` | `help.mistral.ai` |
+| **xAI** (Grok) | `docs.x.ai` | `docs.x.ai/developers` | `x.ai` |
+| **DeepSeek** | `api-docs.deepseek.com` | `api-docs.deepseek.com/api` | `platform.deepseek.com` |
+| **Cohere** | `docs.cohere.com` (index: `docs.cohere.com/llms.txt`) | `docs.cohere.com/reference` | `dashboard.cohere.com` |
+| **Meta Llama** | `llama.com` (dev docs: `ai.developer.meta.com/docs`) | `ai.developer.meta.com/docs` | `llama.com` |
+
+**Claude Code specifics** (install, Node.js requirement, MCP, config):
+`docs.anthropic.com/en/docs/claude-code/claude_code_docs_map.md`.
+
+**Hosted access** (not a distinct vendor): Azure OpenAI, AWS Bedrock, and
+Google Vertex AI resell the underlying vendor's models. Route to BOTH the
+underlying vendor's row above AND the cloud's own docs (`learn.microsoft.com`,
+`docs.aws.amazon.com/bedrock`, `cloud.google.com/vertex-ai`) — model IDs,
+quotas, and regions differ from the vendor's direct API.
+
+## Procedure
+
+1. **Identify the provider and the surface** — API / developer platform /
+   consumer app. A ChatGPT-Plus limit is not an OpenAI-API rate limit.
+2. **Pick the row + column** from the table; go to the stable root.
+3. **Read the live docs** for the exact fact (navigate from the root; follow
+   the provider's own index / `llms.txt` where present).
+4. **State the fact with its source URL.** If the docs can't be reached or are
+   ambiguous, say so and point the user at the root rather than guessing.
+5. **Never transcribe a volatile spec as durable** — frame it as "per <URL> as
+   of now"; the source is authoritative, the reply is a pointer.
+
+## Output format
+
+Every reply that states a provider product fact MUST include:
+
+1. **The fact, scoped to the product surface** — name the provider AND which
+   surface (API / platform / consumer app) it applies to.
+2. **The official source URL** — the specific docs page the fact came from (or
+   the stable root when you're directing the user to read it themselves).
+3. **A freshness caveat when the fact is volatile** (pricing, limits, model
+   availability): "verify at <URL> — these change without notice."
+
+## Do NOT
+
+- **Do NOT** state a model ID, context window, price, or rate limit from
+  memory — route to the docs and cite the URL, or say you're unsure.
+- **Do NOT** transcribe a volatile spec (pricing, limits, model availability)
+  into the reply as if durable — frame it as "per <URL> as of now".
+- **Do NOT** conflate a provider's API with its consumer app — they carry
+  different limits and different docs.
+- **Do NOT** steer the user to another vendor's model over the host's — that is
+  `model-recommendation`; this skill reports facts neutrally.
+- **Do NOT** cache a provider's docs into this skill. When a root URL moves,
+  fix the one table row; a mismatch a user reports is a signal to correct the
+  row, never to start transcribing pages here.
+
+## Gotcha
+
+- **Provider docs URLs churn** (Meta's Llama dev-docs host redirected during
+  this skill's authoring). That is *why* the skill links to stable roots and
+  reads live — a deep-linked page memorised here would rot. If a root itself
+  moves, fix the one table row; never start caching pages to compensate.
+- **Do not conflate surfaces.** "Gemini" the app and the Gemini API have
+  different limits and different docs; the same for ChatGPT vs the OpenAI API
+  and Claude.ai vs the Claude API.
+- **Redundant with the harness on Claude Code.** Claude Code's own
+  `product-self-knowledge` also fires for Anthropic facts — both route to the
+  same Anthropic docs, so the overlap is harmless. On every other host this is
+  the only such skill.

package/dist/agent-src/skills/llm-provider-knowledge/evals/triggers.json

@@ -0,0 +1,20 @@
+{
+  "skill": "llm-provider-knowledge",
+  "last_eval": "2026-07-14",
+  "description": "7 should-trigger + 6 should-not-trigger. Should-trigger covers specific product-fact claims (context window, pricing, rate limit, API detail, model spec, consumer-app plan limit) across OpenAI, Google, Anthropic, Mistral, DeepSeek, Cohere. Should-not-trigger covers near-misses: SDK wiring with a user-supplied model, prompt authoring (prompt-engineering-patterns), model choice for the host (model-recommendation), image-provider selection (image-provider-routing), a user-supplied fact, and a plain SDK refactor.",
+  "queries": [
+    {"q": "what's the context window of GPT-5?", "trigger": true},
+    {"q": "how much does Gemini 2.5 Pro cost per million input tokens?", "trigger": true},
+    {"q": "what are the rate limits on the Anthropic API for tier 1?", "trigger": true},
+    {"q": "does the Mistral API support function calling, and what parameter enables it?", "trigger": true},
+    {"q": "what's the max output length for DeepSeek's chat model?", "trigger": true},
+    {"q": "how many messages does ChatGPT Plus allow in the app per window?", "trigger": true},
+    {"q": "what embedding dimension does Cohere's embed model return?", "trigger": true},
+    {"q": "wire up an openai chat completions call using the model id I already gave you", "trigger": false, "note": "SDK wiring; user supplied the model — no unverified product fact asserted"},
+    {"q": "write a good prompt to make Gemini summarize this document", "trigger": false, "note": "prompt authoring → prompt-engineering-patterns"},
+    {"q": "which model should I use for this task on my current host?", "trigger": false, "note": "model choice → model-recommendation (never steer to another vendor)"},
+    {"q": "route this logo-with-text image to the right generation provider", "trigger": false, "note": "image-provider selection → image-provider-routing"},
+    {"q": "I already know Claude Sonnet has a 200k context window — just use that number", "trigger": false, "note": "user supplied the verified fact; use it, do not re-litigate"},
+    {"q": "refactor this function that calls the Anthropic SDK to add retries", "trigger": false, "note": "plain code refactor; asserts no product fact"}
+  ]
+}

package/dist/agent-src/skills/po-discovery/SKILL.md

@@ -81,6 +81,8 @@ not name an implementation**. Use Given / When / Then or a numbered
 list. Reject ACs that hide assumptions ("works correctly", "is fast
 enough") — replace with measurable thresholds or strike them.
 
+**Cross-source discrepancy scan** (per [`cross-source-consistency`](../../rules/cross-source-consistency.md), gated by `consistency.cross_source`): when the raw input includes a screenshot / mockup alongside the story text, check the sources against each other and surface any conflict as a `gap` / open question — never resolve it silently. Watch for: story text contradicting an attached screenshot; the AC contradicting the description; a clearly-needed behavior the input never states (weekend/holiday shift, empty/error state). Batch them into one clarifying question. Taxonomy: [`cross-source-consistency-mechanics`](../../../docs/guidelines/agent-infra/cross-source-consistency-mechanics.md).
+
 ### 5. Surface non-functional gaps
 
 Flag anything missing that downstream skills will need: success

package/dist/agent-src/skills/refine-ticket/SKILL.md

@@ -138,6 +138,13 @@ Check the loaded ticket for clarity signals before orchestrating:
 - Is the scope one feature, or multiple tangled together?
 - Any sentence that references an existing module name, feature flag, or domain concept?
 
+**Cross-source discrepancy scan** (per [`cross-source-consistency`](../../rules/cross-source-consistency.md), gated by `consistency.cross_source`): the ticket is rarely a single source. Compare every source against the others and surface any conflict as an *Open question* — never resolve it silently:
+- **text ↔ attachment** — does the ticket text agree with every attached mockup / screenshot / diagram? (Canonical miss: text says "birthdays **today**", the mockup shows a birthday from two days ago.) If an attachment cannot be read, say so — do not assume it agrees.
+- **silent-but-needed** — is the spec silent on a clearly-needed behavior (weekend/holiday shift, empty state, error path, timezone, permissions)? Surface it and ask before it becomes an implementation assumption — an inferred behavior is a scope expansion, not a given.
+- **intra-ticket** — do the AC, description, and comments contradict each other?
+
+Fold every discrepancy into the refined output's *Open questions* section (one batched list), never a second prompt. Full taxonomy + scan procedure: [`cross-source-consistency-mechanics`](../../../docs/guidelines/agent-infra/cross-source-consistency-mechanics.md).
+
 Then run the deterministic detection helper — do **not** re-derive trigger
 logic in prose:
 

package/dist/agent-src/skills/roadmap-writing/SKILL.md

@@ -82,6 +82,20 @@ Vague goals ("improve roadmaps") force every reader to re-derive
 intent. If the goal needs three sentences, the roadmap is two
 roadmaps.
 
+### 3b. Scan sources for discrepancies before drafting phases
+
+When the roadmap originates from a ticket/spec that carries a second
+source — an attached mockup/screenshot, a code reality, or an internal
+contradiction — run the **cross-source discrepancy scan** (per
+[`cross-source-consistency`](../../rules/cross-source-consistency.md),
+gated by `consistency.cross_source`) before writing phases. A phase plan
+built over a text↔image contradiction or a silent-but-needed behavior
+(weekend/holiday shift, empty/error state) bakes the wrong assumption into
+every downstream step. Surface each discrepancy as one batched open
+question first; an inferred behavior is a scope expansion to confirm, not
+to plan silently. Taxonomy + procedure:
+[`cross-source-consistency-mechanics`](../../../docs/guidelines/agent-infra/cross-source-consistency-mechanics.md).
+
 ### 4. Phase blocks carry checkboxes
 
 Every non-intro phase contains at least one `- [ ]`. Decision tables

package/dist/agent-src/skills/subagent-orchestration/SKILL.md

@@ -1,7 +1,7 @@
 ---
 model_tier: inherit
 name: subagent-orchestration
-description: "Use when orchestrating implementer/judge subagents — form gate + eight modes (do-and-judge ±two-stage, steps/parallel/worktrees, competitively, debate, live-app-judge)."
+description: "Use when orchestrating implementer/judge subagents — form gate + nine modes (do-and-judge ±two-stage, steps/parallel/worktrees, competitively, debate, live-app-judge, adversarial-council)."
 domain: process
 workspaces:
   - agent-config-maintainer
@@ -108,6 +108,7 @@ no learned routing, no self-modifying selector (rejected, stays rejected).
 | Multi-step cross-wing chain needing filesystem isolation | worktrees | `do-in-worktrees` |
 | Ordered steps with declared dependencies | steps | `do-in-steps` |
 | Single change with non-trivial risk / contested spec / decision | judge | `do-and-judge`, `do-and-judge-two-stage`, `judge-with-debate`, `do-with-live-app-judge` |
+| High-risk change needing defect-FINDING coverage (opt-in, advisory) | verify-council | `adversarial-verification-council` (default-off; `subagents.adversarial_council`) |
 | Single slice below the delegability floor, unstructured, or frontier-priced | none | no dispatch — run in-session |
 
 Rules:
@@ -121,7 +122,7 @@ Rules:
   or `none`) so the gate's value is measurable inside the ADR-117
   prove-or-drop window.
 
-## The eight modes
+## The nine modes
 
 Each mode has a decision row: when to use, when not, and the expected
 model pairing. Defaults come from
@@ -211,6 +212,9 @@ migration, public API) where a single judge is too easy to fool.
 |---|---|---|
 | Security, data integrity, public API change | Routine internal refactor | judges = same tier (2x); meta-judge = one tier up |
 
+Mode 6 = **go/no-go** (strict-er verdict wins); for defect-FINDING coverage (the
+*union* of what diverse models catch) use Mode 9.
+
 ### 7. do-in-worktrees
 
 Cross-wing or cross-skill chain executed across isolated git worktrees —
@@ -231,6 +235,22 @@ Experimental until `verdict_changed_outcome` telemetry proves it. Rubric,
 adoption gate, and the async-verifier future candidate →
 [`subagent-modes-detail`](../../agent-src/contexts/execution/subagent-modes-detail.md) § Mode 8.
 
+### 9. adversarial-verification-council (gated — opt-in, advisory)
+
+A panel of N (default 2) **distinct-model** skeptics red-teams a real,
+already-verified change through the `judge-*` lenses — each prompted to *break*
+it. Returns reconcile deterministically
+([`_lib/adversarial_reconcile.ts`](../../scripts/_lib/adversarial_reconcile.ts))
+into one findings-by-severity envelope with provenance + cross-model confidence
+([`schemas/adversarial-findings.json`](schemas/adversarial-findings.json)). Unlike
+Mode 6 it emits a **findings-union**, not a go/no-go verdict. **Advisory only —
+never auto-gates (Hard Floor).** Default-off (`subagents.adversarial_council`);
+opt-in high-risk changes only; registered claim + high-risk tier need
+cross-*vendor* skeptics. Invariants, skeptic prompt, reconciliation, prove-or-drop
+gate → [`subagent-modes-detail`](../../agent-src/contexts/execution/subagent-modes-detail.md) § Mode 9
++ [`prompts/adversarial-verification-council.md`](prompts/adversarial-verification-council.md)
+(ADR-122).
+
 ## Status taxonomy — every subagent return uses one envelope
 
 Every implementer or judge return must conform to
@@ -265,7 +285,7 @@ Each mode's literal dispatch template lives under
 matching prompt at dispatch time and substitutes `{{placeholders}}`.
 Edits to a prompt do not bloat this skill against the 400-line sunset
 trigger; `tests/test_subagent_prompt_loading.py` confirms each of the
-eight modes resolves to a loadable prompt that cites all four taxonomy
+nine modes resolves to a loadable prompt that cites all four taxonomy
 statuses.
 
 ## Procedure
@@ -294,7 +314,7 @@ same context, **stop** and report. Do not improvise.
 
 ### 3. Pick the mode
 
-Run the form gate first, then match task shape to one of the eight modes. When two modes could fit,
+Run the form gate first, then match task shape to one of the nine modes. When two modes could fit,
 prefer the cheaper one (`do-and-judge` < `do-and-judge-two-stage` <
 `do-in-steps` < `do-in-parallel` < `do-competitively` <
 `judge-with-debate` < `do-in-worktrees`).
@@ -320,6 +340,7 @@ Describe each dispatch step explicitly in chat so the user can follow it.
 * `do-competitively` → [`prompts/do-competitively.md`](prompts/do-competitively.md)
 * `judge-with-debate` → [`prompts/judge-with-debate.md`](prompts/judge-with-debate.md)
 * `do-in-worktrees` → [`prompts/do-in-worktrees.md`](prompts/do-in-worktrees.md)
+* `adversarial-verification-council` → [`prompts/adversarial-verification-council.md`](prompts/adversarial-verification-council.md)
 * Standalone judge → judge prompt in [`prompts/do-and-judge.md`](prompts/do-and-judge.md)
 
 ### 5. Report
@@ -360,7 +381,7 @@ Skip emit when `subagents.enabled: false` or `spawn_count == 0` (in-session run)
 
 ## Output format
 
-1. **Mode chosen** — one of the seven, with the one-line reason
+1. **Mode chosen** — one of the nine, with the one-line reason
 2. **Model pairing** — implementer model / judge model (resolved)
 3. **Verdict** — applied / revised / handed back
 4. **Evidence** — diff summary, test output, or judge transcript

package/dist/agent-src/skills/subagent-orchestration/evals/evals.json

@@ -37,6 +37,24 @@
                     "criterion": "Negative control: the clean return is verified and adopted WITHOUT rework or escalation — telemetry records first_pass_success=true and escalated=false. No spurious findings are invented to justify a re-dispatch."
                 }
             ]
+        },
+        {
+            "id": "sao-adversarial-council-advisory-no-gate",
+            "prompt": "`subagents.adversarial_council: on`. You are orchestrating an adversarial-verification-council (Mode 9) over a high-risk, already-verified change to an auth endpoint. Two distinct-model skeptics return findings: skeptic A raises a critical missing tenant-scope check at `src/http/orders.ts:42` (category security) and a low naming nit; skeptic B independently raises the same tenant-scope issue and refutes the naming nit. Reconcile and report the council result.",
+            "assertions": [
+                {
+                    "kind": "contains",
+                    "value": "advisory"
+                },
+                {
+                    "kind": "rubric",
+                    "criterion": "The reconciled output is a findings-by-severity envelope (findings-union), NOT a single go/no-go verdict: the tenant-scope finding is corroborated (raised_by both skeptics → high confidence), and the naming nit raised by only A and refuted by B is demoted to false_positives_suppressed (not silently dropped)."
+                },
+                {
+                    "kind": "rubric",
+                    "criterion": "The council is treated as ADVISORY and NEVER auto-gates the change (Hard Floor): the orchestrator surfaces the findings for a human decision and does not itself accept/reject/merge or block the change based on the panel verdict."
+                }
+            ]
         }
     ]
 }