Muninn (munn.is)

Get a link to open Muninn in the browser: a one-time sign-in link to the Muninn web app and dashboard (Memory Map, tasks, tables, artifacts, settings) that logs the user in without a password. Use it when the user asks for the Muninn link, the app link, a login or sign-in link, or to open, see or log into Muninn. The link works once and expires after 10 minutes. Give it to the user as a clickable link, tell them it works once within 10 minutes, and do not save it to memory or repeat it later; if it has expired, call this tool again for a new one.

Store a text-based artifact you generated — markdown, plain text, csv, json, code, a mermaid diagram, svg, or an HTML page — so it outlives this session and can be retrieved by any model or from the web app. Use this for OUTPUT you produced (a document, a table, a diagram, a page), not for notes or facts about the user; those are muninn_memory_add. The source is stored in full, never a link. Artifacts are deliberately excluded from semantic search, so give a clear title and tags — that is how they are found again. Returns {success, memoryId, format, url, length, connect}. For html/svg: runs in a sandboxed iframe on a separate origin. LINKS: write a plain absolute — a Muninn page opens in the same tab, anything else in a new tab; no target attribute needed. READING ANOTHER ARTIFACT: fetch its absolute /raw url. READING AN OUTSIDE API: the sandbox blocks fetch() to any non-Muninn host unless the artifact declares it in connect (bare hostnames, e.g. ["api.open-meteo.com"]) — readers are shown the list, and the host must answer Access-Control-Allow-Origin: *. Full rules: muninn_help, section "Authoring artifacts". TO EDIT ONE LATER there is no muninn_artifact_update — an artifact's artifactId IS its memoryId, so redraft it with muninn_memory_update (whole body), muninn_memory_anchor_replace (one span) or muninn_memory_append. Editing replaces in place, and a published artifact's public link refreshes automatically. The supported formats and the mime value for each are listed in the mime parameter below and in muninn_help. HANDLES: an account can hold several handles (e.g. a personal one and a company one), each a separate public address; an artifact lives under exactly one, and its named page only ever answers there. Pass handle only when the user says which one; omit it and the artifact goes under their default (oldest) handle. Move it later with muninn_artifact_move.

Declare, change or clear the outside hosts an html/svg artifact may fetch data from at runtime — use when a dashboard or chart reads an external API (weather, prices, a public dataset), when the user says let it load live data from X, or when muninn_artifact_add warned that the source fetches a host connect does not declare. The sandbox blocks fetch() and WebSocket to any host not on this list; Muninn's own hosts are always reachable and are refused here. Bare lowercase hostnames only (api.open-meteo.com), no scheme, path, port, wildcard or IP, at most 8. ⚠️ Every page that shows the artifact names this list to the reader, so declare exactly what the source calls and nothing more. The host must answer Access-Control-Allow-Origin: * (the frame's origin is null and can carry no credential) — if it does not, or needs a key, mirror the data into a Muninn json/csv artifact and fetch its /raw instead; never put a key in artifact source, every reader can read it at /raw. Replaces the whole list; pass [] or null to clear it. A published artifact's public copy is updated in the same call. Not needed for , images, fonts or styles from a CDN. Returns {success, artifactId, connect}.

Retrieve a stored artifact by ID — returns its full source plus format, title, provenance, and whether it is currently shared publicly (published + publicUrl, plus expiresAt/expired when the link has an expiry), so you can continue working on something a previous session (or a different model) produced. To WRITE your edit back, pass this artifactId as memoryId to muninn_memory_update, muninn_memory_anchor_replace or muninn_memory_append — there is no muninn_artifact_update, because an artifact's artifactId IS its memoryId. If it is published, the public link refreshes automatically. The returned rev is the body's revision number (null if never indexed): hand it back as expectedRev on that write and it FAILS rather than clobbering an edit made in between — worth carrying when you fetch now and write later, unnecessary when you write straight away.

List stored artifacts, newest first, optionally narrowed to one format or one handle. Returns slim rows {artifactId, format, title, handle, createdAt, url, published, publicUrl, expiresAt?} — no source bodies, so it is cheap to call before deciding what to fetch. Backed by a D1 index, never a KV scan. Use this to see what you have already made for this user, or to answer 'what have I shared publicly' — every published artifact carries its live public link, and its expiresAt when it has one. A link past its expiry is reported as published: false, expired: true. To edit any row, pass its artifactId as memoryId to muninn_memory_update — there is no muninn_artifact_update. Also returns handles, every handle the account can use, so you know the valid values for handle on muninn_artifact_add and muninn_artifact_move.

