@falkenslab/agent-kit 0.17.0 → 0.19.0

package/assets/knowledge-plugin-files/commands/ingest.md

@@ -1,7 +0,0 @@
----
-description: Ingest material into the knowledge base right now - the files or topic given, or everything in sources/ not ingested yet
----
-
-Apply the `knowledge-ingest` skill right now to: $ARGUMENTS
-
-If nothing is given above, ingest every original `list_sources` reports as new, and update the summaries of the ones it reports as changed. When you're done, summarize which pages you created and updated, and anything you couldn't read.

package/assets/knowledge-plugin-files/commands/lint.md

@@ -1,5 +0,0 @@
----
-description: Health-check the knowledge base right now - broken links, orphans, duplicates, contradictions, gaps
----
-
-Apply the `knowledge-lint` skill right now over the whole knowledge base. Fix what's mechanical (links, index, missing back-links) and report the rest: what needs the human's decision, and the gaps worth filling next.

package/assets/knowledge-plugin-files/skills/knowledge-ingest/SKILL.md

@@ -1,46 +0,0 @@
----
-name: knowledge-ingest
-description: Ingest one source into the knowledge base - a file in sources/, a document, a page - creating its summary page, creating or updating the concept and entity pages it touches, linking everything both ways, and updating index.md and log.md.
----
-
-# Ingesting a source into the knowledge base
-
-A source is ingested once, and from then on the knowledge base holds what it taught: later sessions read the pages, not the original again. Ingesting is not summarizing a file in isolation - its value is in how it connects to what the knowledge base already knows. Load the `knowledge-pages` skill first for the page templates.
-
-## 1. Check it isn't already ingested
-
-`list_sources` gives each original's status and summary pages: *new* needs ingesting; *ingested* has a page; *changed* changed after its ingest. For a document from elsewhere, look for it in `index.md` (Summaries) or `Grep` its URL inside the knowledge base. If it already has a page:
-- unchanged source: nothing to do;
-- the source changed or the page is thin: update that page instead of creating another.
-
-## 2. Read it for real
-
-Read the whole source, not its first page (a long PDF in parts: `list_sources` gives its pages). If it exists only outside the sources folder, keep the original first: `download_to_sources` for a URL (a web page is kept as markdown too: read that one), `save_to_sources` for a file in the run's folder, `request_file` to ask the person for one. `Read` reads PDFs and images; read DOCX, PPTX (with its speaker notes) and XLSX with `extract_text`.
-
-## 3. Write the summary page
-
-Create `summaries/<slug>.md` with the template: summary, key points (literal wording where exactness matters), frontmatter `file`/`url` pointing to the original.
-
-## 4. Update concepts and entities
-
-For every concept or entity the source explains or relies on:
-- no page yet: create it;
-- page exists: add what is new (a better definition, an example, a nuance, a fact) with `Edit`, and link the summary under "Sources".
-
-Check first whether it exists under another name (`Grep` the knowledge base for the term and look at `aliases`): a duplicate page is worse than none.
-
-## 5. Link both ways and look for conflicts
-
-Every link you added from page A to page B needs its counterpart in B. If the source contradicts an existing page, record both versions with attribution in both pages - don't overwrite.
-
-## 6. Close
-
-- `index.md`: new pages, and one-line descriptions that changed.
-- `log.md`: `## [date] ingest | <source title>` with the pages created and updated.
-- `overview.md`: only if the source changes the big picture.
-
-When ingesting several sources in a row, do steps 1-5 for each and close once at the end.
-
-## An original that was wrong or replaced
-
-`retire_source` (the person approves it) moves it aside and marks its summary retired (wrong) or superseded (replaced by a better one). Then update `index.md`, and fix the pages that cite it (`Grep` its file name): after a wrong one, correct or remove what it taught; after a replaced one, ingest the new original and re-ground those passages on it.

package/assets/knowledge-plugin-files/skills/knowledge-lint/SKILL.md

