llmwiki2 0.4.1__py3-none-any.whl

llmw2/__init__.py

@@ -0,0 +1,54 @@
+# Copyright 2026 Federico Cesarini, Marco Sassarini
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+"""An LLM wiki that writes Open Knowledge Format bundles.
+
+A Librarian files sources into a folder tree of notes, a Researcher answers
+questions from it; in CROW mode a typed classifier takes the decisions and the
+LLM only writes text.
+"""
+
+from __future__ import annotations
+
+__version__ = "0.4.1"
+
+from llmw2.agents.data import Candidate, NoteDraft, Route, Source
+from llmw2.agents.steps import CLASSIC, CROW, StepContext, Steps
+from llmw2.audit import AUDIT_MIN, FolderHealth, RouteProposal
+from llmw2.batch import BatchReport, Item
+from llmw2.bundle.origin import Origin
+from llmw2.config import WikiConfig
+from llmw2.errors import ConfigError, InputError, ModelError, StepError, WikiError
+from llmw2.sources import Change, ChangeBatch, LocalFolderSource, SourceConnector, SyncReport, sync
+from llmw2.wiki import Wiki
+
+__all__ = [
+    "AUDIT_MIN",
+    "CLASSIC",
+    "CROW",
+    "BatchReport",
+    "Candidate",
+    "Change",
+    "ChangeBatch",
+    "ConfigError",
+    "FolderHealth",
+    "InputError",
+    "Item",
+    "LocalFolderSource",
+    "ModelError",
+    "NoteDraft",
+    "Origin",
+    "Route",
+    "RouteProposal",
+    "Source",
+    "SourceConnector",
+    "StepContext",
+    "StepError",
+    "Steps",
+    "SyncReport",
+    "Wiki",
+    "WikiConfig",
+    "WikiError",
+    "__version__",
+    "sync",
+]

llmw2/__main__.py

@@ -0,0 +1,8 @@
+# Copyright 2026 Federico Cesarini, Marco Sassarini
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+import sys
+
+from llmw2.cli import main
+
+sys.exit(main())

llmw2/agents/__init__.py

@@ -0,0 +1,4 @@
+# Copyright 2026 Federico Cesarini, Marco Sassarini
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+"""The Librarian and the Researcher, classic and CROW, with the prompts they send."""

llmw2/agents/base.py

