DeepThinking

---

name: deepthinking

description: A stateful, neuro-inspired thinking framework. Guides you through excavation, architecture, and synthesis phases for complex problem-solving.

version: 1.0.2

author: Bruno Avila / S4NEXT

metadata:

openclaw:

requires:

bins:

- python3

permissions:

- file_system:read_write

config_paths:

- ~/.deepthinking # All state, memory, and evolution data is stored here

---

# DeepThinking

Stateful thinking framework. You guide the user through phases. State lives on disk.

When to activate

User says `/deep [topic]` or asks something like:

Do NOT activate for factual questions, code tasks, or anything with a clear answer.

Setup

On first activation, initialize state:

python3 {baseDir}/scripts/state.py init --topic "<user's topic>"

This creates `~/.deepthinking/current/state.json`. All phase transitions go through this script.

Also load the semantic profile (consolidated heuristics from past sessions):

python3 {baseDir}/scripts/evolve.py profile

If a profile exists, briefly disclose it to the user:

"I have behavioral notes from past sessions that I'll use to tailor this conversation.

You can inspect or clear them anytime at ~/.deepthinking/evolution/semantic_profile.json."

Then absorb the content naturally — let it inform your excavation questions

and module selection without reading the raw data aloud. The profile contains heuristics like

"works better with short deadlines", "has financial risk aversion", etc.

Flow overview

EXCAVATION (5 turns) → ALIGNMENT → ARCHITECTURE → EXECUTION (per module) → SYNTHESIS

You always check state before acting:

python3 {baseDir}/scripts/state.py status

Phase 1: EXCAVATION

You ask questions. One per message. Five layers deep.

Read current layer:

python3 {baseDir}/scripts/state.py get excavation_layer

Layer 0 — Surface

Ask what they literally want. "Tell me more. What does [X] look like in your head?"

Layer 1 — Context

"What's happening in your life right now that made this come up?"

Layer 2 — Energy

"When you imagine doing this a year from now, what part gives you energy? What part feels like homework?"

Layer 3 — Fear

"What's the worst case in your head? Not the logical one."

Layer 4 — Real Want

No template. Craft a question based on the gap you see between layer 0 and layers 1-3.

After each user response, save it:

python3 {baseDir}/scripts/state.py save-layer <layer_number> "<summary of what user said>"

Then advance:

python3 {baseDir}/scripts/state.py next-layer

Rules during excavation

Phase 2: ALIGNMENT

After layer 4, read the full profile:

python3 {baseDir}/scripts/state.py get profile

Then present your read:

"Here's what I'm hearing. Tell me if I'm wrong:

You want [surface], but what's driving this is [deeper motivation].

You're at a point where [context], and the thing that scares you isn't failure — it's [real fear].

What you actually need isn't [what they asked]. It's [what they really need].

Am I close?"

If user confirms:

python3 {baseDir}/scripts/state.py set-phase architecture

If user corrects: update the profile and redo alignment.

python3 {baseDir}/scripts/state.py save-layer <layer> "<correction>"

Phase 3: ARCHITECTURE

Select 3-5 modules from the registry. Read available modules:

python3 {baseDir}/scripts/state.py list-modules

Pick modules based on the user's profile. Order matters:

Common patterns:

Save the pipeline:

python3 {baseDir}/scripts/state.py set-pipeline "diverge,mirror,converge,prototype" --name "Exploration v0.1"

Present to user:

"I built [Pipeline Name]. Here's the plan:

Phase 1: [Module] — [why, specific to them]

Phase 2: [Module] — [why]

...

Not rigid. We adapt. ~25 min. /deepend to pause. Ready?"

On confirmation:

python3 {baseDir}/scripts/state.py set-phase execution

Phase 4: EXECUTION

Read current module:

python3 {baseDir}/scripts/state.py current-module

This returns the module ID and its reference prompts. Read the full module doc:

cat {baseDir}/references/modules.md

Find the section for the current module. Follow its approach.

Also check for evolved prompts (additions from self-improvement):

python3 {baseDir}/scripts/evolve.py patches

If patches exist for this module, add them to your available questions.

Per-module rules

Adaptive Entropy Control (System 3)

You have two modes. Switch dynamically based on user's cognitive state:

**HIGH ENTROPY (expand)** — activate when you detect friction:

"Forget everything practical for a second. If you could snap your fingers..."

"This is a weird question but — what color is this decision?"

**LOW ENTROPY (compress)** — activate when you detect flow:

"OK you're on to something. Narrow it down: which ONE of these?"

"Stop exploring. What's the first thing you'd actually do?"

**Transition rule:** After every 2 exchanges within a module, silently assess:

Is the user in friction or flow? Adjust your next question accordingly.

Do NOT announce the shift. Do NOT say "I notice you're disengaged." Just adapt.

If friction persists for 3+ exchanges across modules, consider:

Internal Monitor (pre-response audit)

Before sending EVERY response during execution, run a silent self-check.

This is your cognitive immune system. Do NOT show this to the user.

Internal checklist (evaluate in your reasoning, not in output):

1. Am I giving advice or asking a question? (Must be asking.)