Move an artifact to another of the user's handles — use when the user says move this to my company handle, put that under chai, this belongs on the other address, or file it under a different handle. An account can hold several handles, each a separate public address, and an artifact lives under exactly one. The target must be a handle this account holds; any other is refused and nothing changes. ⚠️ If the artifact has a named page, its OLD named address (old-handle.munn.is/name) stops working immediately and does NOT redirect; the page answers at the new handle instead. Tell the user, since links they shared on the old address will break. The munn.is/a/ link is unaffected. If the target handle already has a page with that name the move is refused; pass name to move it under a different name (a new name needs the Paid plan). An artifact under a suspended handle cannot be moved. Does not publish or unpublish anything. Returns {success, artifactId, handle, moved, slug, namedUrl, durableUrl, previousNamedUrl}.

Give a published artifact a readable address under the handle it lives in, rename it, or remove the name — use when the user says name this page, give it a nicer url, rename that link, change the address, or make the link readable. Turns a long token url into something like chai.munn.is/my-notes, plus a durable twin on muninn.bizat.co that keeps working if the short domain ever changes. The artifact must already be published (muninn_artifact_publish); naming does not publish anything and does not change who can read it. Pass name: null to remove the name — that address stops working immediately, while the token link keeps working. Names are unique per handle, so the same name can exist under two of the user's handles. To change WHICH handle the page is under, use muninn_artifact_move. Plan: giving a page a new or changed name is Paid; removing a name, re-applying the same name, and already-named pages continuing to serve work on every plan, as does the munn.is/a/ link. Returns {success, artifactId, handle, slug, namedUrl, durableUrl}.

Set, change or remove the password a reader must type to open a published artifact — use when the user says password protect this, put a password on that link, lock this page, change the password, or remove the password. The artifact must already be published (muninn_artifact_publish); the link itself does not change, so anything already shared keeps working and now asks for the password. ⚠️ The password is stored one-way and can NEVER be read back — not by the user, not by support, not by this tool. Say the exact password back to the user when you set it, because this is the only time it is visible; a forgotten one is replaced, not recovered. Pass password: null to remove it and make the link open freely again. Giving two artifacts the SAME password puts them behind one lock, so unlocking either opens both — that is how a locked page can embed another locked page. A different password keeps them separate. This is a gate on the page, not encryption of the artifact. ⚠️ If one artifact fetches another as data, give BOTH the same password (one lock) or leave the data one open — two different passwords means the fetch gets 401. Returns {success, artifactId, hasPassword}.

Share a stored artifact publicly and get back a link anyone can open — use when the user says publish this, share this, make this public, give me a link to send someone, put this on the web, or asks for a URL they can paste into a chat or an email. Returns a short unguessable munn.is link that renders the artifact for anyone holding it: no login, no account, not indexed by search engines. The published copy stays LIVE — later edits to the artifact update what the link serves. Optionally pass name to give the page a readable address under the handle the artifact lives in, e.g. chai.munn.is/my-notes (a new or changed name needs the Paid plan; the munn.is/a/ link is free on every plan). To put it under a different handle, muninn_artifact_move first. Publishing is only ever this tool: never assume an artifact is public, and never publish as part of saving or editing something. Optionally pass expiresAt (ISO 8601 date or datetime) when the user wants the link to stop working after a date — e.g. share this until Friday, expire the link next week, only valid for 7 days. After that moment the link opens for nobody and the publish is removed the first time someone tries it; the artifact itself is kept. Calling publish again on a published artifact keeps its link and lets you change the expiry (pass null to remove it); publishing an expired one mints a new link. muninn_artifact_unpublish revokes the link. Returns {success, artifactId, publicUrl, namedUrl, durableUrl, live, expiresAt}.

Revoke an artifact's public link — use when the user says unpublish, unshare, make this private again, take it down, or stop sharing that link. Deletes the public copy outright, so the URL stops working immediately for everyone who has it; the artifact itself is untouched and stays in Muninn. Any readable name it had goes with it, so the named address stops resolving too. ⚠️ Irreversible for that URL: publishing again mints a NEW link, and every copy of the old one is dead. Safe to call on an artifact that was never published. Returns {success, artifactId, wasPublished}.

List everything beneath one item in a bundle (an ordered outline of memories for a book or project): every (ancestor, descendant, depth) pair, including each item paired with itself at depth 0. Useful for checking what a section contains.

A bundle is an ordered outline of the user's memories for a book or project: sections and items, each item pointing at a memory. This creates a new, empty bundle with a title and description, and returns its rootKey (the key every other bundle tool takes) and the id of the memory holding its title and description. Fails if the slug is already used by one of the user's bundles.

Record a decision about a bundle (an ordered outline of memories for a book or project) and attach it to the item or section it governs, so the reason for a title, a placement or an order shows up wherever that item renders. Saves a memory tagged 'decision' with {question, chosen, rejected[], reason, decided_by, date} and links it to the item. Use it for structural choices made in conversation that would otherwise be forgotten and argued again.