@@ -0,0 +1,51 @@
+# Copyright 2026 Federico Cesarini, Marco Sassarini
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+"""What the steps share: the trace of decisions and the helpers every prompt and flow uses."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from dataclasses import dataclass, field
+from typing import Literal, TypeVar
+
+from llmw2.bundle.tree import Folder, Note, slugify
+
+T = TypeVar("T")
+
+
+@dataclass
+class Decision:
+    """One decision of an ingest or a question, kept to calibrate thresholds (CROW §5.3)."""
+
+    step: str  # route, match, consolidate, relate, navigate, select, …
+    decider: Literal["llm", "classifier", "rule", "code"]  # "code": a check the code makes alone (revisions)
+    choice: str
+    confidence: float | None = None
+    fallback: bool = False  # the classifier was not confident (or failed) and the LLM decided
+    scores: dict[str, float] = field(default_factory=dict)  # classifier probability per option / candidate
+
+
+def list_folders(folders: list[Folder]) -> str:
+    """`- name: description` lines, the way every prompt shows folders."""
+    return "\n".join(f"- {f.name}: {f.description or '(no description)'}" for f in folders) or "(none)"
+
+
+def list_notes(notes: list[Note]) -> str:
+    """`- path: Title — summary` lines, the way every prompt shows notes."""
+    return "\n".join(f"- {n.rel}: {n.title} — {n.summary}" for n in notes) or "(none)"
+
+
+def unique_objects(items: Iterable[T]) -> list[T]:
+    """Keep the first occurrence of each object, in order."""
+    seen: set[int] = set()
+    out = []
+    for item in items:
+        if id(item) not in seen:
+            seen.add(id(item))
+            out.append(item)
+    return out
+
+
+def clean_tags(tags: list[str]) -> list[str]:
+    return list(dict.fromkeys(t for t in (slugify(t, max_len=30, fallback="") for t in tags) if t))[:6]

llmw2/agents/conflicts.py

@@ -0,0 +1,47 @@
+# Copyright 2026 Federico Cesarini, Marco Sassarini
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+"""When the notes read to answer a question disagree on its answer, the answer must report every value (CROW).
+
+One typed question reads the passage of each note that is closest to the question; if it says the notes disagree,
+the answer step gets a hint added to the question.
+"""
+
+from __future__ import annotations
+
+import re
+
+from llmw2.bundle.tree import Note
+
+__all__ = ["CONFLICT", "CONFLICT_HINT", "CONFLICT_MIN", "MAX_NOTES", "PASSAGE_CHARS", "conflict_state"]
+
+CONFLICT_MIN = 0.4  # the probability that the notes disagree, above which the hint is added
+PASSAGE_CHARS = 900
+MAX_NOTES = 8
+
+CONFLICT = "The notes do not all agree on the answer to the question: at least one gives a value that another contradicts."
+CONFLICT_HINT = (  # added to the question of the answer step, after the history hint if there is one
+    "(The notes may disagree on this. If two notes give different values for what the question asks, report every value, "
+    "say which note gives which and which source is more recent, and do not pick one silently.)"
+)
+
+_WORD = re.compile(r"\w{3,}")
+_BLANK_LINE = re.compile(r"\n\s*\n")
+
+
+def _words(text: str) -> set[str]:
+    return set(_WORD.findall(text.lower()))
+
+
+def _passage(question: str, note: Note) -> str:
+    """The paragraph of the note that shares most words with the question (the first on a tie), cut."""
+    paragraphs = [p.strip() for p in _BLANK_LINE.split(note.main_body()) if p.strip()]
+    asked = _words(question)
+    best = max(paragraphs, key=lambda p: len(asked & _words(p)), default="")  # max keeps the first of equals
+    return best[:PASSAGE_CHARS]
+
+
+def conflict_state(question: str, notes: list[Note]) -> str:
+    """The question and, for each of the first `MAX_NOTES` notes, its title and the passage closest to the question."""
+    blocks = [f"### Note: {n.title}\n{_passage(question, n)}" for n in notes[:MAX_NOTES]]
+    return f"Question: {question}\n\n" + "\n\n".join(blocks)

llmw2/agents/data.py

@@ -0,0 +1,56 @@
+# Copyright 2026 Federico Cesarini, Marco Sassarini
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+"""The data the steps pass to one another: a source, the candidate note, a route, a rewritten note."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from pydantic import BaseModel
+
+from llmw2.bundle.origin import Origin
+from llmw2.bundle.tree import Folder
+
+
+@dataclass
+class Source:
+    text: str
+    title: str | None = None
+    resource: str | None = None  # URL or path of the original, if any
+    origin: Origin | None = None  # where the original lives at its source, if it has one
+    fields: dict[str, Any] = field(default_factory=dict)  # user data, uninterpreted by the core
+
+
+@dataclass
+class Candidate:
+    """The note an ingest would write (CROW step 0)."""
+
+    title: str
+    summary: str
+    tags: list[str]
+    body: str
+    fields: dict[str, Any] = field(default_factory=dict)  # written to the note's frontmatter under `fields:`
+    state: str = ""  # what the routing decisions read; empty: built from the source text (see `agents.state`)
+
+    def compact(self, max_chars: int) -> str:
+        """Title, summary and opening passage: the state every decision reads."""
+        return f"Title: {self.title}\nSummary: {self.summary}\n\n{self.body}".strip()[:max_chars]
+
+
+@dataclass
+class Route:
+    folder: Folder  # where the note goes
+    new: bool  # file it in a new subfolder of `folder`
+    candidates: list[Folder]  # folders whose notes are checked for consolidation
+    # (name, description) per level to open below `folder`, reusing a subfolder of the same name; the note goes in the last one
+    create: list[tuple[str, str]] = field(default_factory=list)
+
+
+class NoteDraft(BaseModel):
+    title: str
+    summary: str
+    tags: list[str] = []
+    body: str
+    fields: dict[str, Any] = {}

llmw2/agents/librarian.py

