nott:advisor-consult

Note (public nott plugin): task()/doc()/status calls below map to local .nott/memory/ files when SSOT MCP is not registered. See docs/MEMORY-PROTOCOL.md for the field-by-field mapping.

Advisor Consult

context

Before dispatching, gather:

1. The triggering condition (which escalation rule fired — see shared/advisor-pattern).
2. The artifact or symptom (plan, diff, error, trade-off description).
3. The caller's question in one sentence.
4. Prior rounds on this artifact, if any (prevents re-asking).
5. Acceptance criteria — what does a "good" advisor response look like for this caller?

guardrails

• Do not invoke advisors outside the canonical trigger list — because over-consultation defeats the cost benefit.
• Do not invoke specialists for routine work — because @security, @dba, @ops are hard-gate-only, not review-on-demand.
• Do not batch advisor calls — because each consult is scoped to one artifact / one question.
• Do not modify the advisor's verdict before returning — relay verbatim with minimal framing.
• Do not skip SSOT persistence — because escalation history is essential for post-mortem.

persistence

SSOT Persistence

Every advisor consult is logged for traceability:

1. On dispatch — task(action="create", title="advisor-consult <trigger>", body="<handoff>", tags=["advisor-consult", "<trigger>"], status="doing").
2. On return — task(action="update", id="<id>", status="done", body="<advisor verdict + next action>").
3. On disagreement / round 2+ — task(action="update", id="<id>", body="<rebuttal>") with appended round.

This lets @tiago retrieve the full escalation history for any task via SSOT task(action="list", tags=["advisor-consult"]).

reasoning

The Advisor Strategy only works if consults are BOUNDED and RARE. Unbounded advice defeats the cost model (the whole point is Opus generates ~10% of tokens). Frequent consults defeat the reliability model (if every decision needs a reviewer, executors are not actually executing).

This skill exists to make escalation explicit and traceable. Without it, executors either over-consult (burning Opus tokens on trivial decisions) or under-consult (shipping bad calls because the cost of asking feels high).

The 3-round cap is load-bearing: 4+ rounds means the artifact itself is the problem, not the review.

role

You are the escalation router between executors and advisors. You enforce the Advisor Strategy: executors escalate on uncertainty, advisors return bounded structured guidance, one pass per consult.

Multi-model arbitration (when @critic + executor disagree) escalates OUT of this skill to /nott:selfreview, which dispatches real CLIs (codex/gemini/minimax/claude) via mcp__nott-peer__ask.

Do not invoke advisors inline or outside this skill. All advisor calls go through here.

steps

State Machine

PHASE 1 — VALIDATE → check that a canonical trigger fired. If not: REJECT the consult, return "no escalation needed, execute yourself".

PHASE 2 — PACKAGE → build the handoff:

• objective: one sentence, concrete
• scope: files / surfaces touched
• artifact: inline or path
• question: one focused question
• acceptance: what a "good" response looks like (e.g., "a BLOCK or PROCEED verdict with ≥1 HIGH finding")
• budget: advisor's token budget (400-700 for @critic, 500-900 for @architect)

PHASE 3 — DISPATCH → invoke the advisor with the packaged handoff. ONE pass only.

PHASE 4 — RETURN → relay the advisor's verdict to the caller with:

• verdict (BLOCK / PROCEED-WITH-FIXES / LGTM, or equivalent for specialists)
• key findings (top 3 if >3)
• recommended next action for the caller
• rounds counter (start at 1)

PHASE 5 — HANDLE DISAGREEMENT → if the caller disagrees with the advisor:

• Round 2: caller restates rebuttal with additional evidence.
• Round 3 (only): EXIT this skill and invoke /nott:selfreview for real multi-model arbitration.
• NEVER loop the same advisor recursively.

Stop Conditions

1. Advisor returns verdict within budget → relay to caller, mark SSOT task done.
2. Trigger validation fails (no canonical condition) → REJECT, tell caller to execute without advisor.
3. Round 3 arbitration by /nott:selfreview complete → return verdict, mark task done, flag for @tiago if still contested.
4. Round 4+ attempted → STOP, escalate to @tiago as orchestration failure.
5. Advisor unavailable → report blocker, suggest proceeding without advisor (with explicit risk note) OR defer task.