@@ -1,26 +0,0 @@
----
-name: knowledge-lint
-description: Health-check the knowledge base - broken links, pages missing from index.md, orphan pages, one-way links, duplicated concepts, mentioned-but-missing concepts, contradictions, gaps - fix what's mechanical and report the rest.
----
-
-# Linting the knowledge base
-
-A knowledge base maintained across sessions drifts: links break, pages go unlisted, the same concept appears under two names. Lint it when asked and after a large ingest. Load `knowledge-pages` first for the templates.
-
-## Checks
-
-Use `Glob` to list pages and `Grep` (always with `path` inside the knowledge base) to find links, instead of reading every page in full.
-
-1. **Broken links**: a relative link whose target file doesn't exist. Fix it if the right target is obvious (a typo, a page under a close name); otherwise report it.
-2. **Index**: every page is listed in `index.md` and every entry there points to an existing page. Fix it.
-3. **Orphans**: pages nothing links to (`Grep` for the file name). Link them from where they belong, or report why they don't belong anywhere.
-4. **One-way links**: a summary that feeds a concept which doesn't list it back... Add the missing side.
-5. **Duplicates**: two pages for the same idea under different names. Merge the content into one, mark the other as superseded (never delete it) and repoint links.
-6. **Missing pages**: terms that several pages treat as concepts or entities but have no page. Create them if the material is there; otherwise list them.
-7. **Contradictions**: claims that disagree across pages without being recorded as such. Record both sides, attributed.
-8. **Provenance**: claims with no traceable source. Add the link, or mark them as unsourced.
-9. **Gaps**: originals `list_sources` reports as new (no summary yet), changed (their summary may be stale) or missing (deleted by hand: their summaries point nowhere), and concepts mentioned but never explained by any source. Report them - they are what to ingest, update or find next.
-
-## Close
-
-Append `## [date] lint | <summary>` to `log.md` listing what was fixed. Then report to the human: what you fixed, and what needs their decision or more material. Don't make judgement calls silently - merging pages that are only similar, or choosing between contradictory sources, goes in the report.

package/assets/knowledge-plugin-files/skills/knowledge-pages/SKILL.md

@@ -1,137 +0,0 @@
----
-name: knowledge-pages
-description: Exact templates and conventions for every page of the knowledge base (index, log, overview, summary, concept, entity and synthesis pages) - load it before creating a knowledge base page or restructuring one, so every page keeps the same shape and links.
----
-
-# Knowledge base page templates
-
-The knowledge base's layout and rules are in the system prompt ("Knowledge base"). This skill only adds the exact shape of each page. Headings and frontmatter keys stay in English (they are structure); the text under them is in the human's language. Dates are `YYYY-MM-DD`. Links are relative markdown links (from `concepts/x.md`, a summary is `../summaries/y.md`; an original file is `../../sources/...`, adjusted to where the folders really are).
-
-Every page starts with YAML frontmatter; `updated` changes whenever you edit the page.
-
-## index.md
-
-The catalog and entry point. One line per page, grouped by section: Summaries, Concepts, Entities, Syntheses (plus any section the domain adds).
-
-```markdown
-# Index
-
-## Summaries
-- [Q3 architecture review](summaries/q3-architecture-review.md) - decisions taken on the billing service
-## Concepts
-- [Idempotency](concepts/idempotency.md) - safe retries of a request
-```
-
-## log.md
-
-Append-only; never edit past entries. Newest at the bottom.
-
-```markdown
-## [2026-10-03] ingest | Q3 architecture review
-- created: summaries/q3-architecture-review.md, concepts/idempotency.md
-- updated: entities/billing-service.md, index.md
-```
-
-## overview.md
-
-A living synthesis of the whole knowledge base, rewritten (not appended) as understanding grows: what it covers, its main blocks and how they connect (with links), what is still unknown.
-
-## Summary page (`summaries/<slug>.md`)
-
-One per ingested source.
-
-```markdown
----
-type: summary
-title: "<Title>"
-file: <relative link to the original in sources/, if any>
-url: <original URL, if any>
-ingested: YYYY-MM-DD
-updated: YYYY-MM-DD
----
-
-# <Title>
-
-## Summary
-<Two to four paragraphs: what it actually says.>
-
-## Key points
-- Claims, definitions or figures likely to be needed later, quoted literally when exact wording matters.
-
-## Pages it feeds
-- [Concept or entity](../concepts/<slug>.md)
-
-## New or surprising
-- What this source adds to what the knowledge base already had.
-
-## Contradictions
-- Conflicts with other pages, linked.
-```
-
-## Concept page (`concepts/<slug>.md`)
-
-One idea per page.
-
-```markdown
----
-type: concept
-aliases: []
-updated: YYYY-MM-DD
----
-
-# <Concept>
-
-<Definition in one or two sentences.>
-
-## Explanation
-<How it works, at the depth the sources give.>
-
-## Connections
-- Requires: [Concept](<slug>.md)
-- Related: [Concept](<slug>.md) - how
-
-## Sources
-- [Summary](../summaries/<slug>.md) - what it says about this
-
-## Contradictions and open questions
-- "<Source A> says X; <source B> says Y" - both attributed.
-```
-
-## Entity page (`entities/<slug>.md`)
-
-A concrete thing: a system, a component, an organization, a document, a person only when they are a public role rather than private individual details.
-
-```markdown
----
-type: entity
-kind: <system | component | organization | document | other>
-aliases: []
-updated: YYYY-MM-DD
----
-
-# <Name>
-
-<What it is, one or two sentences.>
-
-## Facts
-- Attributed facts, each linking the summary or source it comes from.
-
-## Connections
-- [Concept or entity](../concepts/<slug>.md) - how
-```
-
-## Synthesis page (`syntheses/<slug>.md`)
-
-An answer worth keeping: a comparison, an analysis, a report.
-
-```markdown
----
-type: synthesis
-question: "<The question it answers>"
-updated: YYYY-MM-DD
----
-
-# <Title>
-
-<The answer, with links to every page it draws on.>
-```

