mulmoclaude 0.9.0 → 0.9.2

package/server/accounting/types.ts

@@ -1,148 +0,0 @@
-// Domain types for the accounting plugin (opt-in, custom-Role only).
-//
-// Source-of-truth files on disk:
-//   data/accounting/config.json                 ← AccountingConfig
-//   data/accounting/books/<id>/accounts.json    ← Account[]
-//   data/accounting/books/<id>/journal/YYYY-MM.jsonl  ← JournalEntry per line
-//   data/accounting/books/<id>/snapshots/YYYY-MM.json ← MonthSnapshot (cache)
-//
-// Snapshots are cache only — journal is the single source of truth.
-
-import type { SupportedCountryCode } from "../../src/plugins/accounting/countries.js";
-import type { FiscalYearEnd } from "../../src/plugins/accounting/fiscalYear.js";
-
-export const ACCOUNT_TYPES = ["asset", "liability", "equity", "income", "expense"] as const;
-export type AccountType = (typeof ACCOUNT_TYPES)[number];
-
-/** B/S accounts (assets / liabilities / equity). Used by opening
- *  balance validation: opening entries reference balance-sheet
- *  accounts only. */
-export const BALANCE_SHEET_ACCOUNT_TYPES: readonly AccountType[] = ["asset", "liability", "equity"];
-
-export interface Account {
-  /** Stable identifier the journal lines reference. Typically a
-   *  numeric string ("1000" / "2000" …) but free-form is allowed
-   *  so the user can adopt their existing numbering. */
-  code: string;
-  name: string;
-  type: AccountType;
-  /** Optional free-form note (tax bucket, parent group, …). Not
-   *  interpreted by the engine — passes through verbatim. */
-  note?: string;
-  /** Soft-delete flag. When `false`, the account is hidden from
-   *  entry/ledger dropdowns but stays visible in Manage Accounts
-   *  and historical entries — accounting integrity requires that
-   *  a code referenced by a journal line never disappears. Omitted
-   *  (treated as active) by default to keep the JSON files clean
-   *  for books created before this field existed. */
-  active?: boolean;
-}
-
-export interface BookSummary {
-  id: string;
-  name: string;
-  /** ISO 4217 (e.g. "USD" / "JPY"). Single-currency per book — no
-   *  cross-book aggregation. */
-  currency: string;
-  /** ISO 3166-1 alpha-2 country code (e.g. "US" / "JP" / "GB").
-   *  Identifies the tax jurisdiction the book is kept under so the
-   *  Accounting role can give country-aware advice (Japanese T-number
-   *  under インボイス制度, EU VAT ID, GSTIN, ABN, etc.). Constrained
-   *  to `SupportedCountryCode` (the curated list shared with the UI
-   *  dropdown and the LLM tool's JSON-schema enum) so a typo from any
-   *  ingress path is rejected at the service layer rather than silently
-   *  persisted. Optional for backward compatibility with books created
-   *  before the field was introduced; the UI prompts existing books
-   *  to set it. */
-  country?: SupportedCountryCode;
-  /** Which calendar-quarter end is the book's fiscal year end:
-   *    Q1 → March 31, Q2 → June 30, Q3 → September 30, Q4 → December 31.
-   *  Drives the UI's "current quarter / current year" date-range
-   *  shortcuts. Optional in the persisted shape for backward
-   *  compatibility with books written before this field existed —
-   *  read-side code treats the absent value as Q4 via
-   *  `resolveFiscalYearEnd`. New books require it at the create
-   *  boundary; the default is Q4. */
-  fiscalYearEnd?: FiscalYearEnd;
-  createdAt: string;
-}
-
-export interface AccountingConfig {
-  books: BookSummary[];
-}
-
-export type JournalEntryKind = "normal" | "opening" | "void" | "void-marker";
-
-export interface JournalLine {
-  accountCode: string;
-  /** Use exactly one of debit / credit per line, both as positive
-   *  numbers. The engine treats them as separate fields rather than
-   *  a single signed amount so the input matches a standard
-   *  bookkeeping form. */
-  debit?: number;
-  credit?: number;
-  /** Per-line memo (the entry-level memo lives on JournalEntry). */
-  memo?: string;
-  /** Counterparty's tax-authority-issued registration ID for this
-   *  line — Japanese 適格請求書発行事業者登録番号 (T-number), EU
-   *  VAT identification number, UK VAT registration number, India
-   *  GSTIN, Australia ABN, etc. Required for input-tax-credit
-   *  eligibility under the Japanese インボイス制度 (effective
-   *  2023-10-01) and equivalent regimes elsewhere. Free-form string;
-   *  format validation belongs upstream (per-jurisdiction). */
-  taxRegistrationId?: string;
-}
-
-export interface JournalEntry {
-  /** Globally unique within a book — ULID-style; ordering by id
-   *  reproduces creation order. */
-  id: string;
-  /** Calendar date the entry is booked for (YYYY-MM-DD). The month
-   *  part decides which `journal/YYYY-MM.jsonl` file the entry lives
-   *  in; entries can be for any past / future date. */
-  date: string;
-  kind: JournalEntryKind;
-  lines: JournalLine[];
-  /** Entry-level memo. */
-  memo?: string;
-  /** When `kind === "void-marker"`: id of the entry being voided.
-   *  When `kind === "void"`: the system-generated reverse entry
-   *  references the original via this field. */
-  voidedEntryId?: string;
-  /** Reason supplied by the user when voiding. */
-  voidReason?: string;
-  /** When this entry was posted via the "edit" flow (void-then-add),
-   *  this is the id of the entry it replaces. The void + new-entry
-   *  pair is *not* atomic on the server — the client issues two
-   *  sequential calls — but recording the link here makes the
-   *  edit chain queryable later (e.g. "what corrected entry X?"). */
-  replacesEntryId?: string;
-  /** ISO timestamp the entry was appended to the journal — the
-   *  authoritative "when did this hit the books" clock. Distinct
-   *  from `date`, which is the user-visible booking date. */
-  createdAt: string;
-}
-
-/** Aggregated balance per account at a point in time. The signed
- *  number is debit − credit; downstream display logic converts to
- *  natural sign per account type (assets debit-positive, liabilities
- *  credit-positive). */
-export interface AccountBalance {
-  accountCode: string;
-  /** Σ debit − Σ credit across all entries up to and including the
-   *  snapshot's period end. */
-  netDebit: number;
-}
-
-export interface MonthSnapshot {
-  /** "YYYY-MM" — the closing month covered. */
-  period: string;
-  /** Closing balances at end of `period`. */
-  balances: AccountBalance[];
-  /** ISO timestamp the snapshot file was written. */
-  builtAt: string;
-}
-
-/** Period selector for reports. Either a single closing month or a
- *  date range. Always inclusive on both ends. */
-export type ReportPeriod = { kind: "month"; period: string } | { kind: "range"; from: string; to: string };