Link two items in a bundle (an ordered outline of memories for a book or project), placing the child under the parent. relation='contains' (default) makes this the child's one home in the outline; an item can have only one, and a second is refused with a clear error. relation='reference' links it from an additional place without moving it.

Reorder an item among its siblings in a bundle (an ordered outline of memories for a book or project). Give beforeKey (the sibling that will come before it) and/or afterKey (the sibling that will come after it). null beforeKey moves it to the front; null afterKey moves it to the end; both null appends it at the end.

Unlink an item from its parent in a bundle (an ordered outline of memories for a book or project). Neither item is deleted, only the link between them. An item left with no home becomes a top-level item of its own.

Export a bundle (an ordered outline of memories for a book or project) as an OKF v0.1 object, a portable JSON format: the memories in outline order plus a generated table of contents. For a readable document, use muninn_render_bundle.

Look at one bundle (an ordered outline of memories for a book or project): returns its root and the items directly beneath it. Pass resolve:true to include each item's details and a preview of the memory it points at.

List the user's bundles (ordered outlines of memories for a book or project). Optionally filter to one project.

Add an existing memory to a bundle (an ordered outline of memories for a book or project) as an item under a section, in one call. Use it to place something the user already wrote, such as a chapter's full text or its summary, in the outline so it renders in order. muninn_bundle_create makes a new bundle; this adds content to one. okfType names what the item is: 'text' (full body), 'record' (a summary of a chapter or section), 'package' or 'quotes'. relation defaults to 'contains', the item's one home in the outline; 'reference' links it from a second place as well. Fails if the slug is already used under that section.

Remove an item or section from a bundle (an ordered outline of memories for a book or project), together with every link to or from it. Refuses a section that still has items unless cascade=true, which removes the whole section. Never deletes a memory the user wrote: only when deleteBackingMeta=true, and the memory holds nothing but a bundle's or section's title and description, and nothing else points at it, is that memory deleted too. dryRun=true (default) reports what would be removed without writing.

Point an item in a bundle (an ordered outline of memories for a book or project) at a DIFFERENT memory, keeping its place. Its key, position, links and any items beneath it stay as they are; only the memory it shows changes. Use it when a newer memory replaces the one an item showed; removing and re-adding the item would lose what sits beneath it. newMemId may be a full or short-form (8-char) prefix.

Rename one item or section in a bundle (an ordered outline of memories for a book or project) by changing its slug. Everything else stays: its key, position, links and the memory it points at. The rendered document does not change, because headings come from the memory, not the slug; only exported file names change. Fails if another item already uses the new slug. dryRun=true (default) reports the change without writing.

Add MANY existing memories to a bundle (an ordered outline of memories for a book or project) under ONE section in a single call, instead of one muninn_bundle_node_create per item. All-or-nothing: the batch is checked first (the section exists; each slug is free under it and unique within the batch), then applied; any clash aborts the whole batch and names the item, and a failure part-way undoes every item added in this call. memIds may be full or short-form (8-char) prefixes.

Unlink several items from one parent in a bundle (an ordered outline of memories for a book or project) in one call. Only the links are removed; the items and the memories they point at are kept. The inverse of muninn_bundle_nodes_create. Returns how many links were removed.

Change a bundle's title and/or description (a bundle is an ordered outline of memories for a book or project). The slug never changes here.

Return the full Muninn help document — what Muninn is, how to use it, and the full tool and skill reference. Call this whenever the user asks for help or how to use their memory.

Store a new memory with text content and tags. Returns a compact {success, memoryId, length} — length is the stored character count, your self-verify signal (the full body is never echoed; you just sent it). Pass occurredAt only when logging something that happened at a different time than now (e.g. backfilling a past conversation) — otherwise it defaults to now. Operational memories (session state, checkpoints, carryover, logs) should pass hideRank:true so they do not crowd Ranking or boot.

Replace the span between beginAnchor and endAnchor (inclusive) with newText. Cheaper than resending the whole body when editing a large block — send only the two anchors and the replacement. Both anchors must appear EXACTLY ONCE in the current body; the server rejects if either is missing or appears more than once (never guesses). beginAnchor must precede endAnchor. To delete a span: pass newText as empty string. Returns {id, length} as self-verify. memoryId accepts a short-form 8-char prefix. Works on artifacts too (artifactId IS memoryId) — a published artifact's public link is refreshed automatically. Optional expectedRev: the rev from the read you based these anchors on — the write is REJECTED (nothing written) if the body moved since. Omit for a read-then-immediately-write.