package/assets/knowledge-plugin-files/skills/knowledge-query/SKILL.md

@@ -1,14 +0,0 @@
----
-name: knowledge-query
-description: Answer a question from the knowledge base - find the relevant pages through the index, read them, answer with links to them, and file the answer back as a synthesis page when it is worth keeping.
----
-
-# Querying the knowledge base
-
-The knowledge base exists so a question doesn't start from zero. Answer from it first; go back to the originals or the web only for what it doesn't hold.
-
-1. **Start from the index.** Read `index.md`, pick the pages that can matter, read those (not the whole knowledge base). `Grep` inside the knowledge base for terms and aliases the index doesn't reveal.
-2. **Answer from the pages**, linking each one you drew on. Say what comes from the knowledge base, what comes from an original in the sources folder (read it if the knowledge base is thin or contradictory) and what comes from outside (label it as such).
-3. **Say what is missing.** If the knowledge base can't answer part of the question, say so and name the source that would fill it, instead of filling the gap from memory silently.
-4. **File it back.** If the answer is a comparison, an analysis or a report that will be asked again, save it as `syntheses/<slug>.md` (template in `knowledge-pages`) with links to its inputs, add it to `index.md`, and log it: `## [date] query | <question>`. A quick factual answer needs no page.
-5. **Feed the knowledge base.** If answering revealed a concept or fact that has no page, or a contradiction, fix that in the knowledge base too and log it.

package/dist/core/agentHelp.d.ts

@@ -1,30 +0,0 @@
-import type { AgentIdentity, Mode } from "./agentSpec.js";
-/**
- * The agent's self-knowledge: who it is (a section of the system prompt) and how it is used
- * (the `agent-help` skill). The chat's part of the skill is the kit's, the same for every
- * agent and kept next to the chat's code (`assets/agent-help/SKILL.md`, checked against the
- * chat's commands and keys by a test); the agent's part is its own guide (`AgentSpec.helpGuide`).
- */
-/** The plugin the skill is loaded from, as the SDK names its skills ("agent-kit:agent-help"). */
-export declare const AGENT_HELP_SKILL = "agent-kit:agent-help";
-/** Absolute path of the kit's part of the skill, next to `dist/` (or `src/` under tsx). */
-export declare function agentHelpSkillPath(): string;
-/** The "Who you are" section appended to the system prompt: name, version, what it is, the kit's version. */
-export declare function identityPromptSection(identity: AgentIdentity): string;
-/** What the generated skill says about this session. */
-export interface AgentHelpSession {
-    mode: Mode;
-    /** The modes Shift+Tab goes through (`ModeControl.switchable`). */
-    switchable: readonly Mode[];
-    /** The built-in knowledge base is on: its slash commands exist. */
-    knowledgeBase: boolean;
-    /** The sources folder, as shown to the model (e.g. "sources/"). */
-    sourcesFolder?: string;
-}
-/**
- * Writes the `agent-help` plugin into `dir` (a folder of this run's), with the kit's part of
- * the skill, this session's facts and the agent's own guide, and returns its root. Generated
- * rather than shipped as it is: the guide goes inside the skill, so the agent needs no file
- * tools to read it, and nothing about it reaches the context until the skill is loaded.
- */
-export declare function writeAgentHelpPlugin(dir: string, session: AgentHelpSession, helpGuide?: string): Promise<string>;

