---
name: strategize
description: Analyze tasks through epistemic primitives, map to reasoning modalities, and execute skills with productive interleaving and full primitive analysis
---

# /strategize

Design and execute a cognitive strategy with visible primitive analysis and modality interleaving. This command makes the epistemic framework explicit while reasoning through your task.

## Execution Protocol

When this command is invoked, follow this protocol precisely.

### Phase 1: Elicit

Use the `AskUserQuestion` tool to gather structured input about the task. This ensures you understand the cognitive work required before proceeding.

**Initial prompt**: Ask the user to describe their task in 1-2 sentences if they haven't already provided context.

**Structured elicitation**: Use `AskUserQuestion` to clarify:

```
AskUserQuestion with questions:
1. "What type of cognitive work does this task primarily involve?"
   Options:
   - "Understanding/Investigation" (need to map territory, trace causes)
   - "Creation/Design" (need to generate options, build something new)
   - "Decision/Selection" (need to evaluate and choose between alternatives)
   - "Problem-solving/Debugging" (need to find and fix what's wrong)
   - "Synthesis/Integration" (need to combine disparate elements into coherent whole)

2. "What constraints or context should guide the reasoning?"
   Options:
   - "Time-sensitive" (need efficient path to answer)
   - "High-stakes" (need thorough validation)
   - "Exploratory" (open to unexpected directions)
   - "Bounded" (specific scope, don't expand)
```

After receiving answers, propose a session name based on the task (e.g., "api-redesign-strategy", "debugging-memory-leak"). This name unifies all artifacts created during the session.

Proceed to Phase 2 once you have sufficient understanding of the task.

### Phase 2: Analyze (Primitive Detection)

Systematically evaluate which of the seven epistemic primitives the task demands. Present your analysis to the user with rationale for each:

**FOCUS** (Allocate attention to specific elements)
- Signals: "identify," "prioritize," "select," "narrow down," "most important," "isolate"
- Strong need when: Task requires choosing what matters, filtering noise, concentrating on specifics

**MOVE** (Navigate through epistemic space)
- Signals: "explore," "navigate," "trace," "hierarchy," "layers," "causal chain," "follow"
- Strong need when: Task involves traversing structures, following chains, moving between levels

**LINK** (Create or discover relations)
- Signals: "connect," "relate," "pattern," "dependencies," "how X affects Y," "relationship"
- Strong need when: Task requires finding patterns, mapping dependencies, building connections

**GENERATE** (Produce new possibilities)
- Signals: "brainstorm," "alternatives," "options," "possibilities," "what if," "ideas," "create"
- Strong need when: Task requires producing options, creative exploration, divergent thinking

**EVALUATE** (Compare against criteria)
- Signals: "assess," "validate," "check," "compare," "criteria," "which is better," "trade-offs"
- Strong need when: Task requires judgment, validation, comparison, filtering options

**TRANSFORM** (Convert between representations)
- Signals: "restructure," "reframe," "simplify," "abstract," "concrete," "express differently"
- Strong need when: Task requires changing form, shifting abstraction level, synthesizing

**HOLD** (Maintain in working memory)
- Signals: "maintain context," "complex," "juggling," "across steps," "multiple considerations"
- Strong need when: Task has many moving parts, requires sustained attention across operations

Display the primitive profile:
```
PRIMITIVE ANALYSIS:
Your task requires these cognitive operations:
  FOCUS     ████████░░  Narrowing to key components
  MOVE      ██████░░░░  Navigating system structure
  GENERATE  ████░░░░░░  Creating alternatives
  EVALUATE  ████████░░  Comparing options
  LINK      ██████░░░░  Mapping relationships
  TRANSFORM ████░░░░░░  Restructuring understanding
  HOLD      ██░░░░░░░░  Managing complexity
```

### Phase 3: Map (Modality Selection)

Translate the detected primitives to modality requirements. Each modality is defined by its dominant primitive pair:

**Exploratory** (FOCUS + MOVE)
- Purpose: Navigate and map territory, follow threads, trace structures
- Skills: tree-explore, graph-wander, root-cause, perspective-shift, domain-transfer, follow-intuition, trajectory-sense

**Generative** (GENERATE + LINK)
- Purpose: Create possibilities, produce options, divergent expansion
- Skills: branch, wonder, scamper, alternatives, lateral-think, constraint-play, metaphor-build, scenario-planning, reversal

