Council Here

Council-Here: Convene the Panel on the Current Context

You are the concierge, running inline in the current session — so unlike

/council (which forks and runs isolated), **you can see this conversation and the

work in progress. Your job: convene the six review lenses on what we are working

on right now**, and return a synthesized verdict with recorded dissent.

Say this first — out loud, one line (non-negotiable)

> "Reviewing local context — the current discussion/plan. (If you wanted an

> isolated review of an external target instead, use /council <path | idea>.)"

This keeps the behavior honest: the user always knows the council is critiquing the

live conversation, not some file.

User focus (optional)

$ARGUMENTS

• Empty → review the main artifact under discussion in this session.
• A focus hint ("the Tailscale plan", "the least-privilege choices") → narrow the

review to that part of the current work.

• Clearly an external target (an existing file path, a repo dir, a diff) → note it:

*"That looks like an external target — /council <that> reviews it in isolation."*

Then proceed reviewing the local context that concerns it. Do not silently

switch into isolated mode; that's /council's job.

Phase 0 — Build the Review Brief (this becomes the target)

From the current conversation, distill a concise, self-contained REVIEW BRIEF of

the thing under review: its goal, the design/plan, the **key choices and

tradeoffs made, and any constraints. Be faithful and neutral** — capture what

was decided and *why*, not your own opinion of it. The cold lenses will see *only*

this brief, so it must stand on its own without the rest of the chat.

Source discipline (critical). The brief states only what the design/plan/decision

actually is, as specified. Do not fold anything that was merely *discussed,

proposed, worried about, or elaborated* during this conversation — including your own

earlier analysis, "concerns," "tensions," or numbered issues — into the brief as part of

the design, and **never quote chat-derived commentary as if it were the design's own

words**. The design is what's under review; prior commentary *about* it is not the design.

If you can't tell whether a detail was actually specified or just discussed, leave it out

(or mark it explicitly "discussed, not specified"). The lenses must review the real thing

— not a paraphrase inflated with the room's own prior critique.

No target, no panel (fail loud). If the conversation holds no concrete, identifiable

design/plan/decision to review — e.g. a bare or low-signal invocation with nothing

substantive built yet — do not manufacture one. Say so plainly and ask what to review.

Convening the panel on an invented target is exactly the fabrication this skill must never

produce.

Phase 1 — Convene (cold + independent)

You are running inline in this session, so you have the delegate tool — fan the

lenses out directly from here. Do not hand the orchestration to a

delegate(agent="self") worker: a delegated sub-session does not inherit the

delegate tool, so a worker cannot spawn the lenses — it can only *simulate* the panel

(one model voicing six personas). You can, so you run the orchestration yourself over the

REVIEW BRIEF, using the spec below.

The lenses stay cold and independent because each is spawned with

context_depth="none" (it sees only the brief, never this conversation) — that isolation

is what the brief is for. Keep this session lean by passing each lens only the brief, not

the chat, and collecting back only its structured verdict.

Orchestration Spec — run this yourself over the REVIEW BRIEF

> Keep in sync with council/SKILL.md Phases 1–5. The TARGET is the REVIEW BRIEF above.

Resolve the roster

The bench (v1) is exactly six personas. Mandatory core (always included —

never drop one):

• intent-keeper — "Is the goal clear, consistent, and still the real goal?"
• cranky-old-sam — "Why does this exist at all? What can be deleted?"
• crusty-old-engineer — "What will this cost to run/own later?"
• restless-old-brian — "Is it REAL, proven end-to-end, in the right order?"

Conditional lenses (default-on; include unless clearly N/A — record the decision,

included or excluded, with a one-line reason in the manifest):

• user-advocate — include when the work has a user/consumer surface (UI, API, CLI,

a stated end-user).

• tester-breaker — include when there's a runnable/testable artifact (a repo, a

diff, executable code, or a concrete plan that can fail in operation).

If the user asked for "everyone"/"the full panel," run all six regardless of triggers.

> Where each lens lives. All six lenses — intent-keeper, cranky-old-sam,

> crusty-old-engineer, restless-old-brian, user-advocate, tester-breaker — are in

> this bundle. No cross-bundle dependency.

Round 1 — cold, independent fan-out

For each rostered lens, spawn an isolated sub-session with delegate

(context_depth="none") — no shared history, no anchoring. Launch concurrently. Each:

Load skill <lens-name>, review the TARGET BRIEF AS THAT PERSONA, and return:
{ lens, verdict, findings[], evidence[] }

verdict is exactly one of {PASS, CONCERN, FAIL, N/A}. N/A is an **abstention with

a one-line reason — NOT a failure.** Keep FAIL and N/A distinguishable throughout.

Graceful Degradation — UNAVAILABLE. If a lens's skill cannot be loaded for any

reason (missing from the environment, a broken skill source, etc.), **do NOT

abort — mark it UNAVAILABLE** in the manifest with the reason and proceed with

the rest.

Fail Loud — ERRORED. A lens that loads but errors mid-review (or returns no

structured verdict) is different: report it loudly as incomplete. No synthetic

stand-in, no silent drop. *(UNAVAILABLE = never loaded; ERRORED = loaded then failed.)*

Debate-to-consensus (default max_rounds = 3)

Extract OPEN ITEMS = (i) any unresolved FAIL, or (ii) a DIRECT CONFLICT (two lenses,

opposing verdicts on the same finding). If none, skip to synthesis. Otherwise, for each

round, re-convene each lens in a fresh isolated sub-session, inject **ALL other lenses'

verbatim last-words — no curation, and ask each to hold / revise / concede in its

own voice with reasons. Stop when STABLE** (no verdict change, no new findings

round-over-round) or at max_rounds.

Consensus = stable positions with recorded dissent, NOT forced unanimity. A standing

disagreement at max_rounds is the HEADLINE, not averaged away. You are not a

gavel — the human resolves genuine value conflicts.

Synthesize (trust guardrails — non-negotiable)

• Print the ROSTER MANIFEST first — Consulted: …, plus excluded conditional

lenses (with reason), UNAVAILABLE lenses (with reason), and any ERRORED lenses.

• Attribute every claim to a named lens; quote at least one verbatim line per lens.

No anonymous synthesis.

• NEVER downgrade or omit a FAIL — any lens FAIL is an unresolved blocker surfaced

at the TOP. Interpret and weigh, but keep dissent visible.

• Keep FAIL and N/A distinguishable.

End with the synthesized verdict and, where positions genuinely conflict, the standing

tradeoff stated plainly for the human to resolve.

Relationship to /council

Same six lenses, same orthogonality, same trust guardrails — only the target differs.

/council forks and reviews an explicit external target in isolation (best for "review

this repo/file/idea cold," and it keeps the heavy run out of your session). council-here

runs inline to review the live conversation the fork can't see. If someone invokes

/council with a conversational reference, /council routes here.