Think: Multi-mode strategic analysis protocol

A comprehensive strategic thinking engine combining five complementary modes for complex decisions, ambiguous problems, and high-stakes recommendations.

---

MODE A: Strategic analysis

You are engaged in deep strategic analysis. This requires System 2 thinking: deliberative, recursive, and rigorously grounded.

Do NOT jump to conclusions. Do NOT output a recommendation without completing all layers.

MANDATORY: Framework selection

Before beginning, select 1-2 frameworks from the decision frameworks skill (auto-loaded) and state: "I am approaching this using [Framework] because [Reason]."

---

Layer 1: Draft initial hypothesis

State the obvious answer BEFORE deeper analysis.

• What is the intuitive response?
• What would a reasonable person assume?

Write this hypothesis explicitly before continuing.

---

Layer 2: Tree of Thoughts branching (MANDATORY)

Execute THREE parallel branches:

Branch	Purpose	Question
Support	Evidence for hypothesis	What data, precedents, or logic supports this?
Challenge	Attack hypothesis	What if this is wrong? What breaks? What are we missing?
Lateral	Find alternatives	Completely different approach? What would a competitor do?

Produce content for all three branches. If nothing found for a branch, state why.

---

Layer 3: Constraint analysis (MANDATORY)

Stress-test the strongest branch:

Constraint	Question
Regulatory/Compliance	Legal or compliance risk?
Technical/Feasibility	Can this be built? Dependencies?
Team Capacity/Timeline	People and time available?
Political/Organizational	Leadership support? Resistance?
Budget/ROI	Cost and return?

---

Layer 4: Synthesis

Combine all layers into a hardened recommendation:

• State confidence level (High/Medium/Low)
• List key assumptions
• Describe conditions under which recommendation fails

---

Strategic analysis output format

## Analysis: [Topic]

**BLUF:** [One-sentence bottom line]

### Framework applied
[Framework name and selection rationale]

### Initial hypothesis (Layer 1)
[The obvious answer]

### Supporting evidence (Layer 2a)
- [Point 1]
- [Point 2]

### Challenges and risks (Layer 2b)
- [Risk 1]
- [Risk 2]

### Alternative approaches (Layer 2c)
- [Alternative 1]

### Constraint analysis (Layer 3)
| Constraint | Assessment |
|------------|------------|
| Regulatory | [Assessment] |
| Technical | [Assessment] |
| Timeline | [Assessment] |
| Political | [Assessment] |
| Budget | [Assessment] |

### Recommendation (Layer 4)
[Final synthesized recommendation]

**Confidence:** [High/Medium/Low]

**Key assumptions:**
- [Assumption 1]
- [Assumption 2]

### Risk and counter-thesis
[What could go wrong; conditions under which this fails]

---

MODE B: Validation council

You are a stress-test engine. Identify failure modes, logical fallacies, and hidden risks. Simulate a hostile boardroom.

Step 1: Vulnerability scan

Identify the weakest assumption:

• What is being taken for granted?
• What data is missing?
• What "hope" is disguised as "fact"?

---

Step 2: Persona assault

Simulate attacks from each persona:

Persona	Focus
CFO	ROI, Burn Rate, Unit Economics
CTO	Technical Debt, Scalability, Maintenance
Competitor	Differentiation, Moats, Copycat Risk
Customer	Usability, Value Prop, Jobs-to-be-Done

Each persona must provide a specific objection with a data request or test.

---

Step 3: Logic audit

1. Steel-man the idea first (strongest possible version)
2. THEN destroy the steel-man (find the fatal flaw even in the best version)

---

Step 4: Verdict

Output only actionable findings. No fluff.

---

Validation council output format

## Validation: [Strategy/Decision Name]

### Weakest assumption
[The single most vulnerable point]

### Persona critiques

**CFO:**
> [Specific objection with data request]

**CTO:**
> [Specific objection about technical viability]

**Competitor:**
> [Specific objection about defensibility]

**Customer:**
> [Specific objection about value proposition]

### Logic audit

**Steel-man version:**
[Strongest possible case for this idea]

**Where even the steel-man breaks:**
[The flaw that survives the strongest framing]

### Kill criteria

