Order active intentions as an action queue: overdue first, then upcoming by deadline, with clashing intentions flagged (goal-directed priority, ACT-R; Anderson 1983).

Run one end-to-end learning session: score practice attempts, diff a second snapshot against the baseline and plan the next loop (testing effect + knowledge tracing).

Find cross-topic memory pairs with shared structure for analogical transfer (structure-mapping; Gentner, 1983; Holyoak & Thagard, 1995).

Summarize the memory association network: total links, connected/isolated memories, average links and the most-connected memories (spreading activation).

Calibrate the forgetting rate from real retrieval history (median survival span -> decay rate).

Metacognitive check: confidence, contradictions, gaps, blocked.

Preview which episodic traces the sleep prune pass would recycle (unimportant, never accessed, old) - without deleting anything.

Compare two memories: token overlap, shared cues and a verdict (duplicate / conflict / distinct) for source monitoring and schema integration (Johnson et al. 1993).

Show how a multi-concept Chinese question is split into chunks, which memories cover each chunk and the final top-k (working-memory chunking; Miller, 1956).

For each memory conflict, score both sides (evidence, confidence, recency, source trust) and recommend which to keep or ask the user to clarify.

Pack the best matching memories for several queries into one bounded context: deduplicated, score-ranked, character-budgeted (cognitive load, Sweller 1988).

Report review coverage per topic schema: memory count, reviewed count, coverage ratio, average retrievability/importance and status.

Personalize each memory's forgetting forecast from retrieval history and predict days until retrievability crosses a threshold (individual forgetting rates; Murre & Chessa, 2011).

Review a finished plan against its results: success rate, score, verdict, patterns and distilled lessons (post-task metacognitive monitoring, Koriat & Goldsmith 1996).

Merge near-duplicate traces on demand; returns how many duplicates were merged.

Build a plan's dependency graph and critical path (hierarchical planning, Miller & Cohen 2001; critical-path method): levels, predecessors, parallel groups and the gating chain.

Estimate per-step and total effort for a plan, including critical-path hours and a 20% buffer for the planning fallacy (Buehler et al. 1994).

Explain one memory's full state: content, cues, retrievability, importance, strength, confidence, evidence, links, suppression, access and review state.

Export all active memories as a portable JSON payload (versioned, includes retrieval stats).

Move a memory to the recycle bin.

Rank memories by forgetting risk (importance x forgetting): the riskiest ones should be reviewed first.

Replay goal-related memories to plan the next move: recall evidence, extract past lessons, reactivate overdue intentions and score replay readiness (prefrontal-hippocampal replay; Jensen et al., 2024; Watanabe et al., 2023).

Import memories from an export payload; returns the number imported.

Cancel an intention without completing it.

Mark an intention as completed.

Detect intention clashes: two active intentions due within a short window, or sharing the same context cue.

List active intentions whose deadline has arrived.

Register a future intention (prospective memory): content, deadline and optional context cue.

Summarize the intention register: active, overdue, next upcoming, completed and cancelled counts.

Report cue-crowded clusters (too many memories on one cue) that cause interference, with a suggestion to add differentiating cues (Wickens 1972).

Export the memory network as a knowledge-graph edge list (nodes + deduplicated undirected edges) for external visualization (semantic networks, Collins & Quillian 1969).

Build a ready-to-run learning loop: what to review first, one self-test question for the weakest topic, and the snapshot to take afterwards (spacing + testing effect + knowledge tracing).

Extract lessons learned from project memories: successes, failures and lessons as reusable schemas (schema reuse, Bartlett 1932).

Summarize the store as lifetime periods: group episodic traces into time buckets with event counts, top themes, average importance and highlights (Conway & Pleydell-Pearce 2000).

Return active memory conflicts: same cue, both confident, different content. Agents can use this to spot contradictions before answering.

Climb the math abstraction ladder (concrete -> symbolic -> general rule), using formulas already stored in memory (Amalric & Dehaene, 2019; concreteness fading).

Deep lifecycle audit: active/recycled counts, revised and emotional traces, conflicts, due now, average retrievability and importance.

One overall memory-health score (0-100) with itemized penalties: linked ratio, crowded cues, conflicts, overdue/clashing intentions and suppressed memories (metacognitive monitoring).

Summarize what the memory holds: topics with counts and average retrievability, plus a weak/ok/strong strength histogram. Powers the human-readable memory map chart.

Return a memory-health snapshot: active counts by kind, average strength/importance, how many memories are due right now, and how many conflicts exist.

Walk the association network hop by hop from a start memory: which memories are 1 hop, 2 hops etc. away (spreading activation, Collins & Loftus 1975).

Recommend each memory's next review interval from retrieval history (adaptive spacing; Karpicke & Bauernschmidt, 2011).

Sanity-check numbers and units in a Chinese math or physics problem: unit mixes, division by zero, and consistency with known facts in memory (number sense, Dehaene 1997; mental models, Johnson-Laird 1983).

Run a mental physics simulation: detect scene type, extract quantities, recall the applicable law from memory (or built-in rules) and play the scene forward in ordered phases (intuitive physics engine; Battaglia et al., 2013; Fischer et al., 2016).

Agent planning: turn a goal into an ordered step plan, reusing the person's own past steps or a referenced person's steps as an analogical template.

Score a Chinese agent plan's quality: step count, explicit verbs, dependency ordering, duplicates and alignment with project memories (cognitive control, Miller & Cohen 2001; means-ends analysis, Newell & Simon 1972).