package/dist/core/agentHelp.js

@@ -1,55 +0,0 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { agentKitVersion } from "./version.js";
-/**
- * The agent's self-knowledge: who it is (a section of the system prompt) and how it is used
- * (the `agent-help` skill). The chat's part of the skill is the kit's, the same for every
- * agent and kept next to the chat's code (`assets/agent-help/SKILL.md`, checked against the
- * chat's commands and keys by a test); the agent's part is its own guide (`AgentSpec.helpGuide`).
- */
-/** The plugin the skill is loaded from, as the SDK names its skills ("agent-kit:agent-help"). */
-export const AGENT_HELP_SKILL = "agent-kit:agent-help";
-/** Absolute path of the kit's part of the skill, next to `dist/` (or `src/` under tsx). */
-export function agentHelpSkillPath() {
-    return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "assets", "agent-help", "SKILL.md");
-}
-/** The "Who you are" section appended to the system prompt: name, version, what it is, the kit's version. */
-export function identityPromptSection(identity) {
-    const who = `${identity.name}${identity.version ? ` ${identity.version}` : ""}${identity.description ? `: ${identity.description}` : ""}`;
-    return `## Who you are
-You are ${who}. You are built on agent-kit ${agentKitVersion()}, which provides your chat (its modes, keys and slash commands) and your built-in tools.
-When the person asks how to use you (your modes, keys or commands, resuming an earlier conversation, your configuration, what you can do), load the \`agent-help\` skill and answer from it; don't invent options it doesn't list.`;
-}
-/** The skill's "This session" section. */
-function sessionSection(session) {
-    const lines = [
-        `- This session started in **${session.mode}** mode.`,
-        session.switchable.length > 1
-            ? `- \`Shift+Tab\` goes through: ${session.switchable.join(", ")}.`
-            : "- The mode can't be switched during this session.",
-    ];
-    if (session.knowledgeBase)
-        lines.push("- You keep a knowledge base (your memory across sessions). Its commands: `/knowledge:ingest` (learn the new or changed files of the sources folder), `/knowledge:query <question>` (answer from it), `/knowledge:lint` (check it and fix what's mechanical).");
-    if (session.sourcesFolder)
-        lines.push(`- Originals go in \`${session.sourcesFolder}\`: the person drops files there (or you ask for one, or download it), and you never change them.`);
-    return `## This session\n\n${lines.join("\n")}`;
-}
-/**
- * Writes the `agent-help` plugin into `dir` (a folder of this run's), with the kit's part of
- * the skill, this session's facts and the agent's own guide, and returns its root. Generated
- * rather than shipped as it is: the guide goes inside the skill, so the agent needs no file
- * tools to read it, and nothing about it reaches the context until the skill is loaded.
- */
-export async function writeAgentHelpPlugin(dir, session, helpGuide) {
-    const kitPart = (await readFile(agentHelpSkillPath(), "utf8")).trimEnd();
-    const guide = helpGuide ? (await readFile(helpGuide, "utf8")).trim() : "";
-    const agentPart = guide
-        ? `## This agent\n\nThe agent's own guide, for everything about its domain (its commands, configuration, folders):\n\n${guide}`
-        : "## This agent\n\nThis agent has no guide of its own: for its domain, say only what your instructions tell you, and that the rest isn't documented.";
-    await mkdir(path.join(dir, ".claude-plugin"), { recursive: true });
-    await mkdir(path.join(dir, "skills", "agent-help"), { recursive: true });
-    await writeFile(path.join(dir, ".claude-plugin", "plugin.json"), `${JSON.stringify({ name: "agent-kit", description: "How to use this agent: the kit's chat and the agent's own guide." }, null, 2)}\n`);
-    await writeFile(path.join(dir, "skills", "agent-help", "SKILL.md"), `${kitPart}\n\n${sessionSection(session)}\n\n${agentPart}\n`);
-    return dir;
-}