@@ -0,0 +1,193 @@
+# Copyright 2026 Federico Cesarini, Marco Sassarini
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+"""The Librarian files a source into the wiki.
+
+    summarize → route → match → consolidate → merge | (name_folder →) write → relate → link
+
+The flow is fixed; each step is a function of the `Steps` it is given (classic, CROW or custom), and the
+output of every step is checked before it is used.
+"""
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+from functools import cached_property
+from typing import Any, Literal
+
+from llmw2.agents import linking, revisions
+from llmw2.agents.base import Decision, clean_tags, unique_objects
+from llmw2.agents.data import Candidate, NoteDraft, Route, Source
+from llmw2.agents.prompts import Prompts
+from llmw2.agents.steps import (
+    StepContext,
+    Steps,
+    check_consolidate,
+    check_match,
+    check_merge,
+    check_name_folder,
+    check_relate,
+    check_route,
+    check_summarize,
+    decision_hash,
+)
+from llmw2.bundle.origin import content_hash
+from llmw2.bundle.store import WikiStore
+from llmw2.config import WikiConfig
+from llmw2.models.classifier import Classifier
+from llmw2.models.llm import LLM
+from llmw2.models.usage import UsageReport
+
+__all__ = ["Candidate", "IngestResult", "Librarian", "NoteDraft", "Prepared", "Route", "Source"]
+
+
+@dataclass
+class IngestResult:
+    action: Literal["created", "merged", "unchanged"]  # "unchanged": nothing was written
+    note: str  # bundle path of the note written ("" when unchanged and no note cites the source)
+    title: str
+    folder: str  # "/" or "/finance/pricing"
+    created_folders: list[str]
+    related: list[str]
+    decisions: list[Decision]
+    usage: UsageReport = field(default_factory=UsageReport)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {**asdict(self), "usage": self.usage.to_dict()}
+
+
+@dataclass
+class Prepared:
+    """A source summarized and waiting to be filed: what `Librarian.prepare` hands to `Librarian.file`."""
+
+    source: Source
+    candidate: Candidate
+    usage: UsageReport  # the model calls made so far for this source
+    decisions: list[Decision] = field(default_factory=list)
+
+
+class Librarian:
+    """One instance serves one ingest, so its trace of decisions is never shared."""
+
+    def __init__(
+        self, store: WikiStore, llm: LLM, prompts: Prompts, cfg: WikiConfig, steps: Steps, classifier: Classifier | None = None
+    ) -> None:
+        self.store = store
+        self.cfg = cfg
+        self.steps = steps
+        self.ctx = StepContext(llm, classifier, prompts, cfg, system_prompt="librarian/system")
+
+    @cached_property
+    def hash(self) -> str:
+        """What the provenance says decided: the steps, prompts and decision parameters (see `decision_hash`)."""
+        return decision_hash(self.steps, self.cfg, self.ctx.prompts)
+
+    def ingest(self, source: Source) -> IngestResult:
+        return self.file(self.prepare(source))
+
+    def prepare(self, source: Source) -> Prepared:
+        """The part of an ingest that does not read the tree: summarize. Needs no lock, and may run in parallel."""
+        self.ctx.source = source
+        with self.ctx.llm.usage.span() as used:
+            cand = check_summarize(self.steps.summarize(self.ctx, source))
+        return Prepared(source, cand, used, list(self.ctx.decisions))
+
+    def file(self, prepared: Prepared) -> IngestResult:
+        """The rest: from a fresh `load()` to the log. The caller holds the wiki's lock."""
+        steps, ctx = self.steps, self.ctx
+        source, cand = prepared.source, prepared.candidate
+        ctx.source = source
+        ctx.candidate = cand
+        ctx.decisions = list(prepared.decisions)
+        with ctx.llm.usage.span() as used:
+            root = self.store.load()
+            route = check_route(steps.route(ctx, root, cand), root, self.cfg)
+            pool = unique_objects(n for f in [*route.candidates, route.folder] for n in f.notes)
+            match = check_match(steps.match(ctx, pool, cand), pool)
+            created: list[str] = []
+            merging = match is not None and check_consolidate(steps.consolidate(ctx, match, cand))
+            revised, archived = False, ""
+            if match is not None and merging:
+                draft = revisions.revise(ctx, match, source) if self.cfg.revisions == "replace" else None
+                if draft is not None:
+                    archived = self.store.archive_note(match)
+                    revised = True
+                else:
+                    draft = check_merge(steps.merge(ctx, match, source))
+                raw, ref = self.save_source(source, cand)
+                note = self.store.update_note(
+                    match,
+                    title=draft.title,
+                    summary=draft.summary,
+                    body=draft.body,
+                    tags=clean_tags(draft.tags),
+                    source=ref,
+                    fields=draft.fields,
+                    previous_version=archived or None,
+                )
+                action: Literal["created", "merged"] = "merged"
+            else:
+                folder = route.folder
+                if route.create:
+                    for name, description in route.create:
+                        folder, is_new = self.store.create_folder(folder, name, description)
+                        created += [folder.label] if is_new else []
+                elif route.new and ctx.can_create(folder):
+                    name, description = check_name_folder(steps.name_folder(ctx, folder, cand))
+                    folder, is_new = self.store.create_folder(folder, name, description)
+                    created += [folder.label] if is_new else []
+                raw, ref = self.save_source(source, cand)
+                note = self.store.write_note(
+                    folder,
+                    title=cand.title,
+                    summary=cand.summary,
+                    body=cand.body,
+                    tags=clean_tags(cand.tags),
+                    source=ref,
+                    fields=cand.fields,
+                )
+                action = "created"
+            others = [n for n in unique_objects([*pool, *note.folder.notes]) if n is not note] if note.folder else pool
+            if ctx.classifier is not None and self.cfg.relate_rare_values:
+                found = linking.rare_scores(root, note, {n.rel for n in others} | {note.rel})
+                others = [*others, *(n for n, _ in found)]
+                if found:
+                    ctx.decide("relate_candidates", "code", f"{len(found)} by rare values", scores={n.rel: round(s, 3) for n, s in found})
+            related = check_relate(steps.relate(ctx, note, others), note, others) if others else []
+            related = related[: self.cfg.max_links]
+            for other in related:
+                self.store.link(note, other)
+            verb = ("Revised" if revised else "Merged") if action == "merged" else "Created"
+            via = f", via {','.join(self.cfg.llm.pin_provider)}" if self.cfg.llm.pin_provider else ""
+            kept = f", previous version archived at {archived}" if revised else ""
+            # CROW: the classifier did not settle the route and the LLM chose the folder (read by `Wiki.taxonomy_health`)
+            llm_decides = self.cfg.mode == "crow"  # in classic the LLM routes every note: that is no fallback
+            fallback = any(d.step == "route" and (d.fallback or (llm_decides and d.decider == "llm")) for d in ctx.decisions)
+            routed = ", routed by fallback" if fallback else ""
+            text = f"from {raw} ({steps.name} {self.hash}, {self.cfg.llm.model}{via}){kept}{routed}"
+            self.store.append_log(verb, text, note.rel, note.title)
+        total = prepared.usage.copy()
+        total.merge(used)
+        return IngestResult(
+            action,
+            note.rel,
+            note.title,
+            note.folder.label if note.folder else "/",
+            created,
+            [r.rel for r in related],
+            ctx.decisions,
+            total,
+        )
+
+    def save_source(self, source: Source, cand: Candidate) -> tuple[str, dict[str, Any]]:
+        """Keep the raw copy and build the note's source entry; called right before the note is written.
+
+        Saved this late so an interrupted ingest leaves no raw copy that no note cites.
+        """
+        title = source.title or cand.title
+        raw = self.store.save_raw(source.text, title=title, resource=source.resource, origin=source.origin)
+        ref: dict[str, Any] = {"resource": raw, "title": title, "hash": content_hash(source.text)}
+        if source.origin is not None:
+            ref["origin"] = source.origin.to_dict()
+        ref["steps"] = {"name": self.steps.name, "hash": self.hash}
+        return raw, ref

