Unstuck

/ouroboros:unstuck

Break through stagnation with lateral thinking personas. Two modes:

• Solo — one persona reframes the problem (fast, cheap).
• Debate — multiple personas run in parallel as sub-agents and the user picks the verdict (visual, thorough).

Usage

ooo lateral                       # debate (default) — all 5 lateral personas
ooo lateral <persona>             # solo — single persona
ooo lateral debate <p1> <p2> ...  # debate with explicit members
ooo lateral @<preset>             # debate with preset (Phase 1: only @all = 5 personas)

Trigger keywords: "I'm stuck", "think sideways", "ooo lateral", "/ouroboros:unstuck".

Personas (Lateral Pool)

The lateral pool is stateless mindset personas only — five reframing lenses. Stateful roles (evaluator, qa-judge, ontologist, socratic-interviewer, etc.) are NOT mixed into this pool; they have their own SKILLs.

When to Call

Direct user invocation — ooo lateral … from the prompt.

Autonomous chain from another SKILL — when you (the main session) are operating in another SKILL's persona (e.g., socratic-interviewer during ooo interview, or any agent role) and judge that the current question requires multi-perspective deliberation, you MAY invoke this SKILL on your own. No forced trigger; this is your self-assessment. After the debate, summarize the options for the user, return to the original SKILL's flow, and let the user decide. The user will see the sub-agent fan-out as it happens — that visibility is the point.

Instructions

Step 1 — Parse args → mode

Parse the user's argument string (or your autonomous-chain intent) into a mode (solo / debate):

Validate every persona name against the lateral pool above. If invalid, emit a brief error message naming the valid personas — do NOT silently coerce. Multiple persona tokens without the explicit debate keyword are rejected to keep the syntax unambiguous.

Step 2 — Gather required context before the MCP call

ouroboros_lateral_think hard-fails if either problem_context or current_approach is empty (LateralThinkHandler.handle in src/ouroboros/mcp/tools/lateral_think_handler.py). A bare ooo lateral from a fresh session has neither — calling MCP directly would crash before any persona work. Resolve both fields before Step 3, in this order:

1. Reuse session state. If a parent SKILL is invoking this one (autonomous chain) or the current Claude Code / Codex session has clearly recent stuck-point context, extract it. Build:
   • problem_context — what the user is stuck on (1–3 sentences, current state of the world).
   • current_approach — what has been tried so far (1–3 sentences). For a brand-new attempt, this can be "none yet — first attempt".
   • failed_attempts (optional) — short list of prior failures, when the user has volunteered them.
2. If either field is unrecoverable, ask the user one short combined question before going further (this applies to both solo and debate — the handler requires both fields either way):

   "Two things I need before lateral thinking can run: (1) what are you stuck on right now, (2) what have you already tried? A sentence each is enough." Wait for the answer. Do not invent or paraphrase past turns into these fields if you are not certain — current_approach="not specified" is acceptable, fabricated content is not.

3. Only when both fields are populated, proceed to Step 3.

This pre-call branch applies to solo and debate. Skipping it makes ooo lateral (no args, fresh session) reliably error.

Step 3 — Always call ouroboros_lateral_think (routing contract)

Per the ooo routing contract in src/ouroboros/codex/ouroboros.md, every ooo lateral invocation MUST route through the MCP tool — solo and debate, in every runtime. This SKILL never substitutes a direct sub-agent fan-out for the MCP call.

1. Use the active runtime's tool-discovery capability with query "+ouroboros lateral" to load ouroboros_lateral_think (often prefixed, e.g., mcp__plugin_ouroboros_ouroboros__ouroboros_lateral_think). Deferred tools won't appear until runtime tool discovery runs.
2. Invoke the tool with the parsed mode and the context from Step 2:
   • Solo: persona=<one>, problem_context, current_approach, failed_attempts.
   • Debate: personas=[...], problem_context, current_approach, failed_attempts.