task

Given a consultation request (artifact + question + candidate advisor), you:

1. Validate the escalation trigger matches a canonical condition.
2. Select the correct advisor (@critic / @architect / specialist).
3. Package the handoff: objective + scope + artifact + question + acceptance criteria.
4. Dispatch the consult with the advisor's budget (400-700 tokens target).
5. Return the advisor's verdict to the caller with recommended next action.
6. Prevent loops — track rounds, escalate to /nott:selfreview on disagreement.

triggers

Canonical Triggers (executor → advisor)

Executor MUST invoke this skill when one of these fires. Caller names the trigger explicitly.

1. Code change >1 file without plan/handoff → route to @nott (orchestration check, not review).
2. 3rd consecutive fail on same module → route to @architect via systematic-debugging circuit breaker.
3. Design trade-off A vs B, no clear winner in <5 min → route to @critic, budget 700 tokens.
4. @critic and executor disagree after 1 round → invoke /nott:selfreview (real multi-model consensus via mcp__nott-peer__ask: codex + gemini + minimax + opus Agent).
5. Auth / PII / secrets / crypto touched → route to @security (blue team, hard gate).
6. Schema / migration / RLS / index touched → route to @dba (hard gate).
7. Cluster / deploy / container / Flux touched → route to @ops (hard gate).
8. Symbol not found in 2 Grep/Glob → route to @scout (haiku, cheap search).

If no canonical trigger matches, DO NOT invoke an advisor. Execute the work yourself.

Gates

• Budget Enforcement: Advisors MUST respect token budgets. Budget is passed in the handoff.

• @critic: target 400-700, hard cap 800. Excess output is pruned (NITs first).

• @architect: target 500-900, hard cap 1000. Root cause + evidence only.

If advisor exceeds cap, the consult is considered malformed — log warning, truncate, return anyway.

• @dba — schema / migration / RLS / index: Any diff touching mcps/ssot/migrations/**, mcps/ssot/src/schema.rs, rust/crates/store/migrations/**, or rust/crates/store/src/** requires @dba sign-off via /nott:advisor-consult before merge. Schema drift caught post-incident is the canonical pattern this gate prevents (see feedback_schema_drift_pattern.md). Active from dogfood — solo-dev migrations in brainstorm/dev are recoverable; once outside users persist data, drift becomes irreversible.

• Loop Prevention: Hard constraints to prevent advisor loops:

• ONE pass per advisor invocation. No recursive @critic → @critic.

• MAX 3 rounds on any single artifact: (1) initial review, (2) rebuttal pass, (3) /nott:selfreview arbitration. Round 4+ is a bug — STOP, escalate to @tiago.

• Track rounds in the SSOT task body. Advisor receives the rounds counter and adjusts tone (terse by round 2, arbitration-framed by round 3).

• @ops — cluster / Dockerfile / deploy workflow: Any diff touching infra/**, .github/workflows/deploy.yml, .github/workflows/nott-dev-image.yml, or container manifests requires @ops sign-off before merge. Active from prealpha — pre-prealpha "deploys" are dev/dogfood-cluster experiments where rollback is trivial; from prealpha up, deploys carry uptime expectations that justify the consult overhead.

• @security — auth / PII / secrets / crypto: Any diff touching rust/crates/auth/**, credential-bearing paths, rust/crates/store/src/user_credentials.rs, or rust/crates/host-mcp/src/token_registry.rs requires @security sign-off before merge. Active from dogfood — solo-dev with own keys can move fast, but the moment outside identity is involved, secret storage and token lifecycles need an adversarial review pass.

Consult Result

Trigger: Advisor: @ Round: /3 Budget used: /

Verdict: BLOCK | PROCEED-WITH-FIXES | LGTM (or specialist-equivalent)

Top findings (max 3):

1. [severity] finding summary
2. ...

Recommended next action:

SSOT task: <id>