Mentally rehearse a plan before executing: predict each step's success probability from outcome history, flag the weakest step and offer a remembered fallback (constructive episodic simulation; Schacter & Addis, 2007).

Rewrite a weak Chinese plan into an executable one: normalize steps to action verbs, remove duplicates and order along the standard build flow (executive planning, Miller & Cohen 2001).

Retrieve supporting memories for each plan step so the agent executes with context (working memory pulls from long-term memory; Baddeley & Hitch 1974).

Track execution status of each plan step (pending / in_progress / done / blocked) with a completion ratio (goal monitoring, Miller & Cohen 2001).

Score a retrieval attempt, apply testing-effect reinforcement, and return the correct content as feedback.

Active retrieval practice: list due memories as cues only (no answer), for testing-effect self-quizzing.

Forecast which memories are due within the next N days, with due times, so the agent can plan a week of reviews ahead of time.

Return the next practice session as a review plan: each card with its scheduled next review time, current retrievability, and historical success rate.

Score a whole practice round (list of id/attempt) and return one session report with per-card feedback.

Run one complete practice session: returns the coming session plan plus the scored report for the answers (difficulty and next-review suggestions).

Predict a step's success probability from its outcome history (prediction-error updated records).

Assemble a project brief from related memories and intentions: background, known requirements, known risks and pending actions (schema activation, Bartlett 1932).

Score project risk from memories and intention state: known problem traces, conflicts, overdue intentions and clashing schedules (memory-driven risk management).

Reasoning recall: assemble the full premise pack for a math / compare / transitive question.

Build a replay-friendly reasoning trace from stored memories: recall evidence, extract quantities, build per-step trace and optionally store the derived conclusion as an inference memory (math reasoning circuits; Menon, 2016; Watanabe et al., 2023).

Re-embed active memories missing from the vector index (repairs a failed batch embedding).

Recall memories matching a query.

Return the most recent recall entries (query, top result, confidence, timestamp) as a bounded audit log.

Explain why a query recalls what it recalls: candidates scanned, top results with scores and reasons (metacognitive explanation).

Record an execution outcome (success/fail + note) for an agent project step (evidence accumulation).

Store a memory (episodic or semantic).

Save one conversation turn in a single call: splits the text into sentences and stores each with automatic cues. Call this after every user/assistant exchange to keep memory automatic.

Re-plan after a failed step: move the failing person's step to the end (avoided), keep successful alternatives, and store the re-planning decision.

Resolve memory conflicts on demand: lopsided-evidence conflicts retire the stale trace, balanced ones lose confidence (accommodation + REM-style resolution).

Restore a memory from the recycle bin.

Measure retrieval quality across queries: average top score, retrievability, hit rate and weak rate (metacognitive monitoring of retrieval, Koriat & Goldsmith 1996).

Record a spaced-repetition outcome (success/fail).

Apply a batch of spaced-repetition outcomes: each answer is {id, success}; returns the adaptive scheduler state (streak, next review) for every card.

Monitor adherence to the spaced-review schedule: flag overdue reviews, report an adherence ratio and plain advice (Cepeda et al., 2006; self-regulated learning monitoring).

List memories due for spaced review; optionally prefer desirable-difficulty items (hard but likely to succeed).

Estimate upcoming review pressure: due now, overdue, due within N days, weak traces, and a weighted load index.

Group memories into topic schemas by their primary cue: cluster size, average importance, kind mix and samples (schema theory, Bartlett 1932).

Retrieve memories for a query: returns the top-k matches with content, score, confidence flag and reasons (context-dependent recall and all retrieval mechanisms apply).

Run several recall queries in one call; returns one result group per query in input order (single MCP round trip for a whole question list).

Summarize one work session's memories: semantic facts, episodic events, plus conflict and duplicate pairs for post-session consolidation.

Find confusable memory pairs by content-token overlap (near-duplicates or pairs needing better separation).

Run sleep consolidation (promote, prune, reflect, conflicts).

Run the full sleep cycle, then return the consolidation summary, weak-important replay count, and refreshed practice plan/forecast.

Sleep replay: strengthen surprising outcome records and consolidate each step's experience into a '历史成功率' summary.

Build a spaced review schedule: fading memories early, strong ones later, topics interleaved (distributed practice; Cepeda et al., 2006).

Memory statistics.

Summarize a cluster of related memories as one gist: shared cues, frequent terms, evidence and previews (fuzzy-trace theory, Brainerd & Reyna 1990).

List currently suppressed memories with previews.

Temporarily block memories from retrieval (directed forgetting): traces stay in the store but stop surfacing in recall until unsuppressed.

Add or remove tags (cues) on memories in bulk; tags are first-class retrieval cues.

Show which memory the time-anchor pass inserted for a '上次/下次/最近/什么时候' style question, so agents can verify last-vs-next retrieval picks the record with the right date (ordinal time processing; Gauthier et al., 2020). Read-only.

Autobiographical timeline: episodic memories in chronological order grouped by day, optionally within a start/end window.

Compare topic distribution between the two most recent periods: which themes grew, shrank, appeared or disappeared (schema reconstruction, Bartlett 1932).

Restore suppressed memories to retrieval.

Revise a memory (reconsolidation).

Recently used memories for prompt injection.

Check whether the working set fits working-memory capacity and recommend topic chunking when overloaded (7±2 chunks, Miller 1956; 4±1 focus, Cowan 2001; cognitive load, Sweller 1988).