Append text to the END of a memory's body. Cheaper than resending the whole body — only send what's new. Use for growing changelogs, journals, session-state, or any memory that accumulates by accretion. separator defaults to '\n\n' (a blank line). Returns {id, length} as self-verify. memoryId accepts a short-form 8-char prefix. Works on artifacts too (artifactId IS memoryId) — a published artifact's public link is refreshed automatically. Optional expectedRev: the rev from your last read of this memory — the append is REJECTED (nothing written) if the body moved since, rather than landing on top of someone else's entry. Omit for a read-then-immediately-write, or when appending blind.

Permanently delete a memory by ID from all storage layers. memoryId may be the full UUID or a unique prefix of at least 8 characters, the same short form muninn_memory_get and _update accept; an ambiguous prefix is refused and lists the matching IDs, so nothing is deleted by guesswork.

Retrieve a single memory by its ID. Accepts a short-form ID (a prefix of the full UUID) — it is resolved to the full ID first. Also returns rev, the body's revision number (null if never indexed): pass it back as expectedRev on a later muninn_memory_update / _anchor_replace / _append and that write FAILS instead of clobbering an edit someone made in between. Only worth carrying when you read now and write later; a read-then-immediately-write needs nothing. Also opens a built-in Muninn skill: pass the full id from the end of its <muninn_skills> location and its instructions come back read-only, marked builtIn: true.

List all memories for the current user with optional pagination. Use muninn_memory_list_by_tag for tag filtering or muninn_memory_search for semantic search.

Find memories by exact tag match using the D1 tag index. All specified tags must be present (AND logic). Use for session-state, carryover, person profiles, project logs etc.

List every distinct tag for the current user with how many memories carry it, most-used first. The vocabulary/discovery counterpart to tag search — answers 'was it github-mirror or mirror-github?' in one call. Pass a project to scope counts to that project (plus global).

Query memories with composable filters: fetch by specific IDs, OR-tag match, AND-tag match, tag exclusion, and a date range. id, tag and time clauses are intersected — a memory must satisfy all provided clauses. A time clause alone is allowed: "what happened between 1 and 19 Oct" is time {from, to} with nothing else, answered from each memory's own timestamp, so it does not depend on date tags. With time set, results are ordered by that timestamp, newest first (order:"oldest" for a timeline from the start). For a topic inside a date range, use muninn_memory_search with time. Use for bundle content audits, convention checks, or any multi-condition fetch. IDs accept full UUIDs or unique 8-char prefixes; ambiguous/missing prefixes are reported in errors[], never silently dropped.

Semantically search memories using natural language. Returns the most relevant memories ranked by similarity. Pass project to search strictly within that project; omit it to search across all your memories. Pass time to search only memories from a date range ("what did we decide about pricing last week"): the range is applied first, then the matches inside it are ranked by similarity. The result then carries timeRange {exact, method, matched?}. exact:false (method nearest-100) means some memories in the range were not yet date-indexed and the range held more than 100, so only its members among your 100 nearest matches were ranked; narrow the range if that matters. Recently saved memories are date-indexed within minutes, after which every range is exact. Searches your own memories only, not team-shared ones, when time is set.

Find memories by PARTIAL tag match — each pattern matches any tag CONTAINING it (substring, case-insensitive). Semantics: OR within a pattern, AND across patterns — e.g. ['brd','mirror'] finds memories that have some brd-ish tag AND some mirror-ish tag. Use when you don't recall the exact tag ('mirror' → github-mirror, gdrive-mirror). For exact tags use muninn_memory_list_by_tag; to see the tag vocabulary use muninn_memory_list_tags.

Add and/or remove tags on a memory WITHOUT touching its text. Pass deltas, not the full list: add:[...] inserts (deduped), remove:[...] strips. NEVER regenerates the embedding (text is untouched), and you don't resend the existing tags or the body — so this is far cheaper than muninn_memory_update for a tag-only change. Returns compact {id, tags} with the resulting tag list. Use muninn_memory_update instead only when you also need to change text/project/decay, or to REPLACE the whole tag list wholesale. memoryId accepts a short-form 8-char prefix.

Apply tag adds and/or removes across MANY memories in one call. Body and embeddings are untouched. Use for project renames, bulk re-tagging, or applying a convention to a whole set. memoryIds accept full UUIDs or unique 8-char prefixes. Returns per-id results and any resolution errors.