3. If the tool is not callable even after discovery — neither already exposed nor loadable (an empty discovery result for an already-exposed tool is expected, not a failure) — stop and report that the MCP dispatch surface is broken — same rule the contract applies to ooo auto. Do not improvise a sub-agent fan-out as a workaround; that bypasses the contract the bot review explicitly flagged.

The MCP call is cheap. The handler's inline path is a deterministic prompt builder — it constructs per-persona reframing prompts via LateralThinker.generate_alternative (LateralThinkHandler.handle in src/ouroboros/mcp/tools/lateral_think_handler.py); it does not run an LLM rollout.

Step 4 — Branch on the handler's response shape

The handler picks one of two response shapes based on should_dispatch_via_plugin(...) (src/ouroboros/mcp/tools/subagent.py). You do not choose; you observe and act. The envelope key further depends on the mode you called with — solo and debate are not symmetric:

Inline dispatch block (debate, inline response only). The handler appends a versioned, sentinel-bracketed dispatch block to the end of content as a compatibility fallback for clients and runtimes that consume only textual content. MCP SDK v2 preserves structured metadata, while the inline block lets text-only consumers recover the same canonical payloads (written by LateralThinkHandler.handle in src/ouroboros/mcp/tools/lateral_think_handler.py, read back by _inline_lateral_dispatch_payload in src/ouroboros/mcp/tools/subagent.py). Format:

<!-- ouroboros-lateral-inline-dispatch-v1 base64
<base64-encoded-JSON>
-->

Two pieces matter:

• Hidden HTML comment — markdown viewers render nothing for <!-- ... -->, so the block doesn't pollute the human-visible output.
• Base64 body — base64's alphabet is [A-Za-z0-9+/=], which can never produce the sequence -->. So even if a user-supplied problem_context or current_approach contains --> (HTML/JS debugging is the obvious case), the encoded body cannot prematurely close the wrapper and leak the dispatch into the visible markdown.

Decoded, the body is JSON. An MCP host that did not declare subagent capability receives the neutral shape:

{"dispatch_mode": "host_decides", "host_action": "dispatch_subagents_if_supported", "execution_preference": "parallel", "fallback_strategy": "sequential", "persona_count": N, "payloads": [...]}

An explicitly sequential execution authority receives dispatch_mode="sequential" with legacy_dispatch_mode="inline_fallback" for compatibility. To recover: locate the substring between <!-- ouroboros-lateral-inline-dispatch-v1 base64\n and \n--> at the end of content, base64-decode it, then JSON.parse.

Shape A — dispatch_mode = "plugin" (OpenCode plugin mode only)

The plugin runtime spawns Task panes automatically from whichever envelope the handler emitted. You only need to read the right key and await the result(s):

Solo (plugin)

The response carries a single _subagent object (singular) — {tool_name, title, prompt, agent, model, context} — produced by build_subagent_result (src/ouroboros/mcp/tools/subagent.py). The plugin spawns one Task pane. Await its single result, then present the persona's reframing.

Debate (plugin)

The response carries a _subagents array (plural) — [{tool_name, title, prompt, agent, model, context}, ...] — produced by build_multi_subagent_result (src/ouroboros/mcp/tools/subagent.py). The plugin spawns N Task panes in parallel. Await all N results, then synthesize per the Synthesize block below.

If you expected plugin mode but the response is inline text (neither _subagent nor _subagents), you are not actually in plugin mode — fall through to Shape B; do not wait for an envelope that will not arrive.

Shape B — inline response (Claude Code, Codex CLI, OpenCode subprocess, every other runtime)

The handler ran the prompt builder internally and returned ready-to-use markdown:

• Solo response: a single # Lateral Thinking: <approach> block followed by the reframing prompt.
• Debate response: N such blocks concatenated with \n\n---\n\n separators. The dispatch block distinguishes declared host_driven, capability-neutral host_decides, and explicit sequential execution.

Solo (any runtime)

Present the persona's approach summary, reframing prompt, questions to consider, and a ◆ Current state → next: suggestion routing back to the workflow.