opencode-wiki-historian 0.2.0 → 0.4.0

package/dist/tools/shared.d.ts

@@ -12,8 +12,9 @@ import type { ToolResult } from '@opencode-ai/plugin';
 import type { GqlClient } from '../wiki/client.js';
 import type { HistorianOptions } from '../config.js';
 import type { PageDeps } from '../wiki/pages.write.js';
-import type { TranslateFn, Locale } from '../wiki/pages.read.js';
+import type { TranslateFn, Locale, PageListItem } from '../wiki/pages.read.js';
 import { type LocalePair } from '../wiki/locale.js';
+import { type Genre } from '../templates/genres.js';
 /** Per-tool dependency bag; the client is a thunk so a bad key surface at
  *  buildTools time as nothing — only the first execution that touches the
  *  wiki resolves it (and then yields a ConfigError envelope, not a crash).
@@ -50,3 +51,78 @@ export declare function okJson(body: Record<string, unknown>): ToolResult;
 export declare function errEnvelope(err: unknown): ToolResult;
 /** Destructive-action gate: refusal BEFORE any fetch when confirm is absent. */
 export declare function confirmRequiredJson(toolName: string, got: unknown): ToolResult;
+/** Machine namespaces: pages whose first path segment lives here are hidden
+ *  machine-tier pages (the `_meta/page-map` cache precedent in src/map.ts —
+ *  isPublished:false + isPrivate:true + tags + twin:false). */
+export declare const INTERNAL_NAMESPACES: readonly ["_meta", "_evidence"];
+/** Plan-mandated note on every evidence-tier success envelope (verbatim). */
+export declare const MACHINE_TIER_NOTE = "machine-tier page; anonymous visits 404 by design";
+/** Tier enum values — single source of truth. The zod schema itself must be
+ *  declared locally per tool via `s.enum(TIERS)`: exporting a zod value from
+ *  here breaks declaration emit (TS2742 — tool.schema is zod 4.1.8 nested in
+ *  @opencode-ai/plugin, unnameable without a zod import, and root zod is v3). */
+export declare const TIERS: readonly ["front", "evidence"];
+/** Page tier: 'front' = bilingual human surface; 'evidence' = machine namespace. */
+export type Tier = (typeof TIERS)[number];
+/** True when the path's first segment is an internal (machine) namespace. */
+export declare function isInternalPath(path: string): boolean;
+/** Pure tier↔path guard: null when the pair is legal, an error string when
+ *  not (evidence ⇒ internal namespace; front ⇒ NOT internal). */
+export declare function enforceTierPath(tier: Tier, path: string): string | null;
+/** Tier↔path mismatch → uniform failure envelope (no fetch has run yet). */
+export declare function tierMismatchJson(message: string): ToolResult;
+/** Evidence-tier zh-side input → refusal envelope (monolingual invariant). */
+export declare function monolingualRefusalJson(toolName: string, argumentName: string): ToolResult;
+/** Soft-gate advisory for front-tier raw dumps: null when nothing to say
+ *  (evidence tier NEVER checked — machine pages are the raw-material home;
+ *  fence at or under the limit). The advisory is informational only: every
+ *  caller still performs the write. */
+export declare function frontDumpAdvisory(tier: Tier, content: string): string | null;
+export interface CollisionInput {
+    readonly tier: Tier;
+    readonly path: string;
+    readonly locale: Locale;
+    readonly title: string;
+    readonly baseUrl: string;
+    /** Exact-(path, locale) pre-read result. A FAILED read must pass false — a
+     *  transport hiccup never masquerades as a collision (the write proceeds
+     *  with no advice rather than with wrong advice). */
+    readonly exists: boolean;
+    /** listPages inventory snapshot; a failed listPages read yields [] → no
+     *  duplicate advice, only the (independent) path-existence line can fire. */
+    readonly inventory: readonly PageListItem[];
+}
+/** Advisory-only duplicate detector for historian_page_create:
+ *  (a) the exact target (path, locale) already exists → prefer
+ *      historian_page_update, with the page URL;
+ *  (b) the same normalized title lives on a DIFFERENT non-machine path →
+ *      疑似重复 … 先读再写, with each path's URLs (first 3, then a count).
+ *  Pure over its inputs and advisory-only: it NEVER throws and NEVER blocks —
+ *  a same-path other-locale twin is not a duplicate, evidence-tier writes skip
+ *  (b) (raw-material pages legitimately echo human titles), and machine
+ *  namespaces (_meta/, _evidence/) never surface as duplicates. */
+export declare function collisionAdvisory(input: CollisionInput): string | null;
+/**
+ * Pre-write self-check advisory (plan todo 4): score the draft with the SAME
+ * 10-item gate the migrate pipeline uses (scoreChecklist — no duplicated
+ * scoring logic), purely locally, zero network. 3+ failing items produce a
+ * hint naming them; items 9-10 are 'deferred' pre-write by the scorer's own
+ * contract (migrate-score.ts) and can never count as fail. Informational
+ * only — the write always proceeds; evidence tier is exempt (callers pass
+ * front only: raw material is not a genre page).
+ */
+export declare function checklistAdvisory(genre: Genre, draft: string): string | null;
+/** Config-level write refusal, paralleling PathValidationError's shape. The
+ *  class NAME is the routing key errEnvelope dispatches on: this shares the
+ *  'ConfigError' hint case with jsonc.ConfigError (which adds a code field
+ *  this pure path rule does not need). */
+export declare class ConfigError extends Error {
+    constructor(message: string);
+}
+/** Pure allow-list check on a write target path: null = allowed, string =
+ *  refusal message. Empty/undefined allow-list = allow-all (the documented
+ *  default, config.ts HistorianOptions.sections). Match is segment-wise and
+ *  case-sensitive: section 'doc' authorizes 'doc' and 'doc/x', never 'docs/x'. */
+export declare function sectionGuard(path: string, allowedSections: readonly string[] | undefined): string | null;
+/** Guard + envelope in one step: null = proceed, ToolResult = refuse. */
+export declare function sectionRefusalJson(path: string, allowedSections: readonly string[] | undefined): ToolResult | null;

