WakeIQX

Appearance

Layer 5: Personality Modes ​

Layer 5 (Presentation) shapes how context is retrieved and presented. Rather than changing what's stored, Personality Modes change the temporal posture of every retrieval — the same project data, viewed from four different angles.

Layer 5 is pure presentation

No database migration needed. Personality Modes are applied at retrieval time inside ContextService and formatted in ToolExecutionHandler. The data contract is the personality_mode parameter on load_context and search_context.

The Four Modes ​

ModeAnswersRetrievalTone
historianWhat happened and why?By recency (default)Factual, timestamp-heavy
prophetWhat should I focus on next?By Layer 4 prediction scorePredictive, forward-looking
archaeologistWhat have I forgotten?By dormancy (least-accessed first)Exploratory, archival
minimalistGive me just the content.By recencySilent — summaries only

historian (default) ​

Focus: Decision history
Retrieval: Standard reverse-chronological (most recent first)
Output: Timestamp, memory tier, causality action + rationale, summary, tags

This is the default mode when no personality_mode is specified. It reconstructs what happened and why — ideal for resuming work or producing an audit trail.

typescript
load_context({
  project: "api-redesign",
  limit: 3
  // personality_mode defaults to "historian"
})

Example output:

Found 3 context(s):

Historian Mode — Decision history for `api-redesign`

**2025-10-17T16:00:00Z** · tier: ACTIVE
Action: decision — Chose REST for initial release
Decision: Use REST API with versioning. Migrate to GraphQL only if needed.
Tags: rest, api, versioning, architecture, decision

**2025-10-17T14:30:00Z** · tier: ACTIVE
Research summary on API design patterns
Tags: research, api, graphql, rest, grpc

prophet ​

Focus: Next session priorities
Retrieval: Ranked by Layer 4 prediction score (predictionScore DESC)
Output: Prediction score, propagation reasons, predicted next access, summary

Prophet mode reads Layer 4's per-project weights and surfaces what the system predicts you'll need next — not what's most recent, but what's most likely to matter.

typescript
load_context({
  project: "api-redesign",
  limit: 5,
  personality_mode: "prophet"
})

Example output:

Found 5 context(s):

Prophet Mode — Predicted priorities for `api-redesign`

**Prediction score: 0.87** (recent_access, high_frequency)
Decision: Use REST API with versioning.
Predicted next access: 2025-10-18T09:00:00Z

**Prediction score: 0.64** (causal_root)
Initial project kickoff — API requirements
Predicted next access: 2025-10-18T10:30:00Z

Fallback behavior

If a project has no prediction scores yet (no update_predictions run), prophet falls back to recency order.

archaeologist ​

Focus: Dormant threads — the forgotten and unvisited
Retrieval: Fetches 50 contexts, re-sorts by lastAccessed ASC (null first = never accessed)
Output: Timestamp, dormancy status, memory tier, summary, tags

Archaeologist ignores recency bias entirely. It surfaces contexts you haven't touched in the longest time — useful for project archaeology, long-running work, or finding abandoned threads.

typescript
load_context({
  project: "api-redesign",
  limit: 5,
  personality_mode: "archaeologist"
})

Example output:

Found 5 context(s):

Archaeologist Mode — Dormant threads for `api-redesign`

**2025-08-01T10:00:00Z** · never accessed · tier: EXPIRED
Early rate-limiting spike (deferred)
Tags: rate-limiting, spike, deferred

**2025-09-10T14:00:00Z** · last accessed 2025-09-11T08:00:00Z · tier: ARCHIVED
gRPC evaluation notes — abandoned after REST decision
Tags: grpc, evaluation, abandoned

When to use archaeologist

  • Before a major refactor: "What did we evaluate but never ship?"
  • Long-running projects: "What threads have we dropped?"
  • Knowledge transfer: "What context exists that nobody's reading?"

minimalist ​

Focus: Raw context content
Retrieval: Standard reverse-chronological (same as historian)
Output: Summaries only, no headers, no metadata, no framing

Minimalist strips all presentation — no mode header, no timestamps, no tiers, no tags. Just the summaries joined by blank lines. Ideal for programmatic use, passing raw context to another tool, or conserving tokens.

typescript
load_context({
  project: "api-redesign",
  limit: 3,
  personality_mode: "minimalist"
})

Example output:

Decision: Use REST API with versioning. Migrate to GraphQL only if needed later.

Research summary on API design patterns — REST vs GraphQL vs gRPC evaluation.

Initial project kickoff notes.

How Modes Work Together with Layers 1–4 ​

Layer 5 reads data from all four underlying layers:

ModeLayer Data Used
historianLayer 1 (causality action + rationale), Layer 2 (memory tier)
prophetLayer 3 (prediction score, reasons, predicted access), Layer 4 (tuned weights)
archaeologistLayer 2 (lastAccessed, memory tier)
minimalistCore context only (summary)

Implementation Reference ​

Config: src/config/personality-modes.ts

typescript
export const PERSONALITY_MODES = {
  historian:     { focus: 'decision_history',  tone: 'factual',      depth: 'causal_chain', verbosity: 'high'   },
  prophet:       { focus: 'next_session',      tone: 'predictive',   depth: 'propagation',  verbosity: 'medium' },
  archaeologist: { focus: 'dormant_threads',   tone: 'exploratory',  depth: 'full_archive', verbosity: 'high'   },
  minimalist:    { focus: 'raw_context',       tone: 'silent',       depth: 'surface',      verbosity: 'none'   },
} as const;

Applied in:

  • ContextService.loadContext() — mode-aware retrieval order
  • ContextService.searchContext() — mode-aware post-search ranking
  • ToolExecutionHandler.handleLoadContext() — mode-aware formatting
  • ToolExecutionHandler.handleSearchContext() — mode-aware formatting

Type contract: personality_mode is an optional enum on both LoadContextInput and SearchContextInput.

See Also ​