package/server/api/routes/accounting.ts

@@ -1,373 +0,0 @@
-// REST endpoint for the accounting plugin. Single POST dispatch
-// route with an `action` discriminator — matches the todos /
-// scheduler convention so the LLM-facing MCP bridge (which invokes
-// `apiPost` with the tool args verbatim) plugs in without
-// translation.
-//
-// The mounted `<AccountingApp>` View hits this same endpoint
-// directly for tab switches, filter changes, and form submits — no
-// LLM round trip per click. The MCP bridge calls into the same
-// service layer, so manual clicks and Claude tool calls produce
-// identical state changes.
-
-import { Router, Request, Response } from "express";
-
-import {
-  AccountingError,
-  addEntries,
-  createBook,
-  updateBook,
-  deleteBook,
-  getBalanceSheetReport,
-  getLedgerReport,
-  getOpeningBalances,
-  getProfitLossReport,
-  getTimeSeriesReport,
-  listAccounts,
-  listBooks,
-  listEntries,
-  rebuildSnapshots,
-  setOpeningBalances,
-  upsertAccount,
-  voidEntry,
-} from "../../accounting/service.js";
-import type { BookSummary } from "../../accounting/types.js";
-import { ACCOUNTING_ACTIONS } from "../../../src/plugins/accounting/actions.js";
-import { API_ROUTES } from "../../../src/config/apiRoutes.js";
-import { bindRoute } from "../../utils/router.js";
-import { log } from "../../system/logger/index.js";
-import { asyncHandler } from "../../utils/asyncHandler.js";
-
-const router = Router();
-
-interface AccountingActionBody {
-  action: string;
-  [key: string]: unknown;
-}
-
-interface AccountingErrorResponse {
-  error: string;
-  details?: unknown;
-}
-
-// Tool-result envelope for the MCP-driven `openBook` action. The
-// frontend tool-result renderer keys off `kind: "accounting-app"`
-// to mount `<AccountingApp>` (vs the compact `Preview.vue` which
-// renders summaries for every other action). `message` is picked
-// up by the MCP bridge and surfaced as the tool's text response
-// to the LLM (server/agent/mcp-server.ts).
-interface OpenBookToolResult {
-  kind: "accounting-app";
-  bookId: string;
-  initialTab?: string;
-  /** Same shape getBooks returns — included so an LLM that calls
-   *  openBook doesn't need a follow-up getBooks round-trip to learn
-   *  what other books exist before its next action. */
-  books: BookSummary[];
-}
-
-type ActionRest = Omit<AccountingActionBody, "action">;
-type ActionHandler = (rest: ActionRest) => Promise<unknown>;
-
-// Each action is a tiny adapter that pulls the typed slice it needs
-// out of the loosely-typed body. Validation of the slice shape
-// itself lives inside the service layer (validateEntry,
-// validateOpening) so the adapters can stay one-liners.
-
-async function handleOpenBook(rest: ActionRest): Promise<OpenBookToolResult> {
-  // openBook requires an explicit `bookId` that resolves to an
-  // existing book. On a fresh workspace the LLM is expected to
-  // call `createBook` first and then `openBook` with the new id.
-  if (typeof rest.bookId !== "string" || rest.bookId === "") {
-    throw new AccountingError(400, "openBook: bookId is required. Call 'getBooks' to enumerate, or 'createBook' first on a fresh workspace.");
-  }
-  const list = await listBooks();
-  if (!list.books.some((book) => book.id === rest.bookId)) {
-    throw new AccountingError(404, `openBook: book ${JSON.stringify(rest.bookId)} not found`);
-  }
-  const initialTab = typeof rest.initialTab === "string" ? rest.initialTab : undefined;
-  return { kind: "accounting-app", bookId: rest.bookId, initialTab, books: list.books };
-}
-
-async function handleGetReport(rest: ActionRest): Promise<unknown> {
-  const kind = String(rest.kind ?? "");
-  const periodInput = rest.period as { kind: "month"; period: string } | { kind: "range"; from: string; to: string } | undefined;
-  const bookId = rest.bookId as string | undefined;
-  if (kind === "balance") {
-    if (!periodInput) throw new AccountingError(400, "getReport balance: period is required");
-    return getBalanceSheetReport({ bookId, period: periodInput });
-  }
-  if (kind === "pl") {
-    if (!periodInput) throw new AccountingError(400, "getReport pl: period is required");
-    return getProfitLossReport({ bookId, period: periodInput });
-  }
-  if (kind === "ledger") {
-    // period is optional for ledger — full-history view from the
-    // UI calls getLedger(accountCode, undefined, bookId). The
-    // account code, however, is mandatory; without it the request
-    // is meaningless and the service would 404 on a blank code.
-    if (typeof rest.accountCode !== "string" || rest.accountCode === "") {
-      throw new AccountingError(400, "getReport ledger: accountCode is required");
-    }
-    return getLedgerReport({ bookId, accountCode: rest.accountCode, period: periodInput });
-  }
-  throw new AccountingError(400, `getReport: unknown kind ${JSON.stringify(kind)}`);
-}
-
-const ACTION_HANDLERS: Record<string, ActionHandler> = {
-  [ACCOUNTING_ACTIONS.openBook]: handleOpenBook,
-  [ACCOUNTING_ACTIONS.getBooks]: () => listBooks(),
-  [ACCOUNTING_ACTIONS.createBook]: async (rest) => {
-    // Surface bookId at the top level so the dispatch envelope's
-    // `data` carries it like every other write action — the View
-    // uses it to preselect the new book on mount.
-    const result = await createBook({
-      name: String(rest.name ?? ""),
-      currency: typeof rest.currency === "string" ? rest.currency : undefined,
-      country: typeof rest.country === "string" ? rest.country : undefined,
-      fiscalYearEnd: typeof rest.fiscalYearEnd === "string" ? rest.fiscalYearEnd : undefined,
-    });
-    return { bookId: result.book.id, ...result };
-  },
-  [ACCOUNTING_ACTIONS.updateBook]: async (rest) => {
-    const result = await updateBook({
-      bookId: String(rest.bookId ?? ""),
-      name: typeof rest.name === "string" ? rest.name : undefined,
-      country: typeof rest.country === "string" ? rest.country : undefined,
-      fiscalYearEnd: typeof rest.fiscalYearEnd === "string" ? rest.fiscalYearEnd : undefined,
-    });
-    return { bookId: result.book.id, ...result };
-  },
-  [ACCOUNTING_ACTIONS.deleteBook]: (rest) => deleteBook({ bookId: String(rest.bookId ?? ""), confirm: rest.confirm === true }),
-  [ACCOUNTING_ACTIONS.getAccounts]: (rest) => listAccounts({ bookId: rest.bookId as string | undefined }),
-  [ACCOUNTING_ACTIONS.upsertAccount]: (rest) =>
-    upsertAccount({
-      bookId: rest.bookId as string | undefined,
-      // Service validates the shape — route doesn't reach into it.
-      account: rest.account as never,
-    }),
-  [ACCOUNTING_ACTIONS.addEntries]: (rest) =>
-    addEntries({
-      bookId: rest.bookId as string | undefined,
-      // Service validates each entry's shape — route doesn't reach into it.
-      entries: (rest.entries ?? []) as never,
-    }),
-  [ACCOUNTING_ACTIONS.voidEntry]: (rest) =>
-    voidEntry({
-      bookId: rest.bookId as string | undefined,
-      entryId: String(rest.entryId ?? ""),
-      reason: rest.reason as string | undefined,
-      voidDate: rest.voidDate as string | undefined,
-    }),
-  [ACCOUNTING_ACTIONS.getJournalEntries]: (rest) =>
-    listEntries({
-      bookId: rest.bookId as string | undefined,
-      from: rest.from as string | undefined,
-      to: rest.to as string | undefined,
-      accountCode: rest.accountCode as string | undefined,
-    }),
-  [ACCOUNTING_ACTIONS.getOpeningBalances]: (rest) => getOpeningBalances({ bookId: rest.bookId as string | undefined }),
-  [ACCOUNTING_ACTIONS.setOpeningBalances]: (rest) =>
-    setOpeningBalances({
-      bookId: rest.bookId as string | undefined,
-      asOfDate: String(rest.asOfDate ?? ""),
-      lines: (rest.lines ?? []) as never,
-      memo: rest.memo as string | undefined,
-    }),
-  [ACCOUNTING_ACTIONS.getReport]: handleGetReport,
-  [ACCOUNTING_ACTIONS.getTimeSeries]: (rest) =>
-    getTimeSeriesReport({
-      bookId: rest.bookId as string | undefined,
-      metric: rest.metric,
-      granularity: rest.granularity,
-      from: rest.from,
-      to: rest.to,
-      accountCode: rest.accountCode,
-    }),
-  [ACCOUNTING_ACTIONS.rebuildSnapshots]: (rest) => rebuildSnapshots({ bookId: rest.bookId as string | undefined }),
-};
-
-// Actions whose tool-result envelope should carry a `data` field so
-// the sidebar renders a preview card. Everything else returns
-// without `data` and the host gates the preview off (silent action).
-// Reads (lists / reports) and View-driven maintenance ops stay
-// silent — they're invoked from inside the canvas and the LLM will
-// summarise reads in its text reply anyway.
-const PREVIEW_ACTIONS = new Set<string>([
-  ACCOUNTING_ACTIONS.openBook,
-  ACCOUNTING_ACTIONS.createBook,
-  ACCOUNTING_ACTIONS.updateBook,
-  ACCOUNTING_ACTIONS.upsertAccount,
-  ACCOUNTING_ACTIONS.addEntries,
-  ACCOUNTING_ACTIONS.voidEntry,
-  ACCOUNTING_ACTIONS.setOpeningBalances,
-]);
-
-// LLM-facing `message` tacked onto YES actions. The shared trailer
-// ("The accounting view is shown to the user.") tells the LLM that a
-// canvas / sidebar surface is already visible, so its text reply
-// shouldn't redundantly enumerate the result the user can see — it
-// should narrate what was *done*, not re-list what's on screen.
-const VIEW_VISIBLE_TRAILER = "The accounting view is shown to the user.";
-
-type MessageBuilder = (fields: Record<string, unknown>) => string;
-
-const MESSAGE_BUILDERS: Record<string, MessageBuilder> = {
-  [ACCOUNTING_ACTIONS.openBook]: (fields) => {
-    // Include the books list inline so the LLM doesn't need a
-    // follow-up getBooks round-trip before deciding what to do
-    // next.
-    const { books, bookId } = fields;
-    const booksFragment = Array.isArray(books) ? ` Books available: ${JSON.stringify(books)}.` : "";
-    const idFragment = typeof bookId === "string" ? ` (book id: ${bookId})` : "";
-    return `Mounted the accounting app in the canvas${idFragment}.${booksFragment}`;
-  },
-  [ACCOUNTING_ACTIONS.createBook]: (fields) => {
-    const book = fields.book as { id?: string; name?: string } | undefined;
-    const subject = book?.name ? `A new book named ${JSON.stringify(book.name)}` : "A new book";
-    // The LLM needs book.id to call any follow-up action on this
-    // book (getAccounts, addEntries, etc.), so include it in the
-    // status message instead of forcing a round-trip via getBooks.
-    const idFragment = book?.id ? ` (id: ${book.id})` : "";
-    // The View's opening-gate hides every tab except `opening` and
-    // `settings` until an opening entry is on file (even a zero-line
-    // one). If the agent doesn't tell the user to set opening
-    // balances first, the user's "can I add an entry?" attempt
-    // silently fails because the New Entry tab isn't even visible.
-    // Include the next-step instruction inline so the agent's reply
-    // matches the UI's actual constraints.
-    return `${subject} has been created${idFragment}. Next required step: set opening balances via setOpeningBalances — the journal-entry, ledger, and report tabs are locked until an opening (even an empty one) is saved.`;
-  },
-  [ACCOUNTING_ACTIONS.upsertAccount]: (fields) => {
-    const account = fields.account as { code?: string; name?: string } | undefined;
-    if (account?.code && account?.name) {
-      return `Upserted account ${account.code} ${JSON.stringify(account.name)}.`;
-    }
-    return "Updated the chart of accounts.";
-  },
-  [ACCOUNTING_ACTIONS.addEntries]: (fields) => {
-    const entries = Array.isArray(fields.entries) ? (fields.entries as { id?: string; date?: string }[]) : [];
-    if (entries.length === 0) return "Posted 0 journal entries.";
-    if (entries.length === 1) {
-      const [entry] = entries;
-      const idFragment = entry?.id ? ` (id: ${entry.id})` : "";
-      return `Posted a journal entry on ${entry?.date ?? "the requested date"}${idFragment}.`;
-    }
-    // Surface every id so the LLM can later voidEntry any one of
-    // them without a follow-up getJournalEntries round-trip.
-    const summary = entries.map((entry) => `${entry?.date ?? "?"} (id: ${entry?.id ?? "?"})`).join(", ");
-    return `Posted ${entries.length} journal entries: ${summary}.`;
-  },
-  [ACCOUNTING_ACTIONS.voidEntry]: (fields) => {
-    const reverse = fields.reverseEntry as { date?: string } | undefined;
-    return `Voided the entry; a reversing pair was posted on ${reverse?.date ?? "today"}.`;
-  },
-  [ACCOUNTING_ACTIONS.setOpeningBalances]: (fields) => {
-    const opening = fields.openingEntry as { date?: string; lines?: unknown } | undefined;
-    const verb = fields.replacedExisting === true ? "replaced" : "set";
-    const date = opening?.date ?? "the requested date";
-    // Surface the actual lines so the LLM can answer follow-up
-    // questions like "what's my opening cash?" without a separate
-    // getOpeningBalances round-trip. An empty-marker opening
-    // (zero lines, used to unlock the gate) gets no fragment.
-    const lines = Array.isArray(opening?.lines) ? (opening.lines as unknown[]) : [];
-    const linesFragment = lines.length > 0 ? ` Lines: ${JSON.stringify(lines)}.` : "";
-    return `Opening balances were ${verb} as of ${date}.${linesFragment}`;
-  },
-  [ACCOUNTING_ACTIONS.deleteBook]: (fields) => {
-    const bookId = fields.deletedBookId as string | undefined;
-    const name = fields.deletedBookName as string | undefined;
-    const subject = name ? `the book ${JSON.stringify(name)}` : "the book";
-    const idFragment = bookId ? ` (id: ${bookId})` : "";
-    return `Deleted ${subject}${idFragment}.`;
-  },
-  [ACCOUNTING_ACTIONS.updateBook]: (fields) => {
-    const book = fields.book as { id?: string; name?: string; country?: string; currency?: string } | undefined;
-    const name = book?.name ? JSON.stringify(book.name) : "the book";
-    const countryFragment = book?.country ? ` (country: ${book.country})` : "";
-    return `Updated ${name}${countryFragment}.`;
-  },
-};
-
-function previewMessage(action: string, fields: Record<string, unknown>): string {
-  const head = MESSAGE_BUILDERS[action]?.(fields);
-  return head ? `${head} ${VIEW_VISIBLE_TRAILER}` : VIEW_VISIBLE_TRAILER;
-}
-
-async function dispatch(body: AccountingActionBody): Promise<unknown> {
-  const { action, ...rest } = body;
-  const handler = ACTION_HANDLERS[action];
-  if (!handler) throw new AccountingError(400, `unknown action ${JSON.stringify(action)}`);
-  // Stamp the dispatch verb onto the response so the MCP bridge's
-  // spread `{ toolName, uuid, ...result }` surfaces it as
-  // `ToolResult.action`. The sidebar reads this to label cards as
-  // `manageAccounting(openBook)` etc., and it round-trips a refresh
-  // because the result envelope is persisted to the chat log.
-  // Direct browser callers (the AccountingApp view) ignore the field.
-  // Service responses that already set `action` win via the spread.
-  const result = await handler(rest);
-  const handlerFields = result && typeof result === "object" ? (result as Record<string, unknown>) : { value: result };
-  // `data` is the host's preview-eligibility signal (see
-  // SessionSidebar.vue's v-if gate). Mirror the handler payload
-  // into it for the actions that should render a card; leave it
-  // off for silent ones so the gate suppresses the preview.
-  const dataField = PREVIEW_ACTIONS.has(action) ? { data: { action, ...handlerFields } } : {};
-  // The MCP bridge only forwards `message` / `instructions` to the
-  // LLM (`data` / `jsonData` reach the view but not the model). So
-  // every action MUST set a message — silence resolves to "Done"
-  // and gives the LLM nothing to reason about. Resolution order:
-  //   1. handler-set `message` wins (reserved for special-case
-  //      narration that the standard MESSAGE_BUILDER can't capture);
-  //   2. an action with a registered MESSAGE_BUILDER gets the
-  //      per-action human-friendly summary; this is decoupled from
-  //      PREVIEW_ACTIONS so silent ops like deleteBook can still
-  //      narrate without earning a card;
-  //   3. everything else returns the JSON-stringified handler
-  //      payload so the LLM can read the raw data.
-  const handlerMessage = typeof handlerFields.message === "string" ? handlerFields.message : undefined;
-  const messageField = handlerMessage
-    ? {}
-    : MESSAGE_BUILDERS[action]
-      ? { message: previewMessage(action, handlerFields) }
-      : { message: JSON.stringify(handlerFields) };
-  return { action, ...handlerFields, ...messageField, ...dataField };
-}
-
-bindRoute(
-  router,
-  API_ROUTES.accounting.dispatch,
-  asyncHandler<Request<object, unknown, AccountingActionBody>, Response<unknown | AccountingErrorResponse>>(
-    "accounting",
-    "accounting dispatch failed",
-    async (req, res) => {
-      // Validate the body shape up front so a missing / non-object body
-      // surfaces as a 400 instead of crashing `dispatch` and bubbling
-      // through to the 500 catch-all.
-      const { body } = req;
-      if (!body || typeof body !== "object" || typeof body.action !== "string") {
-        log.warn("accounting", "POST dispatch: invalid body");
-        res.status(400).json({ error: "request body must be an object with a string `action` field" });
-        return;
-      }
-      const { action } = body;
-      log.info("accounting", "POST dispatch: start", { action });
-      try {
-        const result = await dispatch(body);
-        log.info("accounting", "POST dispatch: ok", { action });
-        res.json(result);
-      } catch (err) {
-        // Domain errors (AccountingError) map to 4xx with `details`.
-        // Anything else rethrows — the asyncHandler wrapper catches
-        // it, logs `unexpected error`, and returns a generic 500.
-        if (err instanceof AccountingError) {
-          log.warn("accounting", "POST dispatch: error", { action, status: err.status, message: err.message });
-          res.status(err.status).json({ error: err.message, details: err.details });
-          return;
-        }
-        throw err;
-      }
-    },
-  ),
-);
-
-export default router;

