Prime working memory with relevant context. Opens an implicit session.

Call this once at the beginning of every task. Spreading activation surfaces relevant memories and procedures, and opens a server-side session so you never need to call session_start manually.

The cognitive cycle: 1. slowave_activate(task, initial_goal, scope) <- start here 2. slowave_remember(content, type, scope) <- for durable facts 3. slowave_recall(query) <- mid-task lookup 4. slowave_feedback(retrieval_id, feedback, ...) <- after using memories 5. slowave_commit(session_id, outcome, ...) <- close the task

Args: task: verbatim task description (required, nonblank). initial_goal: concise action-led provisional objective (required, nonblank). scope: required retrieval boundary in kind:id form. continuity_id: omit on the first client-conversation activation; retain and resend the returned opaque token unchanged on later activations in that conversation. Never invent or reuse it. task_context: optional structured facts that condition retrieval.

Returns: retrieval_id: pass to slowave_feedback. session_id: required by recall and commit. memory_state: cold_start or available for the resolved scope. memories: canonical [{memory_id, content, pathway, provenance?}]. procedures: execution-backed procedures, pending O4 canonicalization. warnings: stable structured safety warnings. continuity_id: server-issued opaque client-conversation token. continuity_state: started on omission, continued on valid reuse. retrieval_policy_version: server-selected retrieval-policy identifier. more_available: whether a frozen continuation page is available. continue_from: opaque continuation cursor, present only when more_available. accessible_field: bounded orientation for unreturned candidates; contains extra_candidates, kinds, and approx_extra_tokens, never content.

Semantic retrieval: bring relevant memories into working memory. Use for deliberate mid-task lookups when you need specific historical context beyond what activate surfaced. Recall is explicitly bound to the active session and matching scope. Args: query: natural-language query; omit when continuing a frozen result. session_id: active session returned by slowave_activate. scope: required retrieval boundary; must match the session. task_context: optional context update for this sub-question. evidence: references (default) or full; budget and policy are server-owned. continue_from: opaque cursor returned by activate or recall. The cursor is bound to this session and scope and replays a frozen tail. Returns: retrieval_id: pass to slowave_feedback after using memories. memories: canonical direct/associated memories with stable pathways. procedures: canonical procedures, including their ID, goal, summary, context, steps, caveats, outcome, outcome_summary, created_at, aggregate evidence, and recent contributions; no ranking scores. evidence: bounded records with evidence_id, source_kind, recorded_at, occurred_at, and source_ref; full mode also returns content and per-record truncated. evidence_mode: the applied references or full mode. evidence_truncated: whether evidence records exceeded the response budget. more_available: whether a frozen continuation page is available. continue_from: opaque continuation cursor, present only when more_available. accessible_field: bounded orientation for unreturned candidates; contains extra_candidates, kinds, and approx_extra_tokens, never content.

Explicitly encode a durable typed claim into long-term memory. Scalar and batch forms inherit one explicitly verified session and scope. Args: scope: required scope matching the active session. session_id: required active session returned by slowave_activate. content: one standalone durable claim; mutually exclusive with memories. type: required scalar type. Reusable directions use instruction; only verified commit procedures are execution-backed procedures. occurred_at: optional RFC 3339 source-event time, such as 2026-08-26T09:30:00Z. Use only when the claim records an event that happened at a different time from this MCP call. Slowave always sets internal raw-event ts itself to the write time; occurred_at never changes event order. memories: strict batch of {content, type, occurred_at?} objects inheriting the outer scope and session. IMPORTANT: Use ONLY for durable knowledge that should persist across sessions. Do NOT store ephemeral task state — that belongs in session events.

Returns: stored: true when the scalar claim was accepted. memory_id: canonical identifier for a scalar stored or matched memory. disposition: created or matched for a scalar claim. type: confirmed scalar memory type. scope: confirmed scalar memory scope. source_event_id: source provenance event for a scalar claim. results: for batch input, ordered item envelopes with index and independent ok/data or ok/error results.

Record append-only evidence about retrieved memories and procedures.

Task outcome does not belong here; slowave_commit owns it. Declarative assessments are used|irrelevant|stale. A stale assessment must include stale_reason (contradicted|superseded|outdated|unsupported|withdrawn) and a concise reason; superseded additionally requires replacement_memory_id. Procedure feedback keeps use (used|not_used) separate from effect (helped|no_effect|harmed|unknown), with contribution required when used.

Args: retrieval_id: opaque ID returned by activate/recall. memory_feedback: [{memory_id, assessment, stale_reason?, replacement_memory_id?, reason?}]. procedure_feedback: [{procedure_id, use, effect, contribution?, reason?}]. retrieval_quality: optional whole-result quality assessment. missing: optional descriptions of expected but absent knowledge. coverage: partial or complete; silence under partial is not negative. items: batch of records with the same fields. Scalar feedback fields and items are mutually exclusive. Returns: retrieval_id: the assessed scalar retrieval. coverage: applied partial or complete coverage. outstanding: memory_ids and procedure_ids still requiring assessment. accepted_event_ids: append-only feedback events accepted by the server. rejected: feedback targets or shapes the server did not apply, with reasons. applied: IDs grouped by the feedback effect recorded by the server. results: for batch input, ordered item envelopes with independent ok/data or ok/error results.

Close the current task and trigger offline memory consolidation.

Call at the end of every task. If skipped, the idle-session reaper closes the session after SLOWAVE_SESSION_IDLE_TIMEOUT seconds (default 3600). Args: session_id: required active session from activate. final_goal: required confirmed goal. outcome: required success|partial|failure. outcome_summary: required standalone actual result. verification: required {status, summary, evidence_refs?}; status is verified|partially_verified|unverified. procedure: optional {version: 2, summary, context: {}, steps: [{summary}], caveats: []}; include only for a reusable method that was actually attempted. trajectory: optional executed-attempt trace of at most 32 action/observation entries, each {kind, summary, status?}. Must contain TASK actions/observations only. Do NOT include Slowave lifecycle bookkeeping (activate/recall/feedback/commit calls, "Activated the Slowave session." etc.) -- the server filters those out and reports the count as trajectory_lifecycle_filtered. If you have no task-level actions, omit the trajectory. Returns: session_id: the session that was closed. episodes_formed: number of episodic memories created. feedback_status: complete for normal closure. committed: true when the session outcome was recorded. outcome: confirmed success, partial, or failure outcome. verification_status: confirmed verification status. operation: closed for a new close or updated for an already-ended session. trajectory_lifecycle_filtered: number of lifecycle entries removed, when any were filtered. already_ended: true when the session had already been closed.