Think

/think — Temporal-trajectory queries against the brain

Answer "when did X last Y" / "what changed since Z" / "what's the latest on W" by splicing dated entries from client history.md, sprint goals/MMYY-NN-cycle.md, memory pages, and session decisions into a chronological timeline. Zero LLM cost on intent classification — regex routes the query, the splice does the work.

Stolen from garrytan/gbrain (v0.40.2.0) via /steal Phase 5–6 (2026-05-23). See .claude/discovery/0526-gbrain-steal-analysis.md item G19.

Triggers

Invoke this skill when the user says:

• /think [question]
• "When did Alan last push back on positioning?"
• "When was the last time we shipped a Pulse?"
• "What changed in ClientCo's pricing since the March doc?"
• "What's the latest on ClientCo's GTM stack build?"
• "Any new on ClientCo?"
• "What happened with the Notion shadow-pull thing?"

Do NOT invoke when:

• The question is rule-shaped or convention-shaped ("do we have a rule about X?") — use /recall --memory
• The question is decision-extraction shaped ("what did we decide about X?") — use /recall --decisions
• The question is research-shaped or external ("what's Salesloft launching this week?") — follow .claude/rules/brain-first-lookup.md then Exa per exa-protocol.md
• The question is in-session reasoning ("what should we do next?") — just answer

If unsure between /think and /recall: /think is for when-shaped and what-changed-shaped questions; /recall is for what-was-decided and what-was-discussed questions.

Process

Step 1 — Classify intent (regex, zero-LLM)

Apply the classifier to the input question. Three intents:

Implementation note: the classifier is deterministic — no model call. Wrong classification degrades gracefully (the source files still surface; the ordering is just less optimal). Default if ambiguous: temporal.

Step 2 — Temporal splice (chronological timeline)

For temporal intent, build a unified chronological timeline by reading these sources:

1. Client history.md if a client name is in the query — projects/consulting/active/{client}/history.md (append-only ops record)
2. Client sprint cycles if a client name is in the query — projects/consulting/active/{client}/goals/*-cycle.md (dated cycle files)
3. Memory pages sorted by indexed_at from memory_pages table (G13) — filter by topic keyword
4. Session decisions sorted by timestamp from decisions table — filter by topic + optional --client

Splice + sort:

• Each entry gets a normalized (date, source, claim) triple
• Sort descending by date (most recent first)
• Limit to the top 20 entries or the last 90 days, whichever is smaller

Output format:

TIMELINE — "<query>"
────────────────────────────────────────
2026-05-23 [history] {history.md entry}
                        ↳ projects/consulting/active/{client}/history.md
2026-05-21 [decision] {decision text}
                        ↳ session {id_short}
2026-05-17 [memory] {memory page title}
                        ↳ memory/{slug}.md (tier {boost}x)
2026-05-15 [cycle] {cycle file headline}
                        ↳ goals/0526-02-cycle.md
...

For "when did X last Y" questions: find the most-recent entry matching X+Y, return it with full context. For "first time" questions: same logic, ascending sort.

Step 3 — Knowledge-update splice (since-date filter)

For knowledge_update intent, parse the implicit time anchor and filter:

Same sources as Step 2 (history.md + cycles + memory + decisions). Same chronological output, but filtered to the since-window.

Step 4 — Fast-path short-circuit (other intent)

If the intent classifier returns other, the question isn't temporal-shaped. Don't build a timeline — just hand off to /recall <topic> and return its result. This is the cheap default — most questions are not temporal, and routing them through the splice machinery would burn time for no gain.

Worked examples

Example 1 — "When did Alan last push back on positioning?"

• Intent: temporal (matches \bwhen did\b)
• Sources scanned: projects/consulting/active/ClientCo/history.md + memory pages with "alan" + session decisions filtered to --client "ClientCo"
• Output: most-recent entry surfaces (e.g., 2026-03-18 [decision] Alan pushed back on "MVP test" → compliance friction reclassification)

Example 2 — "What's the latest on ClientCo's GTM stack build?"

• Intent: knowledge_update (matches \bwhat is the latest\b.*\bon\b)
• Window: last 30 days
• Sources scanned: projects/consulting/active/ClientCo/history.md + sprint cycles + decisions
• Output: chronological timeline of the last 30 days of ClientCo activity, most-recent first

Example 3 — "What did we decide about positioning?"

• Intent: other (no temporal regex match)
• Short-circuit: hand off to /recall --decisions filtered by topic "positioning"
• No timeline built — the question is decision-shaped, not when-shaped

Example 4 — "Since the March doc, what changed on ClientCo pricing?"

• Intent: knowledge_update (matches \bsince the\b)
• Anchor: "March doc" → resolve to projects/consulting/active/ClientCo/pricing/0326-*.md mtime → filter to entries after
• Output: chronological timeline of pricing-related entries after the March doc

Data sources (read paths)

For client name extraction from the query, match against CLIENT_MAP from session-indexer.py (ClientCo, ClientCo, ClientCo, ClientCo, etc.).

Anti-hallucination guardrails

1. Never fabricate timeline entries. Only return entries actually found in the source files. If a query matches nothing, say "no temporal entries found for {query}" — don't synthesize.
2. Always cite the source path + date. Every timeline row has a ↳ {path} line. The user can verify.
3. Don't paraphrase entries. Quote the verbatim line from history.md or memory page; the verbatim phrasing IS the signal (per .claude/rules/auto-memory.md).
4. Respect the brain-first-lookup ladder. If the timeline is empty AND the question is research-shaped, escalate per .claude/rules/brain-first-lookup.md Step 4 — don't fill the gap with external data without explicit user approval.
5. Cap output at top-20 or 90 days. Longer timelines drown the reader; if more depth is needed, the user can ask /think --since 6mo.

When to use this skill vs. its neighbors

The fast-path short-circuit means /think is safe to invoke broadly — non-temporal questions just route through to /recall without overhead.

Composition with adjacent skills + rules

Anti-patterns

• ❌ Running /think on every question. The fast-path costs near-zero, but it adds a layer of indirection — only invoke when the question is temporal-shaped or you want the classifier to decide.
• ❌ Treating the classifier as infallible. Misclassification degrades gracefully; check the output and re-route manually if needed.
• ❌ Splicing too many sources. Top-20 / 90-day cap is the discipline; more drowns the signal.
• ❌ Paraphrasing source entries in the timeline. Quote verbatim with path + date.
• ❌ Filling temporal gaps with external research. If the brain has nothing, say so; don't invent a "latest on X" from training data.