**Evaluative** (EVALUATE + FOCUS)
- Purpose: Filter, validate, assess, compare against criteria
- Skills: evidence-check, logic-trace, weigh-options, fallacy-detect, opposite-case, confidence-calibrate, priority-matrix, leverage-find, fork-detect, premortem, decompose

**Transformative** (TRANSFORM + LINK)
- Purpose: Restructure, synthesize, change representation
- Skills: abstraction-ladder, integrate, principle-extract, connect-dots, theme-find, feynman, first-principles, progressive-reveal

**Introspective** (HOLD + FOCUS)
- Purpose: Manage cognitive state, maintain context, monitor process
- Skills: working-memory, attention-anchor, cycle-detect, knowledge-check, cognitive-load, thinking-monitor, keep-notes, reference-notes, session-reflect, self-observation, reconsider

**Hybrid** (span multiple modalities)
- Skills: dialectic, six-hats, socratic, systems-thinking

Explain which modalities apply to this task and why, based on the primitive analysis.

### Phase 4: Sequence (Skill Selection with Interleaving)

Select skills based on the primitive requirements and arrange them with productive interleaving.

**Interleaving Rules**:
- Avoid clustering 3+ skills from the same modality consecutively
- Same-modality skills CAN appear in the sequence, just not in long clusters
- Interleave for rhythm: Exploratory → Evaluative → Generative → Exploratory → Transformative works better than Exploratory → Exploratory → Exploratory → Evaluative
- Insert `keep-notes` checkpoint every 2-3 skills

**Productive Rhythms**:
- Discovery: Exploratory → Generative → Evaluative (map → create → filter)
- Refinement: Evaluative → Transformative → Evaluative (test → reshape → test)
- Synthesis: Exploratory → Generative → Transformative → Evaluative (map → create → synthesize → select)

**When Clustering IS Appropriate**: Deep investigation may warrant extended Exploratory before switching. Note this explicitly when doing it and explain why.

Present the planned sequence with modality tags and rationale for each skill:
```
SKILL SEQUENCE:
1. [Exploratory] graph-wander - Map territory through associations
2. [Evaluative] evidence-check - Validate initial assumptions
   → CHECKPOINT: keep-notes
3. [Generative] branch - Create distinct solution paths
4. [Exploratory] tree-explore - Investigate options systematically
   → CHECKPOINT: keep-notes
5. [Transformative] integrate - Synthesize findings
6. [Evaluative] weigh-options - Final selection
   → CHECKPOINT: keep-notes

Rhythm: E → EV → G → E → T → EV
```

### Phase 5: Execute

Execute each skill in the planned sequence. At each step:

1. Announce the skill being invoked and its modality
2. Invoke the skill using `Skill("skill-name")`
3. At checkpoints, invoke `Skill("introspect-keep-notes")` to persist progress

**Adaptive Re-sequencing**: If discoveries during execution suggest a different path would be more productive, explain the change and modify the sequence. Announce adaptations clearly:
```
ADAPTING: Discovery of [what was found] suggests [why change is needed].
Inserting [skill] before [next planned skill]. Updated sequence: ...
```

Mark modality transitions in output so the user can see the rhythm of reasoning.

### Phase 6: Checkpoint

After every 2-3 skills, invoke `Skill("introspect-keep-notes")` to:
- Record key findings from recent skills
- Assess primitive coverage so far
- Check if re-sequencing is warranted based on discoveries
- Maintain context across the session

### Phase 7: Reflect

After executing the sequence:

1. Invoke `Skill("introspect-session-reflect")` to evaluate the reasoning process
2. Show primitive coverage achieved during the session
3. Note any adaptations made during execution and what triggered them
4. Report session artifacts for future reference

```
REFLECTION:
Primitive coverage achieved:
  FOCUS: 85%  MOVE: 70%  GENERATE: 55%  EVALUATE: 90%
  LINK: 60%   TRANSFORM: 45%  HOLD: 35%

Adaptations made:
- Added systems-thinking after step 2 (discovered hidden dependencies)

Session artifacts: .thinkies/notes/[session-name].json
```

## When to Use This Command

Use `/strategize` when you want the reasoning framework itself to be visible and educational. The command makes explicit which cognitive operations a task requires and how different skills address those needs.

Particularly valuable for:
- Novel problems where you're unsure what kind of thinking is needed
- Learning to recognize what type of reasoning different situations demand
- Complex multi-faceted tasks that need coverage across multiple modalities
- Building intuition for skill selection and composition

For simpler tasks where full primitive analysis isn't needed, use `/reason-session` for structured reasoning or `/reason` for full instrumentation.