llmw2/agents/linking.py

@@ -0,0 +1,58 @@
+"""See-also candidates found by code: notes anywhere in the wiki that share rare values with a note.
+
+The route only visits some folders, so two notes with the same facts in distant folders would never meet in `relate`.
+Values held by few notes (codes, amounts, dates, names) bring them together. No model call.
+"""
+
+from __future__ import annotations
+
+import math
+import re
+
+from llmw2.agents.steps_classic import incoming_values
+from llmw2.bundle.store import body_hash
+from llmw2.bundle.tree import Folder, Note, split_see_also
+
+RARE_TOP = 40  # most notes added to the candidates of `relate`
+RARE_MAX_SHARE = 0.05  # a value is rare when at most this share of the notes hold it...
+RARE_MIN_CAP = 3  # ...or this many, in a small wiki
+INDEGREE_CAP = 12  # a note with this many See-also entries is not offered
+_CACHE_MAX = 50_000
+_YEAR = re.compile(r"^(19|20)\d\d$")
+
+_cache: dict[tuple[str, str, str, str], frozenset[str]] = {}
+
+
+def note_values(note: Note) -> frozenset[str]:
+    """The values of a note (`incoming_values` of its text), cached by what they are computed from."""
+    key = (note.rel, body_hash(note.main_body()), note.title, note.summary)
+    values = _cache.get(key)
+    if values is None:
+        if len(_cache) > _CACHE_MAX:
+            _cache.clear()
+        values = _cache[key] = frozenset(incoming_values(note.full_text()))
+    return values
+
+
+def rare_scores(root: Folder, note: Note, exclude: set[str]) -> list[tuple[Note, float]]:
+    """The notes that share rare values with `note`, with their score: best first, at most `RARE_TOP`."""
+    notes = root.all_notes()
+    total = len(notes)
+    held = {n.rel: note_values(n) for n in notes}
+    df: dict[str, int] = {}
+    for values in held.values():
+        for v in values:
+            df[v] = df.get(v, 0) + 1
+    cap = max(RARE_MIN_CAP, RARE_MAX_SHARE * total)
+    weight = {v: math.log(total / c) for v, c in df.items() if c <= cap and not _YEAR.match(v)}
+    mine = {v for v in note_values(note) if v in weight}
+    scored: list[tuple[Note, float]] = []
+    for other in notes:
+        if other.rel == note.rel or other.rel in exclude:
+            continue
+        score = sum(weight[v] for v in held[other.rel] & mine)
+        if score <= 0 or len(split_see_also(other.body)[1]) >= INDEGREE_CAP:
+            continue
+        scored.append((other, score))
+    scored.sort(key=lambda item: (-item[1], item[0].rel))
+    return scored[:RARE_TOP]