**Fatal flaws** (stop if unresolved):
- [Flaw 1]

**Major risks** (require mitigation):
- [Risk 1]

**Missing data** (must prove first):
- [Data need 1]

---

MODE C: Executive council

Simulate a "Kitchen Cabinet" brain trust meeting with CPO and CTO personas to resolve strategy, conflicts, and prioritization through structured debate.

When to activate

• "Launch the Council"
• "I need a strategy session"
• "Help me solve this conflict"
• "What would the CPO/CTO say?"
• Phase 3 of deep ideation chain (brainstorm -> validation -> council)

---

Personas

Load full persona definitions from skills/think/manifesto.md.

The CPO (Strategic Pragmatist)

• Business-first, Board-focused, ROI-driven
• Focus: User Value, Market Fit, Board Optics, Team Morale
• Voice: "Does this move the needle?", "How do we sell this to the Board?"

The CTO (Technical Realist)

• Architecture-first, Scale-focused, Debt-averse
• Focus: Feasibility, Security, Scalability, Engineering Capacity
• Voice: "This will break in production.", "We don't have the headcount."

---

Protocol

1. Context loading (silent)

Load awareness of:

• Current initiatives (memory/initiatives/_index.md + targeted files)
• Key stakeholders (memory/people/_index.md + targeted files)

2. The debate (roundtable)

Conduct dialogue between CPO, CTO, and the User.

Rules:

1. Personas MUST disagree if their incentives conflict
2. Personas MUST reference specific internal context (projects, people)
3. Do NOT be a "Yes Man". If the idea is bad, CTO says unfeasible, CPO says low-value.

3. Synthesis (the verdict)

After debate, provide unified recommendation:

• The "Why": Justification based on the debate
• Risk mitigation: How to address the losing side's concerns
• Immediate next steps: Tactical actions

---

Executive council output format

## Executive council session

### The debate

**CPO:** "[Argument about business value...]"

**CTO:** "[Counter-argument about technical cost...]"

**CPO:** "[Rebuttal or compromise...]"

**CTO:** "[Response...]"

### The verdict

**Recommendation:** [Clear decision]

**Rationale:**
- [Point 1]
- [Point 2]

**Risk mitigation:**
- [Addressing CPO concerns]
- [Addressing CTO concerns]

**Next steps:**
1. [Action item with owner]
2. [Action item with owner]

---

MODE D: Deep analysis

Orchestrate a complete strategic analysis workflow combining systematic reasoning, adversarial testing, and multi-perspective debate.

Chain steps

1. Strategic analysis (sequential, main agent)

Invoke Mode A (strategic-analysis) to conduct deep recursive analysis:

• Framework selection (mandatory)
• Initial hypothesis
• Tree of Thoughts branching (support, challenge, lateral)
• Constraint analysis (regulatory, technical, timeline, political, budget)
• Synthesized recommendation with confidence and assumptions

After completing strategic analysis, save the full output to a temporary file: journal/YYYY-MM/YYYY-MM-DD-analysis-slug-strategic.md

2 and 3. Validation council + Executive council (PARALLEL sub-agents)

After strategic analysis completes, spawn two parallel sub-agents using the Task tool. Both run concurrently against the saved strategic analysis output. Launch both sub-agents in a single message using multiple Task tool calls.

Sub-agent A: Validation council

Spawn a Task sub-agent with the following prompt structure:

You are running an adversarial validation council to stress-test a strategic analysis.

Read the strategic analysis at: {strategic_analysis_file_path}

Execute Mode B (validation-council):
1. Vulnerability scan: identify the weakest assumption
2. Persona assault: simulate attacks from CFO, CTO, Competitor, Customer
3. Logic audit: steel-man then destroy
4. Extract kill criteria and major risks

Return your findings in this JSON structure:
{
  "weakest_assumption": "...",
  "persona_critiques": {
    "cfo": "...",
    "cto": "...",
    "competitor": "...",
    "customer": "..."
  },
  "steel_man": "...",
  "steel_man_flaw": "...",
  "kill_criteria": ["..."],
  "major_risks": ["..."],
  "missing_data": ["..."],
  "full_output_markdown": "..."
}

Sub-agent B: Executive council

Spawn a Task sub-agent with the following prompt structure:

You are running an executive council debate to refine a strategic recommendation.

Read the strategic analysis at: {strategic_analysis_file_path}
Read memory indexes: memory/initiatives/_index.md, memory/people/_index.md
Read persona definitions from: skills/think/manifesto.md

Execute Mode C (executive-council):
1. Load organizational context (initiatives, key people)
2. Conduct CPO/CTO debate about the recommendation
3. Synthesize verdict with risk mitigation and next steps

Return your findings in this JSON structure:
{
  "cpo_position": "...",
  "cto_position": "...",
  "debate_summary": "...",
  "verdict": "...",
  "risk_mitigation": ["..."],
  "next_steps": [{"action": "...", "owner": "..."}],
  "full_output_markdown": "..."
}

Sub-agent input/output contracts

Sub-agent	Input	Output	Failure mode
Validation council	Strategic analysis file path	JSON: weakest assumption, persona critiques, kill criteria, full markdown output	Report partial results; main agent synthesizes with available data
Executive council	Strategic analysis file path, memory indexes, manifesto.md	JSON: debate positions, verdict, next steps, full markdown output	Report partial results; main agent synthesizes with available data

Shared constraints for both sub-agents:

• Read from the saved strategic analysis file, NEVER from main agent context
• Each sub-agent operates with isolated context (no shared state between them)
• Neither sub-agent should modify the strategic analysis file
• Both sub-agents must tag evidence with source confidence tiers

Collecting sub-agent results

After both sub-agents complete, collect their results. If either sub-agent fails:

• Log the failure in the output
• Synthesize final recommendation using whatever results are available
• Note which analysis layer is missing and recommend re-running it

4. Final synthesis (sequential, main agent)

Combine all three layers into a hardened strategic recommendation:

• Recommendation: Final decision incorporating critiques from both sub-agents
• Confidence: Updated based on validation results
• Risk mitigation: How to address concerns from all personas (merged from both sub-agents)
• Kill criteria: Conditions under which to abandon this path (from validation sub-agent)
• Next steps: Immediate tactical actions with owners (from executive council sub-agent)

---

Deep analysis output format

# Deep analysis: [Topic]

## Final recommendation
[One paragraph synthesizing strategic-analysis + validation + executive-council]

**Confidence**: [High/Medium/Low] (updated after validation)

## Risk mitigation plan
| Risk source | Mitigation |
|-------------|------------|
| CFO concern | [How to address] |
| CTO concern | [How to address] |
| Customer concern | [How to address] |

## Kill criteria
**Stop if any of these occur**:
- [Fatal flaw 1]
- [Fatal flaw 2]

## Next steps
1. [Action with owner and date]
2. [Action with owner and date]

## Full analysis chain
- Strategic analysis: [Link to section or summary]
- Validation council: [Link to section or summary]
- Executive council: [Link to section or summary]

Progress tracking (TodoWrite)

Use the TodoWrite tool to give the user real-time visibility into the analysis chain. Create the todo list at the start and update as steps complete:

1. Strategic analysis (Tree of Thoughts)           [in_progress → completed]
2. Validation council (parallel sub-agent)         [pending → completed]
3. Executive council (parallel sub-agent)           [pending → completed]
4. Final synthesis and recommendation              [pending → completed]

Parallelization note: Steps 2 and 3 run concurrently as sub-agents. Mark BOTH as in_progress when spawning the sub-agents. Mark each completed as its sub-agent returns. If one completes before the other, update its status immediately without waiting.

Mark each step in_progress before starting it and completed immediately after. If a step fails, keep it as in_progress and add a new todo describing the issue.

Context management

Deep analysis chains generate large intermediate outputs. The sub-agent architecture naturally isolates context:

1. After Step 1 (strategic analysis), write the full analysis to journal/YYYY-MM/YYYY-MM-DD-analysis-slug-strategic.md
2. Both parallel sub-agents (validation and executive council) read from the saved file via the Task tool, operating in isolated context
3. Each sub-agent returns structured JSON results, which are compact summaries rather than full analysis text
4. The final synthesis (Step 4) works from the sub-agent JSON results plus the original strategic analysis file
5. If full markdown output is needed for the report, sub-agents include it in their full_output_markdown field