package/dist/core/knowledge.d.ts

@@ -1,25 +0,0 @@
-import type { PageType } from "./knowledgeStore.js";
-/**
- * The built-in knowledge base (an "LLM wiki"): `sourcesDir` holds the originals, `knowledgeDir`
- * is the wiki the agent writes and maintains, and the rules below plus the plugin's skills
- * (knowledge-pages, knowledge-ingest, knowledge-query, knowledge-lint) and commands (/knowledge:ingest, /knowledge:query,
- * /knowledge:lint) are the schema that tells the agent how. Domain-agnostic on purpose: an agent
- * with its own page types (topics, activities...) opts out with `AgentSpec.knowledgeBase: false` and
- * writes its own rules, or extends these.
- */
-/**
- * Absolute path of the plugin shipped with the kit, next to `dist/` (or `src/` under tsx):
- * `assets/knowledge-plugin`, whose skills work through the `knowledge_*` tools, or with
- * `"files"` `assets/knowledge-plugin-files`, whose skills work on the files (ADR-024).
- */
-export declare function knowledgePluginRoot(variant?: "tools" | "files"): string;
-/**
- * The "Knowledge base" section appended to the system prompt: the layout and the working
- * rules. With `tools` (the kit's default since ADR-024), for a knowledge base reached through
- * the `knowledge_*` tools, listing `pageTypes`; otherwise for one kept with the file tools,
- * whose page templates live in the `knowledge-pages` skill.
- */
-export declare function knowledgePromptSection(projectDir: string, knowledgeDir: string, sourcesDir?: string, options?: {
-    tools?: boolean;
-    pageTypes?: readonly PageType[];
-}): string;

package/dist/core/knowledge.js