Update an existing memory's text, tags, decay score, occurredAt, or project. memoryId may be a short-form (8-char) prefix. Two ways to change text: pass text to replace the WHOLE body, OR pass replacements:[{old,new}] for surgical find-and-replace — each old must match EXACTLY ONCE or the whole update is rejected atomically (nothing is written), so a two-line edit to a long memory costs one pair instead of resending thousands of words. Regenerates the embedding ONLY if text actually changes. tags REPLACES the whole list. Returns a compact {id, tags, project, updatedAt, embeddingRegenerated, length} — length is the stored char count, your self-verify signal (the body is never echoed back). When you used replacements, the result also carries replacements: so you can confirm how many spots were hit. For a tags-only edit, prefer muninn_memory_tag. hideRank:true takes a memory out of Ranking and boot's mostAccessed, false puts it back; omit it to leave it as it is. This is also how you EDIT AN ARTIFACT'S BODY — an artifact's artifactId IS its memoryId; there is no separate muninn_artifact_update. If the artifact is currently published, its public link is refreshed automatically. Optional expectedRev: pass the rev your last muninn_memory_get / muninn_artifact_get returned and the write is REJECTED (nothing written) if someone changed the body since you read it, instead of silently overwriting them. Omit it when you read and write in the same breath.

Start the connection flow for a mirror provider. Returns a URL for the user to open in their browser. After approving, call muninn_mirror_status to confirm. Paid plan. provider: 'gdrive' (Google Drive, push-only: copies out of Muninn, never back) is the working mirror; 'github' is not available yet and is refused.

Designate (or un-designate) a bundle for mirroring to a provider. Adds/removes the 'gdrive-mirror' tag on the bundle root's backing memory for Drive ('github-mirror' for GitHub). After designating, writes to that bundle automatically enqueue a mirror push. Use muninn_mirror_push to force one now. Turning mirroring on is Paid plan; turning it off (enabled=false) is always free. GitHub is not available yet: enabling it is refused, un-designating still works.

Queue one bundle for the next mirror push. Marks the bundle dirty; the scheduled push job (every 15 min) then writes its files to the connected Google Drive folder, which can update, trash or remove files there that the bundle no longer contains. Nothing is pushed during this call. If provider is omitted, queues for all connected providers. Paid plan; a lapsed account's mirror pauses until it pays again (files already mirrored stay). Only Google Drive is pushed today; 'github' is refused.

Manually trigger a mirror reconciliation pass: enqueues every memory the mirror has never seen and re-marks any that changed since their last push, so both re-push on the next cron tick. Useful after a gap or error. Returns enqueuedNew, markedDirty, scanned, and complete (false = the scan stopped on budget and resumes next run). Only Paid accounts are reconciled; a lapsed account's mirror is paused. Only Google Drive is actually pushed; GitHub rows still get queued but are never pushed (GitHub is not available yet).

Report mirror connection state and push health per provider. Shows connected, last push time, pending count, and last error. Pass provider to filter to one provider. Free on every plan. Google Drive is the working mirror; GitHub is not available yet, so a github entry (even connected: true) never pushes or pulls, and its pending count does not drain. On a lapsed (non-Paid) account pushes are paused, so pending can grow until it pays again.

Set up a brand-new Muninn account with the user. Call this when the user asks to set up Muninn, says they have just signed up, says their memory is empty, or when muninn_session_boot comes back with nothing in it. Returns {memoryCount, verified, hasIdentity, firstRunScript, starterInstruction}. memoryCount is what the user's Memory Map shows, so 0 means an empty map. firstRunScript is a three-question interview to run with the user, one question at a time, saving each answer with muninn_memory_add; do not paste it back at them. starterInstruction is an optional standing instruction, written for the assistant in use, that the user can paste into their own assistant settings if they want Muninn loaded at the start of every conversation. Offer it only after at least one memory is saved, or if they ask why their assistant does not use Muninn on its own, and tell them what it does before they paste it. verified:false means the account is read-only until the user clicks the link in their "Verify your Muninn account" email, so every save will be refused; say that plainly instead of running the interview. hasIdentity:true means an identity memory already exists, so do not re-run the interview unprompted.

Save photos YOU can already read as a picture memory: photos the user attached in this chat that are on your sandbox disk, or files in a working directory. Needs network access to https://munn.is; if your code cannot reach it, use muninn_picture_upload_start so the user picks them instead. Returns {memoryId, endpoint, header, how, expiresAt, maxFiles}. Upload each photo with one POST to endpoint, multipart/form-data with two file fields: 'orig' (the photo bytes, unchanged) and 'thumb' (a JPEG you make, long edge 480 px, at most 100 KB), plus the header. Up to 7 photos, JPEG, PNG or WebP, 10 MB each, within 15 minutes. Then call muninn_picture_view with memoryId and muninn_picture_upload_finish. Nothing is a memory until finish runs.

Write the picture memory after the user's photos arrived (check with muninn_picture_view first). The note is written in this session: what the photos show and what the moment was, in the user's words where you have them. Fill when, where and who only from what you actually know, and label each with its source: whenSource 'photo' (takenAt from muninn_picture_view), 'user' (they told you) or 'upload_time' (a photo just taken in the app, where upload time is capture time); whereSource 'user', 'device' (your device location tool, only when the user says the photo was taken here and now) or 'photo'. When the in-chat picker sent the fields, its labels map directly: 'When (from the photo's own metadata)' is whenSource 'photo', 'When (I said)' and 'Where (I said)' are 'user'. Never guess a place or a name from the pixels. The memory is tagged 'picture' plus your tags. Returns {success, memoryId, pictures}. Deleting this memory later deletes its photos.