llmw2/agents/prompts/classifier/consolidate.md

@@ -0,0 +1,8 @@
+## instructions
+The state holds an incoming note followed by an existing note. Should the incoming content modify the existing note, or become a new note?
+
+## Modify
+The incoming content is about the same subject as the existing note and adds, updates or corrects its information.
+
+## New note
+The incoming content is about a related but distinct subject that deserves a note of its own.

llmw2/agents/prompts/classifier/note_relevance.md

@@ -0,0 +1 @@
+Does the incoming content concern the same subject as the note titled "{{title}}", summarized as "{{summary}}"?

llmw2/agents/prompts/classifier/relate.md

@@ -0,0 +1 @@
+Would a reader of this note want to open the note titled "{{title}}", summarized as "{{summary}}", because it covers a closely connected subject?

llmw2/agents/prompts/classifier/retrieval_folder.md

@@ -0,0 +1 @@
+Is the folder "{{name}}", described as "{{description}}", likely to contain notes that help answer the question?

llmw2/agents/prompts/classifier/retrieval_note.md

@@ -0,0 +1 @@
+Does the note titled "{{title}}", summarized as "{{summary}}", help answer the question?

llmw2/agents/prompts/classifier/route.md

@@ -0,0 +1,11 @@
+## instructions
+Where does the incoming note belong, relative to the wiki folder {{folder}}? Pick the subfolder whose description covers the subject of the note, or one of the placement options.
+
+## Here
+The description of the folder {{folder}} covers the subject of the note, and no listed subfolder covers it better.
+
+## New subfolder
+The subject of the note belongs under the folder {{folder}}, but neither the folder's description nor any listed subfolder covers it.
+
+## None of these
+The subject of the note belongs to a different part of the wiki than the folder {{folder}}.

llmw2/agents/prompts/classifier/route_open.md

@@ -0,0 +1,11 @@
+## instructions
+Where does the incoming note belong, relative to the wiki folder {{folder}}? Pick the subfolder whose description covers the subject of the note, or one of the placement options.
+
+## Here
+The subject of the note matches the folder {{folder}} as a whole, more than any single subfolder.
+
+## New subfolder
+The subject of the note fits under the folder {{folder}} and needs a subfolder of its own, distinct from the listed subfolders.
+
+## None of these
+The subject of the note belongs to a different part of the wiki than the folder {{folder}}.

llmw2/agents/prompts/librarian/consolidate.md

@@ -0,0 +1,17 @@
+The incoming note may be about the same subject as the existing note. Decide what to do with it.
+
+- "modify": the incoming content updates, corrects or extends the subject of the existing note, so it is merged into it.
+- "new": the incoming content is about a related but distinct subject, so it gets its own note next to the existing one.
+
+When unsure, answer "new": a duplicate can be merged later, while a wrong merge blurs two subjects into one note.
+
+<note>
+{{note}}
+</note>
+
+<existing>
+{{existing}}
+</existing>
+
+Reply with JSON:
+{"reasoning": "...", "decision": "modify" | "new"}

llmw2/agents/prompts/librarian/find_match.md