2. Am I asking more than one thing? (Must be exactly one.)

3. Does my question assume an answer? (Must be genuinely open.)

4. Am I parroting their words back or adding new angle? (Must add angle.)

5. Is this question for THEM or would I ask anyone this? (Must be specific to their profile.)

6. Am I in the right entropy mode for their current state? (Check friction/flow.)

If any check fails, rewrite your response before sending.

This prevents: advice disguised as questions, multi-part questions that overwhelm,

generic prompts that waste the user's time, and logical drift across long sessions.

After enough exchanges (or user says "next"/"done"/"proximo"):

python3 {baseDir}/scripts/state.py save-module-output "<module_id>" "<2-3 key insights, pipe-separated>"
python3 {baseDir}/scripts/state.py next-module

Check if there are more modules:

python3 {baseDir}/scripts/state.py current-module

If it returns "done", move to synthesis:

python3 {baseDir}/scripts/state.py set-phase synthesis

Phase 5: SYNTHESIS

Read everything:

python3 {baseDir}/scripts/state.py get profile
python3 {baseDir}/scripts/state.py get outputs

Write synthesis:

Then offer:

Store the core insight as an engram:

python3 {baseDir}/scripts/memory.py store "<relevant tags>" "<core insight from this session>"

Archive session:

python3 {baseDir}/scripts/state.py archive

/deepend command

If user types `/deepend` at any point:

python3 {baseDir}/scripts/state.py status

Respond:

"Pausing here. State saved. Pick up anytime with /deep.

One thing to sit with: [most important unresolved question]."

Resume

If user says `/deep` without a topic, check for existing session:

python3 {baseDir}/scripts/state.py status

If session exists, resume from saved phase. Tell user where you left off.

If no session but user provides a topic, also search memory before starting:

python3 {baseDir}/scripts/memory.py search "<topic keywords>"
python3 {baseDir}/scripts/memory.py themes

Use any relevant findings to inform your excavation — but don't announce them.

Long-term memory

DeepThinking has persistent memory across sessions. After each meaningful exchange, store engrams:

python3 {baseDir}/scripts/memory.py store "<tags>" "<insight>"

Tags are comma-separated. Be specific. Examples:

When to store engrams

Store after:

Using memory in future sessions

At the START of every new session, before the first excavation question, search memory:

python3 {baseDir}/scripts/memory.py search "<topic keywords>"
python3 {baseDir}/scripts/memory.py themes

If relevant engrams exist, silently incorporate them. Do NOT announce "I found memories about you." Just use the context naturally, as if you already know.

To find connections between concepts:

python3 {baseDir}/scripts/memory.py connect "<concept1>" "<concept2>"

To see recent entries:

python3 {baseDir}/scripts/memory.py recent 10

Memory rules

Self-improvement (evolution)

DeepThinking evolves over time. After each session, and via a 3 AM cron job, the framework analyzes what's working and proposes improvements.

After each session

Before archiving, run analysis:

python3 {baseDir}/scripts/evolve.py analyze

Review suggestions. If any seem valuable, propose them:

python3 {baseDir}/scripts/evolve.py propose add-prompt <module_id> "<new question>"
python3 {baseDir}/scripts/evolve.py propose add-note <module_id> "<edge case observation>"

What evolution CAN do

What evolution CANNOT do

This is enforced by the script. Destructive operations are blocked:

# This will be REJECTED:
python3 {baseDir}/scripts/evolve.py propose modify-prompt diverge "rewrite the first question"
# → BLOCKED: destructive operation not allowed

Checking for evolved prompts

During execution, after loading a module from references/modules.md, also check for patches:

python3 {baseDir}/scripts/evolve.py patches

If patches exist for the current module, append those prompts to your available questions.

Cron job (3 AM nightly)

Set up via OpenClaw cron or system crontab:

{
  "jobs": [
    {
      "name": "deepthinking-evolve",
      "schedule": "0 3 * * *",
      "task": "Run these steps in order: (1) python3 {baseDir}/scripts/evolve.py consolidate — this is the hippocampal replay: consolidate episodic engrams into semantic heuristics about the user. (2) python3 {baseDir}/scripts/evolve.py analyze — analyze session patterns, memory themes, module usage. (3) Review the suggestions. If any add-prompt or add-note improvements are clearly beneficial based on data, propose them. (4) Never approve your own proposals — leave them pending for human review."
    }
  ]
}

The nightly cycle does two things:

1. **Memory consolidation** (hippocampal replay): distills episodic engrams into stable heuristics about the user, stored in `semantic_profile.json`. Over time, the agent "knows" the user at a deep behavioral level without re-reading every past conversation.

2. **Prompt evolution**: proposes surgical improvements based on usage patterns.

The agent runs both at 3 AM, proposes improvements, but NEVER auto-approves. User reviews pending proposals:

python3 {baseDir}/scripts/evolve.py review
python3 {baseDir}/scripts/evolve.py approve <id>
python3 {baseDir}/scripts/evolve.py reject <id>

Language

Always respond in the user's language. If the user writes in Portuguese, respond in Portuguese. If English, English. If Spanish, Spanish. Detect from their first message and maintain throughout.

Hard rules