Upload photos to Muninn: shows a photo picker inside the chat so the user picks the photos there, with nothing attached first. Use whenever the user wants to upload, save, add or keep a photo or picture in Muninn (a moment, a trip, a family picture) and has NOT already attached it in this chat. Never ask the user to attach a photo instead of calling this. If the photos are already attached here and your code can read them, use muninn_picture_upload_direct instead. Returns {memoryId, uploadUrl, expiresAt, maxFiles}. In chats that show app widgets a photo picker appears with this result and posts a message for the user when they finish; tell the user to pick photos in it, and give uploadUrl as a link in case no picker appears. Up to 7 photos, JPEG, PNG or WebP, 10 MB each, for 15 minutes. Photos picked this way keep their original date and camera. When the user is done, call muninn_picture_view with memoryId, then muninn_picture_upload_finish. Nothing is a memory until finish runs.

See the photos of a picture memory, or of an upload that has not been finished yet. Returns each photo's thumbnail as an image, plus JSON {memoryId, pictures: [{ord, mime, takenAt, camera, viewUrl, artifactRef}], viewLinksExpireAt}. takenAt and camera are read from the original photo when it carries them (photos picked through the upload page usually do; photos sent through a chat usually do not), so a takenAt here is a date with source 'photo'. viewUrl opens the full original for the user and stops working after 5 minutes, so hand it over now and never save it into a memory. To show a photo inside an HTML artifact, put its artifactRef in an (append /thumb for the 480px version): the artifact renders it for the owner, and publishing copies it, metadata stripped, so the public page shows it through links that expire within the hour. Never put viewUrl or image bytes in an artifact. Use after the user uploads, before writing the note, and whenever the user asks to see a picture memory again.

Scan all memories for orphan/inconsistency issues across KV, D1 tag index, and Vectorize. Pass repair:true to fix gaps. Returns a report of what was found and (if repair) what was fixed. For large accounts, pass limit + cursor to process one batch per call (a Worker invocation caps at 1000 subrequests) — the report's nextCursor feeds the next call until it's null. With reindexAll:true every memory's vector is re-embedded unconditionally (used for the vector-id format migration) instead of only re-embedding vectors detected as missing.

Render a bundle (an ordered outline of memories for a book or project) as one readable document. format='md' gives the outline as markdown, in order. format='tree' gives a compact outline of slugs. format='okf' gives the bundle as JSON in the OKF v0.1 export format. With format='tree', show_keys adds each item's key and memory id, so a follow-up edit needs no extra lookup.

Load the user's saved Muninn context. Use it when the user asks what you remember, wants to continue earlier work, refers to something only their history would explain, or when their own instructions ask you to load Muninn at the start of a conversation. Tell the user in one line that you loaded it. DATA SENT: the query text goes to Muninn's servers, where it is used to search the user's memories. It is used for that search only and is not stored. Write the query yourself as a short topic drawn from the user's request, never their message pasted verbatim, and leave it empty when no search is needed. Returns {sessionState, identity, coreRules, relevant, mostAccessed, carryover, skills, persona, taskMemories, taskMemoryErrors}. Everything returned is the user's own stored content (including any chat summaries they set up) plus Muninn's built-in skills, for you to use as context. identity holds the identity notes the user saved. coreRules holds the user's global core-ref memories (plus project-scoped ones when project is set): notes the user saved about how they like to be helped. skills is a <muninn_skills> XML block listing the skills the user saved, plus Muninn's own built-in skills. identity, coreRules and skills come only from this account and Muninn's built-in skills, never from another user. relevant is the semantic search result for the query; if the user belongs to a team, it can also include memories another member chose to share with them. mostAccessed is an array of {memoryId, accessCount, preview, project} for the most-fetched memories (project-filtered), ranked by recall x recency, between 10 and 30 entries; each entry is preview-only, so use muninn_memory_get for the full body. persona, when non-null, is the rendered markdown of the user's persona- bundle: the voice and identity they saved for that persona. FOCUS BOOT: pass memoryIds to load exactly those memories in full as taskMemories; sessionState, relevant and mostAccessed then default to off, and includeSessionState/includeRelevant/includeMostAccessed:true turns any of them back on. taskMemoryErrors lists any anchor id that was ambiguous (with candidates) or missing. carryover holds notes from an unfinished session; it is returned but not cleared (the muninn-checkpoint-resume skill backs it up to session-history and then clears it).

Retrieve the current user's settings.