@@ -0,0 +1,15 @@
+Is the incoming note about the same subject as one of the existing notes below?
+
+Same subject means a reader would expect both texts in one note: the same entity, concept, process, event or decision, possibly with new, updated or corrected information. Notes that are only related (same area, different subject) do not match.
+
+<note>
+{{note}}
+</note>
+
+Existing notes (path: title — summary):
+<notes>
+{{notes}}
+</notes>
+
+Reply with JSON; "match" is the exact path of the matching note, or null when none matches or you are unsure:
+{"reasoning": "...", "match": "<path>" | null}

llmw2/agents/prompts/librarian/merge.md

@@ -0,0 +1,29 @@
+Merge an incoming note into an existing wiki note and return the complete updated note.
+
+{{shared/note_rules}}
+
+How to merge:
+- The result is the existing note, updated: keep its title, summary, headings and order of sections, and its wording where nothing changed. Do not rewrite or reorganise it around the incoming note.
+- Keep every fact of the existing note that the incoming note does not contradict.
+- Put each new fact in the section where it belongs; add a section only when none fits.
+- When the incoming note updates or contradicts the existing one, keep the newer fact and state the change in place, with the date of the incoming note ("As of March 2026 the limit is 40, previously 30"), unless the incoming note is clearly older than the existing one.
+- Change the title and summary only if the subject itself changed, not because the incoming note is longer or has another focus.
+
+Existing note
+Title: {{title}}
+Summary: {{summary}}
+Tags: {{tags}}
+<existing>
+{{body}}
+</existing>
+
+Incoming note ({{incoming_from}})
+Title: {{incoming_title}}
+Summary: {{incoming_summary}}
+Tags: {{incoming_tags}}
+<note>
+{{incoming_body}}
+</note>
+
+Reply with JSON:
+{"title": "...", "summary": "...", "tags": ["..."], "body": "..."}

llmw2/agents/prompts/librarian/merge_source.md

@@ -0,0 +1,26 @@
+Merge a new source into an existing wiki note and return the complete updated note.
+
+{{shared/note_rules}}
+
+How to merge:
+- Keep every fact of the existing note that the source does not contradict.
+- Put each new fact in the section where it belongs; add a section only when none fits.
+- When the source updates or contradicts the note, keep the newer fact and state the change in place ("As of March 2026 the limit is 40, previously 30"), unless the source is clearly older than the note.
+- Never shorten the note to the size of the source and never drop sections.
+- Change the title and summary only if the scope of the subject changed.
+
+Existing note
+Title: {{title}}
+Summary: {{summary}}
+Tags: {{tags}}
+<existing>
+{{body}}
+</existing>
+
+New source
+<source>
+{{source_text}}
+</source>
+
+Reply with JSON:
+{"title": "...", "summary": "...", "tags": ["..."], "body": "..."}

llmw2/agents/prompts/librarian/name_folder.md

@@ -0,0 +1,17 @@
+A new subfolder is being created under {{parent}} ({{parent_description}}) to hold the incoming note. Name it and describe it.
+
+Existing subfolders of {{parent}} (name: description):
+{{siblings}}
+
+<note>
+{{note}}
+</note>
+
+{{shared/folder_rules}}
+
+The name: 1 to 3 lowercase words joined by hyphens, letters a-z and digits only; a plural noun for collections ("suppliers", "incident-reports"); in the language of the existing folders, English if there are none. It must not duplicate or overlap an existing subfolder.
+Directly under the root ("/"), name the broad area the note belongs to ("engineering", "finance", "customers"), never its specific topic: specific topics become subfolders of that area later.
+The description: one line of at most 150 characters stating what belongs in the folder — the category, not this single note.
+
+Reply with JSON:
+{"name": "...", "description": "..."}

llmw2/agents/prompts/librarian/relate.md

@@ -0,0 +1,15 @@
+Choose the existing notes that deserve a "See also" link from the note below.
+
+Link a note only when a reader of this note would want to open it next: it covers the same entity from another angle, a part or the whole of it, a cause, a consequence, a prerequisite or a direct alternative. Do not link notes that only share a broad area. At most {{max_links}} links; an empty list is the right answer when nothing qualifies.
+
+<note>
+{{note}}
+</note>
+
+Candidates (path: title — summary):
+<notes>
+{{notes}}
+</notes>
+
+Reply with JSON; use exact paths from the list, best first:
+{"reasoning": "...", "related": ["<path>", "..."]}