@@ -1,84 +0,0 @@
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-/**
- * The built-in knowledge base (an "LLM wiki"): `sourcesDir` holds the originals, `knowledgeDir`
- * is the wiki the agent writes and maintains, and the rules below plus the plugin's skills
- * (knowledge-pages, knowledge-ingest, knowledge-query, knowledge-lint) and commands (/knowledge:ingest, /knowledge:query,
- * /knowledge:lint) are the schema that tells the agent how. Domain-agnostic on purpose: an agent
- * with its own page types (topics, activities...) opts out with `AgentSpec.knowledgeBase: false` and
- * writes its own rules, or extends these.
- */
-/**
- * Absolute path of the plugin shipped with the kit, next to `dist/` (or `src/` under tsx):
- * `assets/knowledge-plugin`, whose skills work through the `knowledge_*` tools, or with
- * `"files"` `assets/knowledge-plugin-files`, whose skills work on the files (ADR-024).
- */
-export function knowledgePluginRoot(variant = "tools") {
-    return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "assets", variant === "files" ? "knowledge-plugin-files" : "knowledge-plugin");
-}
-/** A path as shown to the model: relative to the project, forward slashes, with a trailing slash. */
-function shown(projectDir, dir) {
-    return `${path.relative(projectDir, dir).split(path.sep).join("/")}/`;
-}
-/** The originals' line of the prompt section, the same in both variants. */
-function originalsLine(originals) {
-    return `- **Originals (read-only for you)**: \`${originals}\`. Never rewrite one; build pages *about* them. \`list_sources\` says which are new (not ingested yet), changed since their ingest or missing; add a file only with \`save_to_sources\`, \`download_to_sources\` or by asking the person (\`request_file\`), and take out a wrong or superseded one only with \`retire_source\`. \`Read\` reads PDFs and images; \`extract_text\` reads DOCX, PPTX (with speaker notes) and XLSX.\n`;
-}
-/** The section for a knowledge base reached through the `knowledge_*` tools (ADR-024). */
-function toolsSection(originals, pageTypes) {
-    return `## Knowledge base
-Your memory across sessions is an interlinked knowledge base of pages that you write and maintain yourself — a wiki, not a pile of notes. A future session only knows what is written there, so anything worth remembering must end up in a page, not just in this turn's reply. You reach it only through the \`knowledge_*\` tools. Write page content in the language you are using with the human.
-
-### Layers
-${originals ? originalsLine(originals) : ""}- **The knowledge base**: pages identified by type and slug (\`concept/spring-tides\`), plus the \`overview\`, a living synthesis of the whole, and the \`log\` of what was done to it (\`knowledge_read\` reads both). Page types: ${pageTypes.map((type) => `\`${type.type}\` (${type.description})`).join("; ")}.
-- **The schema**: these rules plus the \`knowledge-ingest\`, \`knowledge-query\` and \`knowledge-lint\` skills. \`knowledge_create\` without content gives a type's template.
-
-### Working rules
-- Start from \`knowledge_search\` or \`knowledge_index\`, then \`knowledge_read\` only the pages the task needs.
-- Link pages by id, \`[Spring tides](concept/spring-tides)\`; links must point to existing pages. The index and the backlinks ("linked from") are kept for you.
-- Change a page with \`knowledge_edit\` (a fragment); \`knowledge_rewrite\` only to redo it whole. Pages are never deleted or renamed: \`knowledge_supersede\` one replaced by another; \`knowledge_retire\` one that was wrong.
-- When an operation is done, \`knowledge_log\` it: \`ingest\`, \`query\`, \`lint\` or \`update\`, with the pages touched.
-- Every claim must be traceable to a summary page, an original, or — clearly labelled as outside the knowledge base — the web.
-- Contradictions are kept, not overwritten: record both versions with attribution in the affected pages.
-- Short, focused, well-linked pages beat long ones: when a page mixes two things, split it.`;
-}
-/**
- * The "Knowledge base" section appended to the system prompt: the layout and the working
- * rules. With `tools` (the kit's default since ADR-024), for a knowledge base reached through
- * the `knowledge_*` tools, listing `pageTypes`; otherwise for one kept with the file tools,
- * whose page templates live in the `knowledge-pages` skill.
- */
-export function knowledgePromptSection(projectDir, knowledgeDir, sourcesDir, options = {}) {
-    const notes = shown(projectDir, knowledgeDir);
-    const originals = sourcesDir ? shown(projectDir, sourcesDir) : undefined;
-    if (options.tools)
-        return toolsSection(originals, options.pageTypes ?? []);
-    return `## Knowledge base (${notes})
-\`${notes}\` is your memory across sessions, kept as an interlinked knowledge base of markdown pages that you write and maintain yourself — a wiki, not a pile of notes. A future session only knows what is written there, so anything worth remembering must end up in a page, not just in this turn's reply. Write page content in the language you are using with the human; file names stay lowercase ASCII with hyphens.
-
-### Layers
-${originals ? originalsLine(originals) : ""}- **The knowledge base**: \`${notes}\`, entirely yours to write.
-- **The schema**: these rules plus the \`knowledge-pages\` skill (exact template of every page type — load it before creating a page) and the \`knowledge-ingest\`, \`knowledge-query\` and \`knowledge-lint\` skills.
-
-### Layout
-\`\`\`
-${notes}
-  index.md          catalog of every page, one line each: read it FIRST, always
-  log.md            append-only log of what you did to the knowledge base
-  overview.md       living synthesis of the whole knowledge base
-  summaries/<slug>.md   one page per ingested source
-  concepts/<slug>.md    one page per idea
-  entities/<slug>.md    one page per concrete thing (system, component, organization, document)
-  syntheses/<slug>.md   answers worth keeping: comparisons, analyses, reports
-\`\`\`
-
-### Working rules
-- Start by reading \`index.md\`, then only the pages the task needs — don't read the whole knowledge base.
-- Links are standard markdown links relative to the page, and go both ways: when A links to B, add the link back in B. To find who links to a page, \`Grep\` for its file name inside the knowledge base.
-- Never rename, move or delete a page (every link to it would break): if it is superseded, say so at its top and link to the new one.
-- Prefer \`Edit\` for changes to an existing page; \`Write\` only for new pages.
-- After any change, update \`index.md\` and append \`## [YYYY-MM-DD] <operation> | <what>\` to \`log.md\`, followed by the pages created/updated. Operations: \`ingest\`, \`query\`, \`lint\`, \`update\`.
-- Every claim must be traceable to a summary page, an original, or — clearly labelled as outside the knowledge base — the web.
-- Contradictions are kept, not overwritten: record both versions with attribution in the affected pages.
-- Short, focused, well-linked pages beat long ones: when a page mixes two things, split it.`;
-}