package/dist/tools/shared.js

@@ -9,6 +9,8 @@
  * here.
  */
 import { assertLocalePair, PathValidationError } from '../wiki/locale.js';
+import { scoreChecklist } from '../migrate-score.js';
+import { selfReviewChecklist } from '../templates/genres.js';
 /** Engine deps for one operation; client resolved lazily at use time. */
 export function pageDeps(deps) {
     return { client: deps.getClient(), options: deps.options, translate: deps.translate };
@@ -85,3 +87,220 @@ function hintFor(errorKind) {
             return 'Inspect the message and retry.';
     }
 }
+// --- Tier plumbing (v3 todo 4) ------------------------------------------------
+/** Machine namespaces: pages whose first path segment lives here are hidden
+ *  machine-tier pages (the `_meta/page-map` cache precedent in src/map.ts —
+ *  isPublished:false + isPrivate:true + tags + twin:false). */
+export const INTERNAL_NAMESPACES = ['_meta', '_evidence'];
+/** Plan-mandated note on every evidence-tier success envelope (verbatim). */
+export const MACHINE_TIER_NOTE = 'machine-tier page; anonymous visits 404 by design';
+/** Tier enum values — single source of truth. The zod schema itself must be
+ *  declared locally per tool via `s.enum(TIERS)`: exporting a zod value from
+ *  here breaks declaration emit (TS2742 — tool.schema is zod 4.1.8 nested in
+ *  @opencode-ai/plugin, unnameable without a zod import, and root zod is v3). */
+export const TIERS = ['front', 'evidence'];
+/** True when the path's first segment is an internal (machine) namespace. */
+export function isInternalPath(path) {
+    const first = path.split('/')[0];
+    return INTERNAL_NAMESPACES.includes(first);
+}
+/** Pure tier↔path guard: null when the pair is legal, an error string when
+ *  not (evidence ⇒ internal namespace; front ⇒ NOT internal). */
+export function enforceTierPath(tier, path) {
+    const internal = isInternalPath(path);
+    switch (tier) {
+        case 'evidence':
+            return internal
+                ? null
+                : `tier "evidence" requires a machine namespace path (${INTERNAL_NAMESPACES.map((n) => `${n}/`).join(' or ')}) — got '${path}'`;
+        case 'front':
+            return internal
+                ? `tier "front" cannot write to the machine namespace '${path}' — use tier "evidence" for ${INTERNAL_NAMESPACES.map((n) => `${n}/`).join(' or ')} paths`
+                : null;
+    }
+}
+/** Tier↔path mismatch → uniform failure envelope (no fetch has run yet). */
+export function tierMismatchJson(message) {
+    return dump({
+        ok: false,
+        error: 'tier-path-mismatch',
+        errorKind: 'TierPathMismatchError',
+        message,
+        actionableHint: 'Pass the tier that matches the path namespace: _meta/ and _evidence/ are machine (evidence) paths; everything else is front.',
+    });
+}
+/** Evidence-tier zh-side input → refusal envelope (monolingual invariant). */
+export function monolingualRefusalJson(toolName, argumentName) {
+    return dump({
+        ok: false,
+        error: 'evidence-monolingual',
+        errorKind: 'TierMonolingualError',
+        message: `${toolName} received "${argumentName}" on an evidence-tier page, which is monolingual en`,
+        actionableHint: 'Drop the zh-side argument (locale "zh" / sectionZh) — evidence machine pages never carry a bilingual twin.',
+    });
+}
+// --- Front-tier raw-dump soft gate (v3 todo 6) --------------------------------
+/** Contract band (SKILL.md SYN-16): a human page stays a 5-10 line excerpt;
+ *  longer raw material belongs on an evidence page. Strictly ABOVE this many
+ *  fence-interior lines triggers the advisory — 30 is the soft gate, never a
+ *  hard refusal. Deliberately layered vs the contract bands; do not unify. */
+const FRONT_DUMP_FENCE_LIMIT = 30;
+/** Longest fenced code block in the content, counting lines STRICTLY inside
+ *  the ``` fences (fence markers excluded). An unterminated fence counts to
+ *  EOF. Fences opening at line start (after optional indentation) close on
+ *  the next ```-leading line. */
+function longestFenceLines(content) {
+    let longest = 0;
+    let inside = false;
+    let count = 0;
+    for (const line of content.split('\n')) {
+        if (line.trimStart().startsWith('```')) {
+            if (inside) {
+                if (count > longest)
+                    longest = count;
+                inside = false;
+                count = 0;
+            }
+            else {
+                inside = true;
+                count = 0;
+            }
+        }
+        else if (inside) {
+            count++;
+        }
+    }
+    if (inside && count > longest)
+        longest = count; // unterminated fence → EOF
+    return longest;
+}
+/** Soft-gate advisory for front-tier raw dumps: null when nothing to say
+ *  (evidence tier NEVER checked — machine pages are the raw-material home;
+ *  fence at or under the limit). The advisory is informational only: every
+ *  caller still performs the write. */
+export function frontDumpAdvisory(tier, content) {
+    if (tier !== 'front')
+        return null;
+    const lines = longestFenceLines(content);
+    if (lines <= FRONT_DUMP_FENCE_LIMIT)
+        return null;
+    return (`content contains a ${lines}-line fenced block; per contract, move raw material to a ` +
+        `tier:"evidence" page under _evidence/ and link it from the human page (SYN-16)`);
+}
+// --- Create-path collision advisory (v4 todo 3) --------------------------------
+/** Title equality for duplicate detection: trim, collapse internal whitespace,
+ *  casefold — 'LLM Eval' == ' llm\neval '. */
+function normalizeTitle(title) {
+    return title.trim().replace(/\s+/gu, ' ').toLocaleLowerCase();
+}
+/** Number of duplicate paths shown verbatim before the overflow count. */
+const COLLISION_DUPE_DISPLAY_LIMIT = 3;
+/** Advisory-only duplicate detector for historian_page_create:
+ *  (a) the exact target (path, locale) already exists → prefer
+ *      historian_page_update, with the page URL;
+ *  (b) the same normalized title lives on a DIFFERENT non-machine path →
+ *      疑似重复 … 先读再写, with each path's URLs (first 3, then a count).
+ *  Pure over its inputs and advisory-only: it NEVER throws and NEVER blocks —
+ *  a same-path other-locale twin is not a duplicate, evidence-tier writes skip
+ *  (b) (raw-material pages legitimately echo human titles), and machine
+ *  namespaces (_meta/, _evidence/) never surface as duplicates. */
+export function collisionAdvisory(input) {
+    const parts = [];
+    if (input.exists) {
+        const urls = reportUrls(input.baseUrl, input.path, input.locale);
+        parts.push(`path exists — '${input.path}' (${input.locale}) already holds a page; ` +
+            `prefer historian_page_update to amend it; ${urls[input.locale]}`);
+    }
+    const norm = normalizeTitle(input.title);
+    if (input.tier === 'front' && norm !== '') {
+        const dupes = input.inventory.filter((row) => row.path !== input.path && !isInternalPath(row.path) && normalizeTitle(row.title) === norm);
+        const paths = [...new Set(dupes.map((row) => row.path))];
+        if (paths.length > 0) {
+            const shown = paths.slice(0, COLLISION_DUPE_DISPLAY_LIMIT).map((p) => {
+                const urls = reportUrls(input.baseUrl, p, input.locale);
+                return `${p} (en=${urls.en} zh=${urls.zh})`;
+            });
+            const overflow = paths.length - shown.length;
+            parts.push(`疑似重复: title matches other path(s) ${shown.join('; ')}` +
+                (overflow > 0 ? ` +${overflow} more` : '') +
+                ` — 先读再写 (historian_read the existing page, prefer historian_page_update over a new twin)`);
+        }
+    }
+    return parts.length === 0 ? null : parts.join('\n');
+}
+// --- Create-path pre-write checklist gate (v4 todo 4) --------------------------
+/** Failing items needed to speak up: 1-2 stragglers are noise, 3+ is a draft
+ *  worth flagging. Threshold per the plan (todo 4). */
+const CHECKLIST_FAIL_TRIGGER = 3;
+/** The zh short name of a checklist item: its label up to the first
+ *  full-width/latin colon or bracket — '导言占比 10–15%'. */
+function itemShortName(label) {
+    const cut = (label.split(/[：:（(]/u, 1)[0] ?? label).trim();
+    return cut === '' ? label.trim() : cut;
+}
+/**
+ * Pre-write self-check advisory (plan todo 4): score the draft with the SAME
+ * 10-item gate the migrate pipeline uses (scoreChecklist — no duplicated
+ * scoring logic), purely locally, zero network. 3+ failing items produce a
+ * hint naming them; items 9-10 are 'deferred' pre-write by the scorer's own
+ * contract (migrate-score.ts) and can never count as fail. Informational
+ * only — the write always proceeds; evidence tier is exempt (callers pass
+ * front only: raw material is not a genre page).
+ */
+export function checklistAdvisory(genre, draft) {
+    const failed = scoreChecklist(genre, draft).filter((v) => v.verdict === 'fail');
+    if (failed.length < CHECKLIST_FAIL_TRIGGER)
+        return null;
+    const labels = new Map(selfReviewChecklist(genre).map((item) => [item.id, item.label]));
+    const names = failed.map((v) => `#${v.id} ${itemShortName(labels.get(v.id) ?? '?')}`).join('; ');
+    return `自检 ${failed.length}/10 未通过: ${names} (不阻断, 发布前请补齐)`;
+}
+// --- options.sections enforcement (v4 todo 5) ---------------------------------
+/** Config-level write refusal, paralleling PathValidationError's shape. The
+ *  class NAME is the routing key errEnvelope dispatches on: this shares the
+ *  'ConfigError' hint case with jsonc.ConfigError (which adds a code field
+ *  this pure path rule does not need). */
+export class ConfigError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ConfigError';
+    }
+}
+/** First path segments the plugin maintains for its own bookkeeping — always
+ *  writable regardless of sections: a topic taxonomy configured for human
+ *  knowledge must never lock out the home landing page, the wiki-index map,
+ *  the _sandbox scratch area, the _data store, or the machine namespaces. */
+const SECTION_EXEMPT_SEGMENTS = [
+    'home',
+    'wiki-index',
+    '_sandbox',
+    '_data',
+    ...INTERNAL_NAMESPACES,
+];
+/** Section entry as configured → comparable form (strip slashes/whitespace). */
+function normalizeSection(entry) {
+    return entry.trim().replace(/^\/+|\/+$/gu, '');
+}
+/** Pure allow-list check on a write target path: null = allowed, string =
+ *  refusal message. Empty/undefined allow-list = allow-all (the documented
+ *  default, config.ts HistorianOptions.sections). Match is segment-wise and
+ *  case-sensitive: section 'doc' authorizes 'doc' and 'doc/x', never 'docs/x'. */
+export function sectionGuard(path, allowedSections) {
+    if (allowedSections === undefined)
+        return null;
+    const sections = allowedSections.map(normalizeSection).filter((sec) => sec !== '');
+    if (sections.length === 0)
+        return null;
+    const first = path.split('/')[0];
+    if (SECTION_EXEMPT_SEGMENTS.includes(first))
+        return null;
+    if (sections.some((sec) => path === sec || path.startsWith(`${sec}/`)))
+        return null;
+    return (`section '${first}' is not in the configured sections [${sections.join(', ')}] — ` +
+        `write the page under an allowed section or add '${first}' to the plugin's sections option`);
+}
+/** Guard + envelope in one step: null = proceed, ToolResult = refuse. */
+export function sectionRefusalJson(path, allowedSections) {
+    const violation = sectionGuard(path, allowedSections);
+    return violation === null ? null : errEnvelope(new ConfigError(violation));
+}

