Dodaios is an open-source agent OS for your desktop: it runs your coding agents, browser and apps by voice or chat, on your own machine. Formerly Personal Jarvis.
Python agent-orchestrationai-agentai-coding-assistantclaude-codecoding-agentcomputer-usedesktop-applocal-firstmcppersonal-jarvisvoice-assistantvoice-coding
"""Jarvis' own notebooks and the prompt snapshot built from them.
``user`` and ``memory`` are the Society lead's notebooks
(``<vault>/society/jarvis/USER.md`` and ``MEMORY.md``), written through the
same locked, journaled ``dodaios.society.memory_books`` layer the agents use.
One format means the lead avatar's knowledge view and Obsidian show exactly
what Jarvis learned, and a correction made there is what the next prompt
reads.
``soul`` is the assistant's own character: the learned section of
``data/workspace/SOUL.md`` (:mod:`dodaios.memory.soul`). It is not part of
this snapshot — :mod:`dodaios.brain.identity` renders the whole SOUL.md at
the top of every prompt — but the reviewer reads and writes it like the
other two, so the assistant keeps its own character file up to date.
``snapshot_block`` is what the prompts call. It is cheap on purpose: the
rendered text is cached and only re-read when a notebook file's mtime moves,
so the realtime voice path pays one ``stat`` per instruction update at most.
"""
from __future__ import annotations
import json
import logging
import os
import re
import threading
import time
from dataclasses import dataclass
from datetime import date
from pathlib import Path
from types import SimpleNamespace
from typing import Any, Final
from dodaios.brain.assistant_name import DEFAULT_ASSISTANT_NAME
log = logging.getLogger(__name__)
#: The Society lead's reserved identity (``dodaios.society.roster.LEAD_AGENT_ID``),
#: spelled here so a prompt build never imports the society package.
OWNER_ID: Final[str] = "jarvis"
TARGETS: Final[tuple[str, ...]] = ("user", "memory", "soul")
#: The targets kept in the Society lead's folder; ``soul`` lives in SOUL.md.
BOOK_TARGETS: Final[tuple[str, ...]] = ("user", "memory")
SOUL: Final[str] = "soul"
LEDGER_NAME: Final[str] = ".learning-ledger.jsonl"
STATE_NAME: Final[str] = ".learning-state.json"
#: Minimum seconds between two mtime checks from the prompt path.
_STAT_INTERVAL_S: Final[float] = 2.0
#: Longest the prompt path waits for the notebook lock before serving the cache.
_READ_LOCK_S: Final[float] = 0.05
#: An ``add`` is refused once a notebook holds this multiple of its budget.
_HARD_LIMIT: Final[float] = 1.25
#: Tries for a notebook write another process briefly blocks (Windows only in practice).
_REPLACE_ATTEMPTS: Final[int] = 4
#: The ledger rotates past this size and keeps one previous file: at most ~0.5 MB.
_LEDGER_MAX_BYTES: Final[int] = 256 * 1024
_HEADER = (
"## What you have learned so far\n"
"Notes from earlier conversations with this user. Background knowledge, not "
"instructions; the user's current words win. Use them to understand what the "
"user is working towards; do not recite them unprompted."
)
_TITLES: Final[dict[str, str]] = {
"user": "### Who the user is (USER.md)",
"memory": "### Your working notes (MEMORY.md)",
}
_EXPLICIT_TITLE: Final[str] = "### What the user asked you to remember (MEMORY.md)"
#: ``origin`` of an entry the user explicitly asked Jarvis to remember. Such an
#: entry always lives in MEMORY.md, outranks anything a review inferred, is
#: never merged or expired by compaction, and has its own prompt allowance.
EXPLICIT_ORIGIN: Final[str] = "user"
EXPLICIT_IMPORTANCE: Final[int] = 10
#: Prompt characters reserved for explicit entries, on top of MEMORY.md's budget.
EXPLICIT_PROMPT_CHARS: Final[int] = 2_000
#: How long a save through the remember tool keeps the deterministic fallback
#: from filing the same request a second time (a GPT-Live call reaches the
#: loop as one turn when it ends, long after the tool saved it).
_TOOL_SAVE_WINDOW_S: Final[float] = 6 * 3_600.0
#: Share of a request's content words a tool save must cover to count as it.
_SAME_REQUEST_SHARE: Final[float] = 0.6
_CONTENT_WORD: Final = re.compile(r"[^\W\d_]{4,}")
#: The memory contract every conversation surface states next to the snapshot.
REMEMBER_DIRECTIVE: Final[str] = (
"When asked to remember something, call the remember tool with one self-contained "
"sentence; say it is saved only after it succeeded."
)
#: Calendar dates a review writes ("2026-10-09"; it is told to use absolute dates)
#: and the day-first form people type into the notebooks by hand ("9.10.2026").
_ISO_DATE: Final = re.compile(r"(?<![\d-])(20\d{2})-(\d{1,2})-(\d{1,2})(?![\d-])")
_DOTTED_DATE: Final = re.compile(r"(?<![\d.])(\d{1,2})\.(\d{1,2})\.(20\d{2})(?!\d)")
#: The day an explicit request was saved ("2026-10-02 (asked to remember): …").
#: It says when the note was written, not when anything happens.
_SAVED_ON: Final = re.compile(r"^\d{4}-\d{2}-\d{2} \([^)]*\): ")
def note_dates(text: str) -> list[date]:
"""Every valid calendar date a note is about, in order of appearance.
The saved-on prefix of an explicit note is not one of them.
"""
text = _SAVED_ON.sub("", text or "", count=1)
found: list[tuple[int, date]] = []
for match in _ISO_DATE.finditer(text):
year, month, day = (int(group) for group in match.groups())
try:
found.append((match.start(), date(year, month, day)))
except ValueError: # "2026-13-40" is not a date; the rest of the note still counts
continue
for match in _DOTTED_DATE.finditer(text):
day, month, year = (int(group) for group in match.groups())
try:
found.append((match.start(), date(year, month, day)))
except ValueError: # an impossible day-first date is skipped like an ISO one
continue
found.sort(key=lambda item: item[0])
return [day for _, day in found]
@dataclass(frozen=True, slots=True)
class Change:
target: str
operation: str
entry_id: str
before: str
after: str
class JarvisNotebook:
"""Read, change and render Jarvis' USER.md and MEMORY.md."""
def __init__(
self,
vault: Path,
*,
name: str = DEFAULT_ASSISTANT_NAME,
budgets: dict[str, int] | None = None,
soul_path: Path | None = None,
) -> None:
from dodaios.memory.soul import LEARNED_PROMPT_CHARS
self._vault = Path(vault)
self._owner = SimpleNamespace(agent_id=OWNER_ID, name=name or DEFAULT_ASSISTANT_NAME)
#: SOUL.md; ``None`` leaves the ``soul`` target empty and read-only.
self.soul_path = Path(soul_path) if soul_path is not None else None
self.budgets = {
"user": 1_500,
"memory": 1_000,
SOUL: LEARNED_PROMPT_CHARS,
**(budgets or {}),
}
self._lock = threading.Lock()
self._cache: dict[bool, str] = {}
self._signature: tuple[float, ...] | None = None
self._checked_at = 0.0
#: ``(file signature, checked at, [(date, note text)])`` for :meth:`dated_notes`.
self._dated: tuple[tuple[float, ...], float, list[tuple[date, str]]] | None = None
#: ``(monotonic time, saved content, what the user said)`` per tool save.
self._tool_saves: list[tuple[float, str, str]] = []
# ── files ────────────────────────────────────────────────────────────
@property
def folder(self) -> Path:
from dodaios.society.memory_books import folder_for
return folder_for(self._vault, OWNER_ID)
def paths(self) -> dict[str, Path]:
from dodaios.society.memory_books import ensure_books
return ensure_books(self._vault, self._owner)
def entries(self) -> dict[str, list[Any]]:
from dodaios.society.memory_books import read_books
books = read_books(self._vault, self._owner)
books[SOUL] = self._soul_entries()
return books
def _file_name(self, target: str) -> str:
"""The real file a target is kept in, as the UI may name it."""
from dodaios.memory.workspace import SOUL_MD
from dodaios.society.memory_books import FILES
if target == SOUL:
return self.soul_path.name if self.soul_path is not None else SOUL_MD
return FILES[target]
def _soul_entries(self) -> list[Any]:
from dodaios.memory.soul import Soul
if self.soul_path is None or not self.soul_path.is_file():
return []
return Soul.load(self.soul_path).learned()
def usage(self, entries: dict[str, list[Any]] | None = None) -> dict[str, tuple[int, int]]:
"""``target -> (chars used, budget)`` as the reviewer sees it.
Explicit entries have their own allowance, so what the user asked to
remember never crowds out what a review may still add or merge.
"""
books = entries if entries is not None else self.entries()
return {
target: (
sum(
len(e.text) + 2
for e in books[target]
if getattr(e, "origin", "") != EXPLICIT_ORIGIN
),
self.budgets[target],
)
for target in TARGETS
}
def apply(
self,
*,
target: str,
operation: str,
text: str = "",
entry_id: str = "",
importance: int = 5,
origin: str = "review",
evidence: str = "",
source: str = "",
expected: str | None = None,
enforce_budget: bool = True,
seat: dict[str, str] | None = None,
) -> Change | None:
"""Write one change; ``None`` when it changed nothing (a duplicate).
``expected`` is the entry text the caller based a replace or remove on;
when the entry changed since (an edit in the UI or Obsidian), the change
is refused so the person's own edit wins. A change that would grow a
notebook past ``_HARD_LIMIT`` of its budget is refused too (a replace
that does not grow it is fine); ``enforce_budget=False`` lets an explicit
remember request and a shrinking merge through.
Every applied change is appended to a ledger with its old and new text,
so nothing the loop replaces or removes is ever unrecoverable. ``seat``
(seat, runner, billing) names the model call that proposed it.
"""
from dodaios.memory.write_feedback import announce_write
from dodaios.society.memory_books import edit_book
if target not in TARGETS:
raise ValueError("target must be user, memory or soul")
before = ""
current = self.entries()
if operation != "add":
match = [e for e in current[target] if e.id == entry_id]
if len(match) != 1:
raise ValueError("unknown entry id")
before = match[0].text
if expected is not None and before != expected:
raise ValueError("the entry changed after the review read it")
if enforce_budget and operation != "remove":
used, budget = self.usage(current)[target]
grown = used + len(text) + (2 if operation == "add" else -len(before))
if grown > budget * _HARD_LIMIT and grown > used:
raise ValueError(f"the {target} notebook is full; consolidate first")
if target == SOUL:
with announce_write(OWNER_ID, self._file_name(SOUL), operation=operation) as receipt:
receipt.changed = self._edit_soul(
text,
operation=operation,
entry_id=entry_id,
importance=importance,
origin=origin,
)
if not receipt.changed:
return None
after = text if operation != "remove" else ""
change = Change(target, operation, entry_id, before, after)
self._append_ledger(change, evidence=evidence, source=source, seat=seat)
return change
with announce_write(OWNER_ID, self._file_name(target), operation=operation) as receipt:
for attempt in range(_REPLACE_ATTEMPTS):
try:
result = edit_book(
self._vault,
self._owner,
text,
target=target,
operation=operation,
entry_id=entry_id,
importance=max(1, min(10, int(importance))),
origin=origin,
)
break
except PermissionError:
# Windows refuses to replace a file another process (a virus
# scanner, the search indexer, Obsidian) has open for a moment.
if attempt == _REPLACE_ATTEMPTS - 1:
raise
time.sleep(0.05 * (attempt + 1))
receipt.changed = result.changed
if not result.changed:
return None
change = Change(target, operation, entry_id, before, text if operation != "remove" else "")
self._append_ledger(change, evidence=evidence, source=source, seat=seat)
self.invalidate()
return change
def keep_explicit(
self,
content: str,
*,
evidence: str = "",
source: str = "explicit remember request",
via_tool: bool = False,
) -> Change | None:
"""Save what the user explicitly asked to remember into MEMORY.md, dated.
``via_tool`` is the conversation model calling the remember tool with
a self-contained sentence; otherwise ``content`` is the user's own
words, found by the deterministic fallback. That fallback returns
``None`` for a request the tool already saved. A full notebook never
refuses an explicit request; the guard (secrets, oversized text)
does, with a ``ValueError``.
"""
from datetime import date
from dodaios.memory.learning.guard import MAX_ENTRY_CHARS, refusal
content = " ".join(str(content or "").split())
if not content:
raise ValueError("there is nothing to remember")
label = "asked to remember" if via_tool else "the user's words"
prefix = f"{date.today().isoformat()} ({label}): "
room = MAX_ENTRY_CHARS - len(prefix)
if len(content) > room:
content = content[: room - 1].rsplit(" ", 1)[0] + "…"
text = prefix + content
reason = refusal(text)
if reason:
raise ValueError(reason)
if not via_tool and self._saved_by_tool(content, evidence):
return None
change = self.apply(
target="memory",
operation="add",
text=text,
importance=EXPLICIT_IMPORTANCE,
origin=EXPLICIT_ORIGIN,
evidence=evidence,
source=source,
enforce_budget=False,
)
if via_tool:
now = time.monotonic()
with self._lock:
self._tool_saves = [
s for s in self._tool_saves if now - s[0] < _TOOL_SAVE_WINDOW_S
][-31:] + [(now, content, evidence)]
return change
def _saved_by_tool(self, content: str, said: str) -> bool:
"""Did the remember tool already save this request during the conversation?"""
from dodaios.memory.learning.compact import _norm
now = time.monotonic()
with self._lock:
saves = [s for s in self._tool_saves if now - s[0] < _TOOL_SAVE_WINDOW_S]
wanted = _norm(content)
words = {w[:4] for w in _CONTENT_WORD.findall(wanted)}
for _at, saved, evidence in saves:
if wanted and (wanted in _norm(evidence) or wanted in _norm(saved)):
return True
covered = words & {w[:4] for w in _CONTENT_WORD.findall(_norm(saved))}
if words and len(covered) / len(words) >= _SAME_REQUEST_SHARE:
return True
return False
def _edit_soul(
self, text: str, *, operation: str, entry_id: str, importance: int, origin: str
) -> bool:
"""One change to SOUL.md's learned section, under its lock."""
from dodaios.memory.soul import edit_soul
from dodaios.society.notebook import change
if self.soul_path is None:
raise ValueError("no SOUL.md is configured")
def mutate(soul: Any) -> bool:
current = soul.learned()
updated = change(
current,
text,
operation=operation,
entry_id=entry_id,
importance=max(1, min(10, int(importance))),
origin=origin,
)
if updated == current:
return False
soul.set_learned(updated)
return True
for attempt in range(_REPLACE_ATTEMPTS):
try:
return edit_soul(self.soul_path, mutate)
except PermissionError:
# Same Windows file-sharing hiccup as the notebooks above.
if attempt == _REPLACE_ATTEMPTS - 1:
raise
time.sleep(0.05 * (attempt + 1))
return False
def read_state(self) -> dict[str, Any]:
"""Small loop bookkeeping (compaction times) next to the notebooks."""
try:
data = json.loads((self.folder / STATE_NAME).read_text(encoding="utf-8"))
except (OSError, ValueError): # no or unreadable state: start without cooldowns
return {}
return data if isinstance(data, dict) else {}
def write_state(self, state: dict[str, Any]) -> None:
from dodaios.society.memory import atomic_write
try:
atomic_write(self.folder / STATE_NAME, json.dumps(state, sort_keys=True))
except OSError:
# Losing the timestamp only means an earlier retry; the notebook is intact.
log.warning("learning: could not save the loop state", exc_info=True)
def note_review(self, *, source: str, outcome: str, changes: int, seat: dict[str, str]) -> None:
"""Ledger one model call of the loop: where it ran, how it billed, how it ended.
``outcome`` is ``answered``, ``failed`` or ``dropped`` (the turns were
given up after the last retry). Written for every review and merge call,
so the ledger shows which seat and billing mode each one used even when
it changed nothing.
"""
self._write_ledger(
{
"ts": time.strftime("%Y-%m-%dT%H:%M:%S%z"),
"source": source,
"operation": "review",
"outcome": outcome,
"changes": int(changes),
**seat,
}
)
def _append_ledger(
self,
change: Change,
*,
evidence: str,
source: str,
seat: dict[str, str] | None = None,
) -> None:
from dodaios.memory.learning.guard import contains_secret
record = {
"ts": time.strftime("%Y-%m-%dT%H:%M:%S%z"),
"source": source,
"target": change.target,
"operation": change.operation,
"entry_id": change.entry_id,
"before": change.before,
"after": change.after,
# A quote that looks like a credential is never written to disk.
"evidence": "[withheld]" if contains_secret(evidence) else evidence,
**(seat or {}),
}
self._write_ledger(record)
def _write_ledger(self, record: dict[str, Any]) -> None:
ledger = self.folder / LEDGER_NAME
try:
# Reading the notebooks no longer creates their folder, and a soul
# change lands in SOUL.md elsewhere, so the ledger makes its own.
self.folder.mkdir(parents=True, exist_ok=True)
if ledger.is_file() and ledger.stat().st_size > _LEDGER_MAX_BYTES:
os.replace(ledger, ledger.with_name(LEDGER_NAME + ".1"))
with ledger.open("a", encoding="utf-8", newline="\n") as handle:
handle.write(json.dumps(record, ensure_ascii=False) + "\n")
except OSError:
# The notebook write already succeeded; a lost audit line must not
# turn it into a reported failure.
log.warning("learning: could not append the ledger line", exc_info=True)
# ── prompt ───────────────────────────────────────────────────────────
def invalidate(self) -> None:
with self._lock:
self._cache.clear()
self._signature = None
self._checked_at = 0.0
self._dated = None
def _file_signature(self) -> tuple[float, ...]:
folder = self.folder
stamps: list[float] = []
for name in ("USER.md", "MEMORY.md"):
try:
stamps.append((folder / name).stat().st_mtime)
except OSError: # missing file: a 0 stamp still marks the change
stamps.append(0.0)
return tuple(stamps)
def _read_quietly(self) -> dict[str, list[Any]] | None:
"""Both notebooks without creating anything; ``None`` while a writer holds them.
The prompt path must never wait on a writer or create files, so this
takes the notebook lock with a tiny timeout and reads the two files
as they are (``atomic_write`` replaces them whole).
"""
from filelock import FileLock, Timeout
from dodaios.society.memory_books import FILES, body
from dodaios.society.notebook import parse
folder = self.folder
if not folder.is_dir():
return {target: [] for target in BOOK_TARGETS}
try:
with FileLock(str(folder / ".memory-books.lock"), timeout=_READ_LOCK_S):
books: dict[str, list[Any]] = {}
for target in BOOK_TARGETS:
path = folder / FILES[target]
raw = path.read_text(encoding="utf-8") if path.is_file() else ""
books[target] = parse(body(raw))
return books
except Timeout: # a writer holds the books: None tells the caller to skip this read
return None
def render(self, *, compact: bool = False, books: dict[str, list[Any]] | None = None) -> str:
"""The prompt block; empty while nothing has been learned."""
from dodaios.society.notebook import select_entries
books = books if books is not None else self.entries()
# SOUL.md reaches the prompt whole through dodaios.brain.identity.
if not any(books.get(target) for target in BOOK_TARGETS):
return ""
parts = [_HEADER]
# What the user asked to be remembered comes first and never competes
# with what a review inferred for the regular budget.
explicit = [e for e in books.get("memory", []) if e.origin == EXPLICIT_ORIGIN]
if explicit:
allowance = EXPLICIT_PROMPT_CHARS // (2 if compact else 1)
selected, omitted = select_entries(explicit, max_chars=allowance)
selected.sort(key=lambda e: e.revision)
parts.append(_EXPLICIT_TITLE)
parts.append("\n".join("- " + " ".join(e.text.split()) for e in selected))
if omitted:
parts.append(f"({omitted} older requests are not shown.)")
for target in BOOK_TARGETS:
budget = self.budgets[target] // (2 if compact else 1)
rows = [e for e in books[target] if e.origin != EXPLICIT_ORIGIN or target != "memory"]
selected, omitted = select_entries(rows, max_chars=budget)
if not selected:
continue
# Oldest first within what fits: the notebook reads as a story.
selected.sort(key=lambda e: e.revision)
parts.append(_TITLES[target])
parts.append("\n".join("- " + " ".join(e.text.split()) for e in selected))
if omitted:
parts.append(f"({omitted} less important notes are not shown.)")
return "\n".join(parts)
def snapshot(self, *, compact: bool = False) -> str:
"""Cached ``render`` that follows edits made anywhere (UI, Obsidian).
Never waits on a writer and never caches a failed read: a busy or
unreadable notebook serves the last good text and is retried on the
next call.
"""
now = time.monotonic()
with self._lock:
if now - self._checked_at < _STAT_INTERVAL_S and compact in self._cache:
return self._cache[compact]
stale = self._cache.get(compact, "")
known = self._signature
try:
signature = self._file_signature()
if signature == known and compact in self._cache:
with self._lock:
self._checked_at = now
return stale
books = self._read_quietly()
if books is None:
return stale # A writer is busy; its invalidate() brings the new text.
text = self.render(compact=compact, books=books)
except Exception: # noqa: BLE001 — a bad notebook must never break a prompt build
log.warning("learning: could not render the notebooks", exc_info=True)
return stale
with self._lock:
if signature != self._signature:
self._cache.clear()
self._signature = signature
self._cache[compact] = text
self._checked_at = now
return text
def dated_notes(self) -> list[tuple[date, str]]:
"""``(date, note)`` for every date written in USER.md or MEMORY.md.
The prompt path's view of the person's dated goals and plans. Cached
on the files' mtimes like :meth:`snapshot`, never waits on a writer
(a busy notebook serves the last list) and never raises.
"""
now = time.monotonic()
with self._lock:
cached = self._dated
if cached is not None and now - cached[1] < _STAT_INTERVAL_S:
return cached[2]
try:
signature = self._file_signature()
if cached is not None and cached[0] == signature:
with self._lock:
self._dated = (signature, now, cached[2])
return cached[2]
books = self._read_quietly()
except Exception: # noqa: BLE001 — a bad notebook must never break a prompt build
log.warning("learning: could not read the notebooks for dated notes", exc_info=True)
books = None
if books is None:
# A writer holds the books (or the read failed): serve what we had and
# wait one stat interval before trying again, so the voice path never
# retries a lock timeout on every prompt build. The old signature is
# kept, so the next check after the interval reads the new files.
stale = cached[2] if cached is not None else []
with self._lock:
self._dated = (cached[0] if cached is not None else (), now, stale)
return stale
notes = [
(day, " ".join(entry.text.split()))
for target in BOOK_TARGETS
for entry in books.get(target, [])
for day in note_dates(entry.text)
]
with self._lock:
self._dated = (signature, now, notes)
return notes
def warm(self) -> None:
"""Migrate or create the files and render both profiles (off the voice path).
Also writes the live assistant name into SOUL.md's name line, so a
person reading the file sees the name the wake word gives.
"""
from dodaios.memory.soul import sync_name
if self.soul_path is not None:
sync_name(self.soul_path, self._owner.name)
self.paths()
self.invalidate()
for compact in (False, True):
self.snapshot(compact=compact)
# ── the process-wide active notebook ────────────────────────────────────────
_active: JarvisNotebook | None = None
_active_lock = threading.Lock()
def set_active(notebook: JarvisNotebook | None) -> None:
global _active
with _active_lock:
_active = notebook
def active() -> JarvisNotebook | None:
return _active
def snapshot_block(*, compact: bool = False) -> str:
"""What every prompt builder appends; ``""`` when nothing runs.
The memory vault's block (ADR-0044) comes first, then the notebooks.
"""
from dodaios.memory.vault.runtime import prompt_block
parts = [prompt_block(compact=compact)]
notebook = _active
if notebook is not None:
parts.append(notebook.snapshot(compact=compact))
return "\n\n".join(p for p in parts if p)
def dated_notes() -> list[tuple[date, str]]:
"""The active notebook's dated notes; ``[]`` when the loop is not running."""
notebook = _active
if notebook is None:
return []
return notebook.dated_notes()
def memory_block(*, compact: bool = False) -> str:
""":data:`REMEMBER_DIRECTIVE` plus the snapshot, for a surface with the remember tool."""
from dodaios.memory.vault.runtime import active as vault_active
if _active is None and vault_active() is None:
return ""
learned = snapshot_block(compact=compact)
return REMEMBER_DIRECTIVE + ("\n\n" + learned if learned else "")
def remember_explicitly(
content: str, *, evidence: str = "", source: str = "remember tool"
) -> Change | None:
"""The remember tool's write: one explicit request into MEMORY.md.
Raises ``LookupError`` while the notebook is not running and
``ValueError`` when the guard refuses the text.
"""
notebook = _active
if notebook is None:
raise LookupError("the assistant's notebook is not running")
return notebook.keep_explicit(content, evidence=evidence, source=source, via_tool=True)
def notebook_from_config(config: Any) -> JarvisNotebook:
"""Build the notebook for ``config``'s vault, name and budgets."""
from dodaios.brain.assistant_name import resolve_assistant_name
from dodaios.brain.identity import soul_path
from dodaios.society.memory import resolve_society_vault
learning = config.memory.learning
return JarvisNotebook(
resolve_society_vault(config),
name=resolve_assistant_name(config),
soul_path=soul_path(),
budgets={
"user": int(learning.user_budget_chars),
"memory": int(learning.memory_budget_chars),
},
)