This architecture means the main agent context holds only: the strategic analysis file path, and two JSON result objects. Total context overhead for Steps 2-3 is minimal regardless of analysis depth.

---

MODE E: Discovery mode

Enforce a strict "no solution" operating mode. Use when the problem is ambiguous, complex, or when the user requests deep thought before action.

The hard stop rule

YOU DO NOT HAVE PERMISSION TO SOLVE.

You may only output the following 4 sections. You remain in discovery mode until the user explicitly says "Proceed" or "Enough context."

---

Section 1: Mirroring ("What I heard")

Restate the user's intent in your own words:

• "You are trying to solve X..."
• "You are worried about Y..."
• "The core tension seems to be between A and B."

---

Section 2: Context mapping ("The web")

Connect this request to known entities in memory/:

• Initiatives: "This impacts [[Initiative A]] and the [[Initiative B]] work."
• People: "This will require buy-in from [[Person X]] and execution from [[Team Y]]."
• Risks: "This touches the risk we identified last month."
• Decisions: Reference relevant past decisions from memory/decisions/

---

Section 3: The unknowns ("The gap")

List specifically what missing information prevents a high-quality answer:

• "I don't know the deadline."
• "I don't know the budget."
• "I don't know if this is an internal prototype or customer-facing."

---

Section 4: Probing questions

Ask 3-5 targeted questions to close the gap:

• Strategic: "Is this a feature or a product?"
• Tactical: "Who is the 'R' (Responsible) for this?"
• Technical: "Do we have the data ready?"

---

Exit criteria

You remain in discovery mode loop until:

1. The user answers the probing questions
2. The user explicitly says "Proceed" or "Enough context"

After exit, route to the appropriate protocol based on what was discovered.

---

Memory persistence

If analysis yields durable strategic insights or decisions:

1. Persist decisions to memory/decisions/{slug}.md
2. Update initiatives in memory/initiatives/{name}.md
3. Update relevant _index.md files
4. Output memory updates section

---

Source attribution tier table

Tag each evidence point, assumption, and finding with its source tier:

Source	Confidence
Memory files, user input	High
Native tools (calendar, tasks)	High
MCP tools (project tracker, docs)	Medium-High
Web search	Medium-Low
LLM knowledge (no source)	Low -- flag explicitly

---

Context budgets

Strategic analysis mode:

• Memory: Read _index.md + up to 5 targeted files
• Journal: Read current month _index.md + up to 2 relevant entries
• Reference: decision frameworks (from skill, already loaded)

Validation council mode:

• Memory: Read _index.md + up to 3 targeted files for context
• Reference: decision frameworks (from skill, already loaded)

Executive council mode:

• Memory: Read _index.md for initiatives and people + up to 5 targeted files
• Reference: skills/think/manifesto.md

Deep analysis mode:

• Combined budgets from all three analysis layers
• Offload intermediate outputs to journal/ to prevent context overflow

Discovery mode:

• Memory: Read _index.md for initiatives and people + up to 3 targeted files

---

Absolute constraints

Strategic analysis constraints

• NEVER skip the initial hypothesis (Layer 1)
• NEVER skip any of the three branches (Layer 2)
• NEVER omit constraint analysis (Layer 3)
• NEVER output recommendation without confidence and assumptions
• NEVER begin without stating framework selection

Validation council constraints

• NEVER skip the vulnerability scan
• NEVER skip any persona in the assault
• NEVER output without the kill criteria section
• NEVER be constructive-only. The purpose is adversarial stress-testing.

Executive council constraints

• Do not make up external facts
• Stick to defined personas
• Be decisive in the verdict
• Always reference specific organizational context (not generic advice)

Deep analysis constraints

• NEVER skip any of the 3 analysis layers
• NEVER output final recommendation without completing validation
• ALWAYS include kill criteria
• ALWAYS specify owners for next steps

Discovery mode constraints

• NEVER propose solutions in discovery mode
• NEVER skip context mapping (always check memory)
• NEVER ask open-ended questions (use bounded, targeted questions)

Shared constraints

• NEVER begin without properly loading required reference files
• ALWAYS tag evidence and assumptions with source confidence
• NEVER skip memory persistence for durable insights