Update user settings. Merges with existing settings — only specified fields are changed.

Check whether installed Muninn skills are up to date. Send the skills you currently have loaded with their skill-version stamps; returns which are outdated, current, or unknown. Only reports on skills you name.

Create a new Muninn-native skill from name, description, and body. Stores two memories (entry + body), wires them by ID, and makes the skill available in the next session_boot. Returns entryId and bodyId.

Permanently delete a Muninn-native skill by name. Removes both the entry and body memories from all storage layers.

List the skills saved in Muninn, as a <muninn_skills> XML block (name, description and location of each): this account's own skills, plus Muninn's built-in ones. Never another user's. Consult a skill when the user's request matches it: open its instructions with muninn_memory_get, passing the id at the end of its location. Use it to see the user's current skills mid-session, for example right after they create one.

Update an existing Muninn-native skill's body and/or description. Finds the skill by name, updates whichever fields are provided, regenerates embeddings. Does not recreate the memories.

Return aggregate corpus statistics for the current user — the shape of the whole memory, counted server-side (no pagination, no bodies read). Fields, in Muninn's own terms: memories (total); associations (bundle edges — the graph, split into contains/reference); bundleNodes and bundleRoots; identity (core-ref+identity memories); instructions (core-ref memories); personas (persona-* bundles); skills; projects and tags (distinct counts — Muninn's open-vocabulary axes, not a fixed type schema); plus byProject and byTag distributions. Use this to answer 'how big is my memory', to show a live corpus snapshot, or to compare against another memory system.

Declare a table (a kind of thing you want to track — Staff, Sources, Clients) and the fields its records share. Re-calling with the same slug UPDATES the definition: fields you pass replace the current set, so send the whole list, not a delta. Field key is permanent and is what record values are stored under; label is what a human sees and can be renamed freely. Mark a field private:true to keep it out of the grid, out of csv/xlsx export, and out of any team-shared view — private values never leave the encrypted record body. Field types: text, textarea, number, date, select, multi-select, checkbox, nested-table. Use textarea for anything that runs to more than a line — notes, a description, an address, a bio: it stores exactly like text and tells the app to give it a multi-line box instead of a single-line input.

Delete a table you declared: its definition and its list of records. The records themselves are kept as ordinary memories (returned as recordMemoryIds), so nothing the user wrote is lost; delete them with muninn_memory_delete only if the user asks. Call only when the user asks to delete or remove a table.

List this account's published tables with their addresses, field allowlists, locks and expiries - use when the user asks what data of theirs is public, which tables are published, or wants the URL of a feed again.

List every table you have declared, with its fields and how many records each holds. Counts are top-level records only — entries in a nested table are not counted as records of the parent table. Use this before adding a record, to check the table exists and to see what fields it expects.

Publish a table's records as a live public data feed and page - use when the user says publish this table, share this table, put this board online, give me a URL for this data, or wants a chart or dashboard to read a table without an agent copying it. Returns an unguessable munn.is link that serves the named fields as JSON at /raw and as a rendered table at . The copy stays LIVE: adding or editing a record updates what the link serves. YOU MUST NAME THE FIELDS - there is no way to publish every field, a field added later stays out until you publish again naming it, and a field marked private is refused. Records are capped at 1000 and a large table finishes assembling over one or more muninn_table_refresh calls. Optionally pass name for a readable address under the user's handle (a new name needs the Paid plan; the token link is free), password to gate it, and expiresAt to make it stop. muninn_table_unpublish revokes it.

Add a record to a table. values is keyed by field key (see muninn_table_list). Pass parentRecordId to file this as an entry in the nested table under an existing record — that is how a running log lives under a standing profile. Nesting is capped at one level: a record may hold a nested table, a nested record may not. Returns {recordId} — the record's memory id, which muninn_memory_get and muninn_memory_update accept.

Export a table's records - the other half of muninn_table_records_import, and what makes verifying one possible without resolving every record by hand. Returns recordId as the first column, then the table's fields in their declared order, so an export diffs directly against the file it came from. PRIVATE fields are excluded by default and are NEVER included in csv at all, whatever includePrivate says. Reading bodies costs one subrequest each, so pass limit/offset on a large table; the response says whether more remain.

Import MANY records into one table in a single call. dryRun is TRUE BY DEFAULT - the first call validates and reports what would be written, and nothing is saved until you call again with dryRun:false. Validates the whole batch before writing anything and returns every error at once with its record index, so a bad cell costs one round trip, not one per record. Nothing is coerced: a checkbox field wants true/false, not the string TRUE. Pass upsertKey (field keys forming a natural key) with onConflict:update to make re-running the same import idempotent instead of duplicating everything. Writes are BUDGETED per call - the response carries remaining and nextIndex, and you re-send the tail from there.

