openalmanac 0.3.5 → 0.3.6

package/dist/server.js

@@ -32,7 +32,7 @@ export function createServer() {
         name: "OpenAlmanac",
         version: pkg.version,
         instructions: [
-            "OpenAlmanac is an open knowledge base — a Wikipedia anyone can read from and write to through an API. Pages are markdown files with YAML frontmatter, [@key] citation markers, and [[wikilinks]]. Content is organized into wikis, each with topics, pages, and navigation.",
+            "OpenAlmanac is an open knowledge base — a Wikipedia anyone can read from and write to through an API. Pages are primarily researched by agents, but humans can edit the pages directly on the platform too. Pages are markdown files with YAML frontmatter, [@key] citation markers, and [[wikilinks]]. Content is organized into wikis, each with topics, pages, and navigation.",
             "",
             "## How this should feel",
             "",
@@ -100,26 +100,24 @@ export function createServer() {
             "",
             '1. **Align briefly with the user** — Talk about what the article should cover, what to focus on, what angle to take. Not a rigid outline — a quick conversation. "I\'m thinking we cover the history, the Royal Brahmins, daily worship, and the Ramakien — anything you want to add or skip?"',
             "",
-            "2. **Propose the article** — Call `propose_article` with your summary (title, key sections, angle — 3-5 bullet points) and a detailed brief (all sources, key facts, user preferences, angle, what to avoid, related articles). Do not start writing an article without proposing first. The client environment determines what happens next — in some environments the user will see a plan card with options (write here vs. run in background), in others you'll get a text response telling you to proceed. Follow whatever the tool response says.",
+            "2. **Read the writing guidelines** — Fetch https://www.openalmanac.org/writing-guidelines.md and https://www.openalmanac.org/ai-patterns-to-avoid.md before writing a single word.",
             "",
-            "3. **Read the writing guidelines** — Fetch https://www.openalmanac.org/writing-guidelines.md and https://www.openalmanac.org/ai-patterns-to-avoid.md before writing a single word.",
+            "3. **Scaffold** — Use `new` with one or more `{ title, slug?, topics? }` entries and a `wiki_slug`. Provide `slug` when you know the canonical ID; otherwise it is auto-derived from the title. List ALL sources you've gathered in the frontmatter before writing any body text. Don't discard sources — if you read it during research and it's relevant, include it.",
             "",
-            "4. **Scaffold** — Use `new` with one or more `{ title, slug?, topics? }` entries and a `wiki_slug`. Provide `slug` when you know the canonical ID; otherwise it is auto-derived from the title. List ALL sources you've gathered in the frontmatter before writing any body text. Don't discard sources — if you read it during research and it's relevant, include it.",
-            "",
-            "5. **Write a pure text draft** — This whole process (writing, review, fact-check, images, linking) takes a few minutes. Let the user know in a fun way that they can step away — and that once it's ready, you're happy to discuss any edits or polishing.",
+            "4. **Write a pure text draft** — This whole process (writing, review, fact-check, images, linking) takes a few minutes. Let the user know in a fun way that they can step away — and that once it's ready, you're happy to discuss any edits or polishing.",
             "",
             "   Write the full article body with citation markers [@key]. No wikilinks, no `[[slug|Display Text]]` syntax, no images, no stubs. Just prose and citations. The linking and images come later from subagents who need to read the finished text.",
             "",
-            "6. **Dispatch four subagents in parallel** — After the draft is complete, dispatch these simultaneously. Each agent has its own guidelines file — tell it to fetch and read that file as its first step. The guidelines file tells the agent what to do, what additional guidelines to fetch, and what format to return results in.",
+            "5. **Dispatch four subagents in parallel** — After the draft is complete, dispatch these simultaneously. Each agent has its own guidelines file — tell it to fetch and read that file as its first step. The guidelines file tells the agent what to do, what additional guidelines to fetch, and what format to return results in.",
             "",
             "   - **Review agent** → tell it to read https://www.openalmanac.org/review-guidelines.md and review the draft at `~/.openalmanac/articles/{wiki_slug}/{slug}.md`",
             "   - **Fact-check agent** → tell it to read https://www.openalmanac.org/fact-checking-guidelines.md and fact-check the draft at `~/.openalmanac/articles/{wiki_slug}/{slug}.md`",
             "   - **Image agent** → tell it to read https://www.openalmanac.org/image-guidelines.md and find images for the draft at `~/.openalmanac/articles/{wiki_slug}/{slug}.md`",
             "   - **Linking agent** → tell it to read https://www.openalmanac.org/linking-guidelines.md and add wikilinks for the draft at `~/.openalmanac/articles/{wiki_slug}/{slug}.md` (dead links become stubs on publish)",
             "",
-            "7. **Integrate** — Present the review and fact-check feedback to the user. Then fix everything in one pass: review issues, fact-check corrections, add images, add wikilinks.",
+            "6. **Integrate** — Present the review and fact-check feedback to the user. Then fix everything in one pass: review issues, fact-check corrections, add images, add wikilinks.",
             "",
-            "8. **Publish** — Validate and publish (`publish` with `slugs` and `wiki_slug`). Put per-page change notes in frontmatter as `edit_summary`. Share the exact URL from the publish response when single-page. Use `list_articles` to verify coverage.",
+            "7. **Publish** — Validate and publish (`publish` with `slugs` and `wiki_slug`). Put per-page change notes in frontmatter as `edit_summary`. Share the exact URL from the publish response when single-page. Use `list_articles` to verify coverage.",
             "",
             "Why this order: the draft must be finished before subagents run. The linking agent needs to see what entities are actually in the text. The image agent needs to match images to specific content. The review agent needs the complete article. Everything reads the draft.",
             "",
@@ -160,7 +158,7 @@ export function createServer() {
             "3. **Brainstorm structure with the user.** Be conversational, not a form-filler. Propose a few natural topics the wiki might have (3-6 bullet points max), what the scope is, what the voice/angle is. Ask what resonates. Don't write prose yet.",
             "4. **Create the wiki.** `create_wiki` with title + description. The server auto-scaffolds a `main-page` with default homepage directives.",
             "5. **Edit the main page in place.** `download` the auto-created `main-page` and edit the file (don't `new` a fresh `main-page` — the server derives slug from title, so a new scaffold would get a different slug and you'd end up with two homepages).",
-            "6. **Seed the topic hierarchy.** `create_topics_batch` with the topics you agreed on.",
+            "6. **Seed the topic hierarchy.** `create_topics` with the topics you agreed on.",
             "7. **Wire navigation.** `update_wiki_settings` with a `nav` array. Each NavItem needs exactly one of `page` / `topic` / `link`. Use `auto: {enabled: true}` on topic NavItems to auto-populate children from the topic DAG.",
             "8. **Seed a few stub pages or first articles.** Stubs are fine — scaffold-and-fill-later is a supported workflow.",
             "",
@@ -175,6 +173,10 @@ export function createServer() {
             "After publishing, share the celebration URL when applicable. Use `list_articles` with `wiki_slug` to browse a wiki's pages.",
             "",
             "When working with tool results, write down any important information you might need later, as the original tool result may be cleared.",
+            "",
+            "## Batching writes",
+            "",
+            "Most write tools take arrays. Pass a single-element array for one item — there is no separate singular tool. Examples: `create_topics([{ title: \"X\" }])`, `delete_pages({ article_slugs: [\"foo\"] })`, `publish({ slugs: [\"bar\"] })`. Do not call a tool in a loop when an array argument exists.",
         ].join("\n"),
     });
     registerAuthTools(server);

package/dist/setup.js

@@ -18,11 +18,10 @@ const TOOL_GROUPS = [
     },
     {
         name: "Research",
-        description: "web search, read pages, register sources, find images",
+        description: "web search, read pages, find images",
         tools: [
             "mcp__almanac__search_web",
             "mcp__almanac__read_webpage",
-            "mcp__almanac__register_sources",
             "mcp__almanac__search_images",
             "mcp__almanac__view_images",
         ],

package/dist/tools/pages.js

@@ -3,31 +3,9 @@ import { readFileSync, writeFileSync, mkdirSync, readdirSync, existsSync, unlink
 import { join } from "node:path";
 import { stringify as yamlStringify } from "yaml";
 import { request, ARTICLES_DIR } from "../auth.js";
-import { validateArticle } from "../validate.js";
 import { openBrowser } from "../browser.js";
+import { coerceJson } from "../utils.js";
 const SLUG_RE = /^[a-z0-9]+(-[a-z0-9]+)*$/;
-function slugify(title) {
-    return title
-        .toLowerCase()
-        .normalize("NFD")
-        .replace(/[\u0300-\u036f]/g, "")
-        .replace(/[^a-z0-9]+/g, "-")
-        .replace(/^-+|-+$/g, "")
-        .replace(/-{2,}/g, "-");
-}
-function coerceJson(schema) {
-    return z.preprocess((val) => {
-        if (typeof val === "string") {
-            try {
-                return JSON.parse(val);
-            }
-            catch {
-                return val;
-            }
-        }
-        return val;
-    }, schema);
-}
 function resolvePageDir(wikiSlug) {
     return join(ARTICLES_DIR, wikiSlug);
 }
@@ -76,11 +54,111 @@ Page body with [@key] citation markers and [[wikilinks]]...
 - Keys must be kebab-case with at least one hyphen
 - Every source must be referenced; every reference must have a source
 
+## Quoting
+
+For any string value with punctuation, quotes, or special characters (common in \`sources[].title\`), use YAML block-literal syntax:
+
+\`\`\`yaml
+sources:
+  - key: farza-yc
+    title: |-
+      "I'm joining Y Combinator, again" — Farza Majeed
+    url: https://...
+\`\`\`
+
+This sidesteps every YAML escaping rule. If you skip this, inner double quotes or em-dashes will break the parser.
+
 ## Images
 
 Use search_images to find relevant images. Syntax: \`![Caption](url "position")\`
 Positions: "right" (default), "left", "center". Every image needs a descriptive caption.
 `.trim();
+function formatPublishResults(results, targetSlugs, wiki_slug, dry_run) {
+    const allAutoStubs = new Set();
+    const lines = [];
+    let okCount = 0;
+    let errorCount = 0;
+    for (let i = 0; i < results.length; i++) {
+        const r = results[i];
+        const slug = targetSlugs[i] ?? r.slug;
+        if (dry_run && r.plan) {
+            const plan = r.plan;
+            const hasError = plan.validation.status === "failed" ||
+                !plan.authorization.can_write ||
+                plan.action === "error";
+            if (hasError) {
+                errorCount++;
+                const reasons = [];
+                for (const e of plan.validation.errors) {
+                    reasons.push(`${e.field}: ${e.message}`);
+                }
+                if (!plan.authorization.can_write && plan.authorization.reason) {
+                    reasons.push(`auth: ${plan.authorization.reason}`);
+                }
+                lines.push(`- ${slug}: **error** — ${reasons.join("; ")}`);
+            }
+            else {
+                okCount++;
+                let line = `- ${plan.slug}: **${plan.action}**`;
+                if (plan.renamed_from)
+                    line += ` (rename: ${plan.renamed_from} → ${plan.slug})`;
+                const details = [];
+                if (plan.source_keys.referenced.length > 0) {
+                    details.push(`${plan.source_keys.referenced.length} source(s)`);
+                }
+                if (plan.wikilinks.will_auto_stub.length > 0) {
+                    details.push(`${plan.wikilinks.will_auto_stub.length} new stub(s)`);
+                    plan.wikilinks.will_auto_stub.forEach(s => allAutoStubs.add(s));
+                }
+                if (plan.source_keys.orphaned.length > 0) {
+                    details.push(`missing source key(s): ${plan.source_keys.orphaned.join(", ")}`);
+                }
+                if (plan.source_keys.unreferenced.length > 0) {
+                    details.push(`unreferenced source(s): ${plan.source_keys.unreferenced.join(", ")}`);
+                }
+                if (details.length > 0)
+                    line += ` (${details.join(", ")})`;
+                lines.push(line);
+            }
+        }
+        else {
+            // Real publish result
+            if (r.status === "error") {
+                errorCount++;
+                lines.push(`- ${r.slug}: **error** — ${r.error}`);
+            }
+            else {
+                okCount++;
+                // Clean up local files — pre-rename slug names the file
+                const fileSlug = r.renamed_from ?? slug;
+                const { filePath, refPath } = resolvePagePaths(fileSlug, wiki_slug);
+                try {
+                    unlinkSync(filePath);
+                }
+                catch { /* ok */ }
+                try {
+                    unlinkSync(refPath);
+                }
+                catch { /* ok */ }
+                let line = `- ${r.slug}: **${r.status}**`;
+                if (r.renamed_from)
+                    line += ` (renamed from ${r.renamed_from})`;
+                if (r.stubs_created?.length) {
+                    r.stubs_created.forEach(s => allAutoStubs.add(s));
+                }
+                lines.push(line);
+            }
+        }
+    }
+    const verb = dry_run ? "Dry-run" : "Published";
+    const summary = `${verb}: ${okCount}/${targetSlugs.length} OK${errorCount > 0 ? `, ${errorCount} error(s)` : ""}.`;
+    const parts = [summary, "", ...lines];
+    if (allAutoStubs.size > 0) {
+        const stubVerb = dry_run ? "Stubs that will be auto-created" : "Stubs auto-created";
+        parts.push("", `${stubVerb}: ${[...allAutoStubs].join(", ")}`);
+    }
+    return parts.join("\n");
+}
 export function registerPageTools(server) {
     server.addTool({
         name: "search_articles",
@@ -187,11 +265,19 @@ export function registerPageTools(server) {
     server.addTool({
         name: "new",
         description: "Scaffold new pages locally. Creates .md files with YAML frontmatter and empty bodies. " +
-            "No .ref file is created (new pages). After writing content, use publish to go live.",
+            "No .ref file is created (new pages). After writing content, use publish to go live.\n\n" +
+            "Passing `slug` is an identity claim, not just a filename hint. The server will honor it " +
+            "at publish time instead of deriving a slug from the title. " +
+            "If no slug is provided, the server derives the slug from the title at publish.\n\n" +
+            "To edit the auto-generated main-page created by create_wiki, do NOT use `new` — " +
+            "use `download` with slug `main-page` to get the page and its ref token, then edit and publish. " +
+            "Publishing without a ref token is a create operation and will fail with a slug collision " +
+            "because main-page already exists.",
         parameters: z.object({
             pages: coerceJson(z.array(z.object({
                 title: z.string().describe("Page title"),
-                slug: z.string().optional().describe("Optional explicit slug"),
+                slug: z.string().optional().describe("Optional explicit slug (kebab-case). When provided, the server uses this slug " +
+                    "at publish instead of deriving one from the title."),
                 topics: z.array(z.string()).optional().describe("Topic slugs"),
             })).min(1).max(50)).describe("Pages to scaffold"),
             wiki_slug: z.string().describe("Wiki slug"),
@@ -202,17 +288,37 @@ export function registerPageTools(server) {
             const created = [];
             const skipped = [];
             for (const item of pages) {
-                const slug = item.slug || slugify(item.title);
-                if (!slug || !SLUG_RE.test(slug)) {
-                    skipped.push(`"${item.title}" → invalid slug "${slug}"`);
-                    continue;
+                // If an explicit slug is provided, validate it and use it for the filename.
+                // If none is provided, derive a simple filename from the title for local
+                // convenience only — the server will derive the authoritative slug from
+                // the title at publish time.
+                let fileSlug;
+                if (item.slug) {
+                    if (!SLUG_RE.test(item.slug)) {
+                        skipped.push(`"${item.title}" → invalid slug "${item.slug}"`);
+                        continue;
+                    }
+                    fileSlug = item.slug;
+                }
+                else {
+                    // Local filename only — server derives from title at publish.
+                    fileSlug = item.title
+                        .toLowerCase()
+                        .replace(/[^a-z0-9]+/g, "-")
+                        .replace(/^-+|-+$/g, "")
+                        .replace(/-{2,}/g, "-") || "untitled";
                 }
-                const filePath = join(dir, `${slug}.md`);
+                const filePath = join(dir, `${fileSlug}.md`);
                 if (existsSync(filePath)) {
-                    skipped.push(`${slug}.md already exists`);
+                    skipped.push(`${fileSlug}.md already exists`);
                     continue;
                 }
                 const meta = { title: item.title, wiki: wiki_slug };
+                // Embed explicit slug in frontmatter so the server binds it at publish.
+                // Without this, changing the title would change the slug; with it, the
+                // server uses this slug regardless of the title's derived form.
+                if (item.slug)
+                    meta.slug = item.slug;
                 if (item.topics?.length)
                     meta.topics = item.topics;
                 meta.sources = [];
@@ -232,13 +338,19 @@ export function registerPageTools(server) {
         name: "publish",
         description: "Publish pages from your local workspace. Reads .md files and their .ref sidecars, " +
             "sends to the API. Pages with .ref are updates; pages without are new. " +
-            "Dead wikilinks auto-create stubs. Put edit_summary in frontmatter for change descriptions. Requires login.",
+            "Dead wikilinks auto-create stubs. Put edit_summary in frontmatter for change descriptions. Requires login.\n\n" +
+            "Set dry_run=true to plan without committing: the backend validates frontmatter, checks authorization, " +
+            "resolves wikilinks, cross-checks citation keys, and detects renames — all read-only. " +
+            "Caveats: plan reflects state at time of check — permissions and slug availability may change before real publish. " +
+            "Rename detection shows the slug derived from the current title; subsequent title edits can change this.",
         parameters: z.object({
             slugs: coerceJson(z.array(z.string()).min(1).max(50)).optional()
                 .describe("Specific page slugs to publish"),
             wiki_slug: z.string().describe("Wiki slug"),
+            dry_run: z.boolean().default(false).optional()
+                .describe("When true, plan all pages without committing any changes"),
         }),
-        async execute({ slugs, wiki_slug }) {
+        async execute({ slugs, wiki_slug, dry_run }) {
             const dir = resolvePageDir(wiki_slug);
             // Determine which files to publish
             let targetSlugs;
@@ -262,95 +374,103 @@ export function registerPageTools(server) {
                     throw new Error(`File not found: ${filePath}`);
                 }
                 const content = readFileSync(filePath, "utf-8");
-                const errors = validateArticle(content);
-                if (errors.length > 0) {
-                    throw new Error(`Validation failed for ${slug}:\n${errors.map(e => `  ${e.field}: ${e.message}`).join("\n")}`);
-                }
                 const ref = existsSync(refPath) ? readFileSync(refPath, "utf-8").trim() : null;
                 pages.push({ content, ref });
             }
-            const resp = await request("POST", `/api/w/${wiki_slug}/publish`, {
+            const endpoint = dry_run
+                ? `/api/w/${wiki_slug}/publish?dry_run=true`
+                : `/api/w/${wiki_slug}/publish`;
+            const resp = await request("POST", endpoint, {
                 auth: true,
                 json: { pages },
             });
             const results = (await resp.json());
-            // Clean up local files for successful publishes
-            const lines = [];
-            let okCount = 0;
-            for (const r of results) {
-                if (r.status === "error") {
-                    lines.push(`FAILED ${r.slug}: ${r.error}`);
-                    continue;
-                }
-                okCount++;
-                // The local file was named with the pre-rename slug. The server returns
-                // `renamed_from` on rename so we can clean up the right file without
-                // relying on request/response index parity.
-                const published_slug = r.renamed_from ?? r.slug;
-                const { filePath, refPath } = resolvePagePaths(published_slug, wiki_slug);
-                try {
-                    unlinkSync(filePath);
-                }
-                catch { /* ok */ }
-                try {
-                    unlinkSync(refPath);
-                }
-                catch { /* ok */ }
-                let detail = `OK ${r.slug}: ${r.status}`;
-                if (r.renamed_from)
-                    detail += ` (renamed from ${r.renamed_from})`;
-                if (r.stubs_created?.length)
-                    detail += `\n  Stubs created: ${r.stubs_created.join(", ")}`;
-                lines.push(detail);
-                // Open browser for single publish
-                if (targetSlugs.length === 1 && process.env.OPENALMANAC_GUI !== "1") {
+            const summary = formatPublishResults(results, targetSlugs, wiki_slug, dry_run ?? false);
+            // Open browser on single-page publish success (non-GUI, non-dry-run).
+            if (!dry_run && targetSlugs.length === 1 && process.env.OPENALMANAC_GUI !== "1") {
+                const r = results[0];
+                if (r && r.status !== "error") {
+                    const resultSlug = r.slug;
                     const url = wiki_slug === "global"
-                        ? `https://www.openalmanac.org/page/${r.slug}?celebrate=true`
-                        : `https://www.openalmanac.org/w/${wiki_slug}/${r.slug}?celebrate=true`;
+                        ? `https://www.openalmanac.org/page/${resultSlug}?celebrate=true`
+                        : `https://www.openalmanac.org/w/${wiki_slug}/${resultSlug}?celebrate=true`;
                     openBrowser(url);
                 }
             }
-            return `Published ${okCount}/${targetSlugs.length}.\n\n${lines.join("\n\n")}`;
+            return summary;
         },
     });
+    // propose_article — GUI-only handshake. Commented out 2026-04-23 per REV-62.
+    // Revive when the GUI plan-card proposal flow is in active use.
+    /*
     server.addTool({
-        name: "propose_article",
-        description: "Propose an article before writing it. Structures your proposal with a user-facing summary and a detailed brief. " +
-            "Do not start writing without proposing first.",
+      name: "propose_article",
+      description:
+        "Propose an article before writing it. Structures your proposal with a user-facing summary and a detailed brief. " +
+        "Do not start writing without proposing first.",
+      parameters: z.object({
+        summary: z.string().describe("User-facing summary (3-5 bullet points)"),
+        details: z.string().describe("Full handoff brief with all sources, key facts, angle"),
+        title: z.string().describe("Proposed title"),
+        slug: z.string().describe("Proposed slug (kebab-case)"),
+        wiki_slug: z.string().default("global").describe("Wiki slug"),
+        _userChoice: z.enum(["background", "here", "expired", "already_in_progress"]).optional(),
+      }),
+      async execute({ summary, details, title, slug, wiki_slug, _userChoice }) {
+        if (_userChoice === "background") {
+          return `Article "${title}" is now being written in a background process.`;
+        }
+        if (_userChoice === "expired") {
+          return `Proposal expired. Continue the conversation naturally.`;
+        }
+        if (_userChoice === "already_in_progress") {
+          return `Article "${title}" is already being generated.`;
+        }
+        return `Article Proposal: ${title}\n\n${summary}\n\nProceed with writing this article following the writing flow in your instructions.`;
+      },
+    });
+    */
+    server.addTool({
+        name: "read_article",
+        description: "Read a single page by slug. Returns the full page JSON including content, topics, sources, and infobox. " +
+            "No side effects — use this to read a page without downloading it to disk or joining the wiki. " +
+            "For editing, use `download` instead (it writes local files and handles ref tokens). " +
+            "For discovery, use `search_articles` instead. No authentication needed.",
         parameters: z.object({
-            summary: z.string().describe("User-facing summary (3-5 bullet points)"),
-            details: z.string().describe("Full handoff brief with all sources, key facts, angle"),
-            title: z.string().describe("Proposed title"),
-            slug: z.string().describe("Proposed slug (kebab-case)"),
-            wiki_slug: z.string().default("global").describe("Wiki slug"),
-            _userChoice: z.enum(["background", "here", "expired", "already_in_progress"]).optional(),
+            wiki_slug: z.string().describe("Wiki slug"),
+            article_slug: z.string().describe("Page slug"),
         }),
-        async execute({ summary, details, title, slug, wiki_slug, _userChoice }) {
-            if (_userChoice === "background") {
-                return `Article "${title}" is now being written in a background process.`;
-            }
-            if (_userChoice === "expired") {
-                return `Proposal expired. Continue the conversation naturally.`;
-            }
-            if (_userChoice === "already_in_progress") {
-                return `Article "${title}" is already being generated.`;
-            }
-            return `Article Proposal: ${title}\n\n${summary}\n\nProceed with writing this article following the writing flow in your instructions.`;
+        async execute({ wiki_slug, article_slug }) {
+            const resp = await request("GET", `/api/w/${wiki_slug}/pages/${article_slug}`);
+            return JSON.stringify(await resp.json(), null, 2);
         },
     });
     server.addTool({
-        name: "resolve",
-        description: "Check if pages exist before writing wikilinks. Returns status (found/stub/not_found) for each target. " +
-            "Use this to verify links before publishing.",
+        name: "delete_pages",
+        description: "⚠️ Permanently deletes pages. Cannot be undone. Confirm with user before calling. " +
+            "Accepts multiple slugs and deletes them in sequence. Requires moderator or creator access.",
         parameters: z.object({
             wiki_slug: z.string().describe("Wiki slug"),
-            targets: coerceJson(z.array(z.string()).min(1).max(50)).describe("Link targets to resolve"),
+            article_slugs: coerceJson(z.array(z.string()).min(1).max(50)).describe("Page slugs to delete (1-50)"),
         }),
-        async execute({ wiki_slug, targets }) {
-            const resp = await request("POST", `/api/w/${wiki_slug}/resolve`, {
-                json: { targets },
-            });
-            return JSON.stringify(await resp.json(), null, 2);
+        async execute({ wiki_slug, article_slugs }) {
+            const results = [];
+            for (const slug of article_slugs) {
+                try {
+                    // DELETE returns 204 No Content on success
+                    await request("DELETE", `/api/w/${wiki_slug}/pages/${slug}`, { auth: true });
+                    results.push({ slug, status: "deleted" });
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    results.push({ slug, status: "error", message });
+                }
+            }
+            const deleted = results.filter(r => r.status === "deleted").length;
+            const lines = results.map(r => r.status === "deleted"
+                ? `- ${r.slug}: deleted`
+                : `- ${r.slug}: error — ${r.message}`);
+            return `Deleted ${deleted}/${article_slugs.length} pages.\n\n${lines.join("\n")}`;
         },
     });
 }

package/dist/tools/research.js

@@ -1,24 +1,7 @@
 import { z } from "zod";
 import { imageContent } from "fastmcp";
 import { request } from "../auth.js";
-/**
- * Workaround for Claude Agent SDK MCP transport bug (#18260):
- * Array/object parameters are sometimes serialized as JSON strings
- * instead of native values. This preprocessor coerces them back.
- */
-function coerceJson(schema) {
-    return z.preprocess((val) => {
-        if (typeof val === "string") {
-            try {
-                return JSON.parse(val);
-            }
-            catch {
-                return val;
-            }
-        }
-        return val;
-    }, schema);
-}
+import { coerceJson } from "../utils.js";
 export function registerResearchTools(server) {
     const SearchWebInput = z.object({
         source: z.enum(["web", "reddit"]).describe("Search source. Use 'web' for Google/Serper and 'reddit' for community perspectives via Reddit."),
@@ -118,7 +101,7 @@ export function registerResearchTools(server) {
     server.addTool({
         name: "search_images",
         description: "Search for images to include in articles. Accepts multiple queries for batch lookup. Returns image URLs, titles, dimensions, and licensing info. " +
-            "Two sources: 'wikimedia' (free, open-licensed images from Wikimedia Commons — preferred) and 'google' (broader web images via Google). " +
+            "Three sources: 'google' (broad web images, default), 'unsplash' (high-quality stock photos), and 'wikimedia' (free, open-licensed from Wikimedia Commons). " +
             "Use descriptive search terms. After searching, call view_images on promising candidates to see what they actually show before using them. " +
             "External image URLs are automatically persisted when you publish the article — no extra steps needed.\n\n" +
             "## Using images in articles\n\n" +
@@ -145,7 +128,7 @@ export function registerResearchTools(server) {
             "Requires login. Rate limit: 10/min.",
         parameters: z.object({
             queries: coerceJson(z.array(z.string()).min(1).max(10)).describe("Image search queries (1-10)"),
-            source: z.enum(["wikimedia", "google"]).default("wikimedia").describe("Image source: 'wikimedia' (free, open-licensed — preferred) or 'google' (broader coverage)"),
+            source: z.enum(["wikimedia", "google", "unsplash"]).default("google").describe("Image source: 'google' (broad web images, default), 'unsplash' (high-quality stock photos), or 'wikimedia' (free, open-licensed)"),
             limit: z.number().default(5).describe("Max results per query (1-10, default 5)"),
         }),
         async execute({ queries, source, limit }) {
@@ -186,20 +169,25 @@ export function registerResearchTools(server) {
             return { content };
         },
     });
+    // register_sources — GUI citation-bubble handshake. Commented out 2026-04-23 per REV-62.
+    // Revive when the GUI citation-bubble flow is re-wired.
+    /*
     server.addTool({
-        name: "register_sources",
-        description: "Register sources you plan to cite in your response. Call this BEFORE writing your response text. " +
-            "In GUI explore sessions this updates the source registry used for citation bubbles. " +
-            "Use [@key] markers in your response to cite them.",
-        parameters: z.object({
-            sources: coerceJson(z.array(z.object({
-                key: z.string().describe("Citation key — kebab-case, BibTeX-style: {domain}-{title-words}"),
-                url: z.string().describe("Source URL"),
-                title: z.string().describe("Source title — include publication name after an em dash when relevant"),
-            })).min(1)).describe("Sources to register for citation"),
-        }),
-        async execute({ sources }) {
-            return `Registered ${sources.length} source${sources.length === 1 ? "" : "s"}. Use [@key] markers in your response to cite them.`;
-        },
+      name: "register_sources",
+      description:
+        "Register sources you plan to cite in your response. Call this BEFORE writing your response text. " +
+        "In GUI explore sessions this updates the source registry used for citation bubbles. " +
+        "Use [@key] markers in your response to cite them.",
+      parameters: z.object({
+        sources: coerceJson(z.array(z.object({
+          key: z.string().describe("Citation key — kebab-case, BibTeX-style: {domain}-{title-words}"),
+          url: z.string().describe("Source URL"),
+          title: z.string().describe("Source title — include publication name after an em dash when relevant"),
+        })).min(1)).describe("Sources to register for citation"),
+      }),
+      async execute({ sources }) {
+        return `Registered ${sources.length} source${sources.length === 1 ? "" : "s"}. Use [@key] markers in your response to cite them.`;
+      },
     });
+    */
 }

package/dist/tools/topics.js

@@ -1,18 +1,6 @@
 import { z } from "zod";
 import { request } from "../auth.js";
-function coerceJson(schema) {
-    return z.preprocess((val) => {
-        if (typeof val === "string") {
-            try {
-                return JSON.parse(val);
-            }
-            catch {
-                return val;
-            }
-        }
-        return val;
-    }, schema);
-}
+import { coerceJson } from "../utils.js";
 export function registerTopicTools(server) {
     server.addTool({
         name: "list_topics",
@@ -28,24 +16,6 @@ export function registerTopicTools(server) {
             return JSON.stringify(await resp.json(), null, 2);
         },
     });
-    server.addTool({
-        name: "create_topic",
-        description: "Create a topic in a wiki. Topics are lightweight categories — pages can belong to multiple topics. Requires wiki membership.",
-        parameters: z.object({
-            wiki_slug: z.string().describe("Wiki slug"),
-            title: z.string().describe("Topic title"),
-            description: z.string().default("").describe("Topic description"),
-            image_url: z.string().url().max(2048).optional().describe("Topic image URL (https:// or http://)"),
-            parent_slugs: coerceJson(z.array(z.string())).default([]).describe("Parent topic slugs"),
-        }),
-        async execute({ wiki_slug, title, description, image_url, parent_slugs }) {
-            const resp = await request("POST", `/api/w/${wiki_slug}/topics`, {
-                auth: true,
-                json: { title, description, image_url, parent_slugs },
-            });
-            return JSON.stringify(await resp.json(), null, 2);
-        },
-    });
     server.addTool({
         name: "update_topic",
         description: "Update a topic's title, description, or image. Requires wiki moderator role.",
@@ -75,8 +45,8 @@ export function registerTopicTools(server) {
         },
     });
     server.addTool({
-        name: "create_topics_batch",
-        description: "Batch create topics in a wiki. Useful for bootstrapping a topic hierarchy. Requires wiki membership.",
+        name: "create_topics",
+        description: "Create one or more topics in a wiki. Topics are lightweight categories — pages can belong to multiple topics. Pass a single-element array for one topic: `[{ title: \"Security Pins\" }]`. Useful for bootstrapping a topic hierarchy. Requires wiki membership.",
         parameters: z.object({
             wiki_slug: z.string().describe("Wiki slug"),
             topics: coerceJson(z.array(z.object({
@@ -84,7 +54,7 @@ export function registerTopicTools(server) {
                 description: z.string().default(""),
                 image_url: z.string().url().max(2048).optional(),
                 parent_slugs: z.array(z.string()).default([]),
-            })).min(1).max(100)).describe("Topics to create"),
+            })).min(1).max(100)).describe("Topics to create (N=1 is fully supported)"),
         }),
         async execute({ wiki_slug, topics }) {
             const resp = await request("POST", `/api/w/${wiki_slug}/topics/batch`, {