package/dist/tools/write.js

@@ -7,7 +7,7 @@
 import { tool } from '@opencode-ai/plugin';
 import { appendSection, createPage, updatePage, PageNotFoundError } from '../wiki/pages.js';
 import { readPage } from '../wiki/pages.read.js';
-import { errEnvelope, okJson, urlPair, URL_MANDATE, pageDeps } from './shared.js';
+import { enforceTierPath, errEnvelope, frontDumpAdvisory, isInternalPath, MACHINE_TIER_NOTE, monolingualRefusalJson, okJson, sectionRefusalJson, tierMismatchJson, TIERS, urlPair, URL_MANDATE, pageDeps, } from './shared.js';
 const s = tool.schema;
 const UPDATE_ARGS = {
     path: s.string(),
@@ -25,6 +25,9 @@ export function makeUpdateTool(deps) {
         args: UPDATE_ARGS,
         execute: async (raw) => {
             const args = UpdateArgsSchema.parse(raw);
+            const offSections = sectionRefusalJson(args.path, deps.options.sections);
+            if (offSections !== null)
+                return offSections;
             try {
                 const page = await readPage(deps.getClient(), args.path, args.locale);
                 if (page === null) {
@@ -36,6 +39,7 @@ export function makeUpdateTool(deps) {
                     description: args.description,
                     tags: args.tags,
                 });
+                const advisory = frontDumpAdvisory(inferredTier(page.path), args.content ?? '');
                 return okJson({
                     mode: 'update',
                     path: args.path,
@@ -51,6 +55,7 @@ export function makeUpdateTool(deps) {
                         updatedAt: result.page.updatedAt,
                     },
                     urls: urlPair(result),
+                    ...(advisory === null ? {} : { advisory }),
                 });
             }
             catch (err) {
@@ -59,6 +64,11 @@ export function makeUpdateTool(deps) {
         },
     });
 }
+/** Path-only tier resolution (same rule the append fallback uses): an
+ *  internal namespace first segment ⇒ evidence, anything else ⇒ front. */
+function inferredTier(path) {
+    return isInternalPath(path) ? 'evidence' : 'front';
+}
 async function bootstrapTwin(deps, primary, section, source) {
     const translate = source === 'translate' ? deps.translate : undefined;
     try {
@@ -84,21 +94,43 @@ const APPEND_ARGS = {
     section: s.string(),
     locale: s.enum(['en', 'zh']).default('en'),
     sectionZh: s.string().optional().describe('Explicit zh section; when absent the zh side falls back to translation/wiring'),
+    tier: s.enum(TIERS).optional().describe('Explicit tier; absent → inferred from the path (first segment _meta/ or _evidence/ ⇒ evidence, else front)'),
 };
 const AppendArgsSchema = s.object(APPEND_ARGS);
 export function makeAppendTool(deps) {
     return tool({
         description: `Append a section to an existing page (engine append + RMW). For the en page with a MISSING zh twin, ` +
             `the twin is auto-created — from sectionZh when given, else translated when the translator is wired. ` +
+            `Evidence-tier pages (_meta/ or _evidence/) are monolingual en — no twin handling. ` +
             `${URL_MANDATE}.`,
         args: APPEND_ARGS,
         execute: async (raw) => {
             const args = AppendArgsSchema.parse(raw);
+            // Exactly ONE resolution rule: explicit tier arg wins; otherwise infer
+            // from the path prefix (internal namespace ⇒ evidence).
+            const tier = args.tier ?? inferredTier(args.path);
+            const mismatch = enforceTierPath(tier, args.path);
+            if (mismatch !== null)
+                return tierMismatchJson(mismatch);
+            const isEvidence = tier === 'evidence';
+            if (isEvidence && args.locale === 'zh') {
+                return monolingualRefusalJson('historian_page_append', 'locale "zh"');
+            }
+            if (isEvidence && args.sectionZh !== undefined) {
+                return monolingualRefusalJson('historian_page_append', 'sectionZh');
+            }
+            const offSections = sectionRefusalJson(args.path, deps.options.sections);
+            if (offSections !== null)
+                return offSections;
             try {
                 const appended = await appendSection(pageDeps(deps), args.path, args.locale, args.section);
                 let zhStatus;
                 let zhNote;
-                if (args.locale === 'zh') {
+                if (isEvidence) {
+                    zhStatus = 'skipped';
+                    zhNote = 'evidence tier is monolingual en — no zh twin is bootstrapped or touched.';
+                }
+                else if (args.locale === 'zh') {
                     zhStatus = 'appended';
                     zhNote = 'Primary locale is zh — the en twin is untouched (check with historian_read(path, "en")).';
                 }
@@ -130,6 +162,7 @@ export function makeAppendTool(deps) {
                         zhNote = 'No zh twin exists and no translator is wired — provide sectionZh to bootstrap it.';
                     }
                 }
+                const advisory = frontDumpAdvisory(tier, args.section);
                 return okJson({
                     mode: 'append',
                     path: args.path,
@@ -138,6 +171,8 @@ export function makeAppendTool(deps) {
                     urls: urlPair(appended),
                     zhStatus,
                     zhNote,
+                    ...(isEvidence ? { note: MACHINE_TIER_NOTE } : {}),
+                    ...(advisory === null ? {} : { advisory }),
                 });
             }
             catch (err) {

package/dist/wiki/locale.d.ts

@@ -22,7 +22,8 @@ export declare class PathValidationError extends Error {
  *  5. first segment matches the locale shape (pitfall #9)
  *  6. any segment is length 1 (wiki.js rejects single-char path components)
  *  7. any segment contains characters outside `[A-Za-z0-9._-]`
- *  8. any segment is a reserved word (wiki.js endpoint collision)
+ *  8. any segment is a reserved word (wiki.js endpoint collision), except the
+ *     exact top-level 'home' (a live published path — see D9 note at the check)
  *
  * Order matters: cheap substring checks first, then per-segment rules.
  * Every rejection names the offending segment + the rule in the message.

package/dist/wiki/locale.js

@@ -44,7 +44,8 @@ const SEGMENT_CHARS = /^[A-Za-z0-9._-]+$/;
  *  5. first segment matches the locale shape (pitfall #9)
  *  6. any segment is length 1 (wiki.js rejects single-char path components)
  *  7. any segment contains characters outside `[A-Za-z0-9._-]`
- *  8. any segment is a reserved word (wiki.js endpoint collision)
+ *  8. any segment is a reserved word (wiki.js endpoint collision), except the
+ *     exact top-level 'home' (a live published path — see D9 note at the check)
  *
  * Order matters: cheap substring checks first, then per-segment rules.
  * Every rejection names the offending segment + the rule in the message.
@@ -84,7 +85,12 @@ export function validatePath(p) {
         if (!SEGMENT_CHARS.test(seg)) {
             throw new PathValidationError(`segment '${seg}' contains invalid characters (allowed: [A-Za-z0-9._-])`);
         }
-        if (RESERVED_WORDS.has(seg.toLowerCase())) {
+        // D9 bypass (probe p1): wiki.js 2.5.314 hosts a live published page at
+        // path=home (id48, en+zh) — the reserved-word block was plugin-side
+        // folklore, not a server limit. Allow the EXACT top-level segment 'home'
+        // only; nested 'home' (foo/home) and case variants (HOME) stay rejected.
+        const isExactTopLevelHome = segments.length === 1 && seg === 'home';
+        if (!isExactTopLevelHome && RESERVED_WORDS.has(seg.toLowerCase())) {
             throw new PathValidationError(`segment '${seg}' is a reserved wiki.js word (home|login|register|graphql|healthz|_assets|favicon)`);
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-wiki-historian",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "opencode plugin that manages a wiki.js knowledge base with bilingual pages, genre templates, and migration tooling.",
   "type": "module",
   "license": "MIT",