package/server/api/routes/wiki/frontmatter.ts

@@ -1,34 +0,0 @@
-// Narrow `tags:` field reader for wiki page files. Built on the
-// shared `parseFrontmatter` util (#895 PR C) — js-yaml handles
-// both flow style (`tags: [a, b, c]`) and block-list style:
-//
-//   tags:
-//     - a
-//     - b
-//
-// out of the box, so we just normalise the resulting strings.
-//
-// Anything unparseable returns `[]` — callers use this for a
-// best-effort comparison against index.md, so a noisy file should
-// degrade silently, not throw.
-
-import { parseFrontmatter } from "../../../utils/markdown/frontmatter.js";
-
-function cleanTagToken(token: string): string {
-  return token
-    .trim()
-    .replace(/^['"]|['"]$/g, "")
-    .replace(/^#/, "")
-    .toLowerCase();
-}
-
-export function parseFrontmatterTags(content: string): string[] {
-  const parsed = parseFrontmatter(content);
-  if (!parsed.hasHeader) return [];
-  const tagsValue = parsed.meta.tags;
-  if (!Array.isArray(tagsValue)) return [];
-  return tagsValue
-    .filter((item): item is string => typeof item === "string")
-    .map(cleanTagToken)
-    .filter((token) => token.length > 0);
-}

package/server/api/routes/wiki/pageIndex.ts

@@ -1,53 +0,0 @@
-// In-memory index of `wiki/pages/*.md` keyed by slug (= filename
-// without the `.md` extension). Kept fresh via `pagesDir` mtime —
-// adding, removing, or renaming a file under `pagesDir` advances
-// the directory's mtime on every major filesystem we target
-// (macOS APFS, Linux ext4, Windows NTFS), so one cheap `stat()`
-// per request is enough to decide whether to rebuild.
-//
-// Eliminates the sync `readdirSync` + linear `find()` in the old
-// `resolvePagePath` — see #201.
-
-import { readDirSafeAsync, statSafeAsync } from "../../../utils/files/safe.js";
-
-export interface PageIndex {
-  mtimeMs: number;
-  /** slug → filename (e.g. "sakura-internet" → "sakura-internet.md"). */
-  slugs: Map<string, string>;
-}
-
-let cache: PageIndex | null = null;
-
-/**
- * Get the page index for `pagesDir`. Returns a cached value as long
- * as the directory's mtime hasn't advanced; otherwise rebuilds.
- *
- * Safe to call concurrently — racing builds produce the same result.
- */
-export async function getPageIndex(pagesDir: string): Promise<PageIndex> {
-  const stat = await statSafeAsync(pagesDir);
-  if (!stat) {
-    // Dir doesn't exist yet (never ingested). Return empty but
-    // don't cache a stale-forever value — the next call will
-    // re-stat and pick up the dir once it lands.
-    return { mtimeMs: 0, slugs: new Map() };
-  }
-  if (cache && cache.mtimeMs >= stat.mtimeMs) {
-    return cache;
-  }
-  const entries = await readDirSafeAsync(pagesDir);
-  const slugs = new Map<string, string>();
-  for (const entry of entries) {
-    if (!entry.isFile()) continue;
-    const { name } = entry;
-    if (!name.endsWith(".md")) continue;
-    slugs.set(name.slice(0, -".md".length), name);
-  }
-  cache = { mtimeMs: stat.mtimeMs, slugs };
-  return cache;
-}
-
-/** Test-only: drop the module-level cache. */
-export function __resetPageIndexCache(): void {
-  cache = null;
-}