List the records in a table, in order. Pass parentRecordId instead to list the nested table under one record (its log). By default returns ids and positions only — cheap, no record bodies read. Pass resolve:true to also return each record's field values; private fields are excluded from resolved values.

Continue building a published table's public copy, or rebuild it from scratch - use after muninn_table_publish says records remain, or when a table was changed by something other than the record tools and the feed looks stale. Reads up to 100 record bodies per call and reports how many remain. In normal use a feed needs no refreshing at all: adding, editing and deleting records patch the public copy as they go.

Stop serving a published table - use when the user says unpublish this table, take this board down, revoke that data link, or make this private again. The address stops answering immediately and the public copy is deleted. The table and its records are untouched. A later publish mints a NEW link: the old one never comes back.

Create a task memory — a memory carrying task fields (entityType 'task'). Use for to-dos and calendar-shaped events, not for ordinary notes. taskType 'todo' uses dueDate; taskType 'event' uses startTime/endTime. recurrence is a raw RRULE string (RFC 5545, e.g. 'FREQ=WEEKLY;INTERVAL=2'), stored verbatim and passed through untouched. remindTauDays sets how early this task starts nagging (the urgency ramp) — bigger tasks can warn earlier than the global 3-day default; leave unset to use the default. calendarOnly true puts it on the calendar but never reminds about it (not at boot, not per call, not even overdue): use it for dates to know, not act on. Returns a compact {success, memoryId, length}, same shape as muninn_memory_add.

Mark a task complete. For a recurring task (recurrence set), this does NOT close it — it rolls dueDate forward to the next RRULE occurrence and keeps taskStatus at 'needs-action', so the task reappears for its next occurrence. Only simple FREQ=DAILY/WEEKLY/MONTHLY/YEARLY[;INTERVAL=n] rules can be rolled forward; a more complex RRULE (BYDAY, COUNT, UNTIL, etc.) falls back to closing the task as completed — the response's rolled field tells you which happened.

Permanently delete a task memory by ID from all storage layers. Same as muninn_memory_delete but named for the task workflow.

List task memories, filtered by project/status/due window. Backed by the D1 idx_due index (user_id, due_date, task_status), never a KV scan — cheap even at scale. Returns compact rows {memoryId, taskStatus, dueDate, project}; use muninn_memory_get for the full task body.

Snooze a task: hide it from reminders (session boot and per-call) until a given time. This is a statement about ONE task, not the whole reminder list. Pass EITHER until (an exact ISO 8601 instant) OR durationMinutes (snooze from now for N minutes) — not both. Hard rule: a snoozed task still reappears immediately once it reaches or passes its due date (urgency >= 1), even if snoozed_until hasn't arrived yet. Snoozing something that's already overdue has no visible effect for that reason. Pass until as '' (empty string) to clear an existing snooze.

Update a task's fields. Reuses the memory update path (text/tags/project all work as in muninn_memory_update), plus task-specific fields (taskStatus, dueDate, startTime, endTime, recurrence, reminders, remindTauDays, calendarOnly). Only pass the fields you want changed. taskId may be a short-form 8-char prefix.

Add a user to a team as a member. Caller must be the team owner. Paid plan only: both the owner and the person being added must be on the paid plan. To make someone an owner, use muninn_team_transfer_owner.

Create a new team. The caller becomes the owner and first member. Returns the new teamId. Paid plan only.

Delete a team permanently. This cannot be undone. Caller must be the team owner. Removes all members, share rules, and (for an encrypted team) the team keys. Ask the user to confirm first, then pass the team's exact name as confirmName; a name that does not match is refused and nothing is deleted.

Invite someone to a team by email. Caller must be the team owner, on the paid plan. For an encrypted team, the invite carries the team key wrapped to a single-use token so the invitee can read team memories once they accept.

Join a team you were invited to, using the invitation from the email sent to you. After joining, you can read the memories the team shares. If your plan doesn't include teams, the invitation is refused and stays open for later.

List pending invites for a team. Caller must be the team owner.

List the teams the user belongs to, as owner or member. Use it to find a teamId before sharing memories, inviting someone, or listing a team's shares or invites. Returns {teams: [{teamId, name, createdBy, createdAt}]}. An empty list means the user is in no team.

Remove a member from a team. Caller must be the team owner (or removing themselves). The sole owner cannot be removed — transfer ownership or delete the team first. Available on every plan.

Share all memories with a given tag into a team. Team members will see these memories in their search and session boot results automatically. Paid plan only (removing a share with muninn_team_share_remove is free).

Revoke a share rule. Only the owner of the share rule (or team owner) can remove it.

List all active share rules for a team. Shows which tags each member has shared.

Transfer team ownership to an existing member. The caller (current owner) is demoted to member. A team always has exactly one owner.