@rubytech/create-siteoffice-code 0.1.256

package/payload/premium-plugins/writer-craft/mcp/src/tools/voice-ingest-session-text.ts

@@ -0,0 +1,152 @@
+/**
+ * voice-ingest-session-text — write operator turns the agent read from its
+ * own session context as :Message {format:'text', source:'admin-pty'} corpus
+ * nodes.
+ *
+ * Invoked on demand by the voice-mirror skill (Task 644): the operator asks to
+ * capture this session's voice, the admin agent extracts its own operator
+ * turns from the live conversation context, and passes them here as `turns`.
+ * Re-running with the same turns is a no-op — MERGE on (contentHash, accountId)
+ * is the deduplication primitive.
+ *
+ * After ingest, triggers voice-distil-profile {format:'text'} so the cadence
+ * guard decides whether distillation runs.
+ *
+ * "Real operator text" filter (each supplied turn is excluded when):
+ *   - text is empty after trimming                      → nothing to ingest
+ *   - text starts with "/"                              → slash command
+ *   - text contains "<system-reminder>"                 → harness injection
+ *   - text.length >= 4096                              → likely pasted content
+ */
+import { createHash } from "node:crypto";
+import { getSession } from "../lib/neo4j.js";
+import { voiceDistilProfile } from "./voice-distil-profile.js";
+
+export interface VoiceIngestSessionTextParams {
+  turns: string[];
+  accountId: string;
+  userId: string;
+  sessionId?: string;
+}
+
+export interface VoiceIngestSessionTextResult {
+  ingestedCount: number;
+  skippedCount: number;
+  sessionId: string | null;
+}
+
+/**
+ * Applies the "real operator text" exclusions to a single supplied turn.
+ * Returns the trimmed text to ingest, or null when the turn should be skipped.
+ * Exported for testability (no DB required).
+ */
+export function filterOperatorText(text: unknown): string | null {
+  if (typeof text !== "string") return null;
+  const trimmed = text.trim();
+  if (trimmed.length === 0) return null;
+  if (trimmed.startsWith("/")) return null; // slash command
+  if (trimmed.includes("<system-reminder>")) return null; // harness injection
+  if (trimmed.length >= 4096) return null; // paste block
+  return trimmed;
+}
+
+export async function voiceIngestSessionText(
+  params: VoiceIngestSessionTextParams,
+): Promise<VoiceIngestSessionTextResult> {
+  const { turns, accountId, userId, sessionId = null } = params;
+
+  if (!accountId || !userId) {
+    throw new Error("voice-ingest-session-text: accountId and userId required");
+  }
+  if (!Array.isArray(turns)) {
+    throw new Error("voice-ingest-session-text: turns array required");
+  }
+
+  // 1. Apply the operator-text filter to each supplied turn.
+  const allTurns: string[] = [];
+  for (const turn of turns) {
+    const text = filterOperatorText(turn);
+    if (text !== null) allTurns.push(text);
+  }
+
+  if (allTurns.length === 0) {
+    process.stderr.write(
+      `[voice-ingest-session-text] sessionId=${sessionId ?? "unknown"} adminUser=${userId} turns=0 bytes=0\n`,
+    );
+    return { ingestedCount: 0, skippedCount: 0, sessionId };
+  }
+
+  // 2. Write each turn as a :Message node. MERGE on contentHash+accountId dedupes.
+  const session = getSession();
+  const now = new Date().toISOString();
+  let ingestedCount = 0;
+  let skippedCount = 0;
+  let totalBytes = 0;
+
+  try {
+    for (const body of allTurns) {
+      const contentHash = createHash("sha256")
+        .update(body, "utf-8")
+        .digest("hex");
+
+      const result = await session.run(
+        `MATCH (a:AdminUser {accountId: $accountId, userId: $userId})
+         MERGE (n:Message {contentHash: $contentHash, accountId: $accountId})
+         ON CREATE SET
+           n.userId = $userId,
+           n.body = $body,
+           n.occurredAt = $now,
+           n.sessionId = $sessionId,
+           n.source = 'admin-pty',
+           n.authorshipMode = 'human-only',
+           n.format = 'text',
+           n.createdAt = $now
+         MERGE (a)-[:AUTHORED]->(n)
+         RETURN n.createdAt = $now AS isNew`,
+        {
+          accountId,
+          userId,
+          contentHash,
+          body,
+          now,
+          sessionId,
+        },
+      );
+
+      if (result.records.length === 0) {
+        // :AdminUser not found — abort rather than orphan nodes.
+        throw new Error(
+          `voice-ingest-session-text: :AdminUser {accountId='${accountId}', userId='${userId}'} not found. Onboarding must promote the operator to :AdminUser before ingest.`,
+        );
+      }
+
+      const isNew = result.records[0].get("isNew") === true;
+      if (isNew) {
+        ingestedCount++;
+        totalBytes += body.length;
+      } else {
+        skippedCount++;
+      }
+    }
+  } finally {
+    await session.close();
+  }
+
+  process.stderr.write(
+    `[voice-ingest-session-text] sessionId=${sessionId ?? "unknown"} adminUser=${userId} turns=${ingestedCount} bytes=${totalBytes} skipped=${skippedCount}\n`,
+  );
+
+  // 3. Trigger text-format distillation (cadence guard decides whether to run).
+  if (ingestedCount > 0) {
+    try {
+      await voiceDistilProfile({ accountId, userId, format: "text" });
+    } catch (err) {
+      // Distil failure must not fail the ingest.
+      process.stderr.write(
+        `[voice-ingest-session-text] distil-after-ingest error: ${err instanceof Error ? err.message : String(err)}\n`,
+      );
+    }
+  }
+
+  return { ingestedCount, skippedCount, sessionId };
+}

package/payload/premium-plugins/writer-craft/mcp/src/tools/voice-record-feedback.ts

@@ -0,0 +1,128 @@
+/**
+ * voice-record-feedback — capture an operator's edit on an agent draft
+ * as feedback for the next distillation.
+ *
+ * Task 424: the Haiku diff-intent summarisation moved into the calling
+ * agent's turn. The agent compares `originalText` to `editedText` itself
+ * and passes the resulting `intent` string as a required parameter. The
+ * tool now does the graph writes only.
+ *
+ * Task 462: `format` is required. `:VoiceEdit` carries the format; the
+ * `FEEDBACK_FOR` edge targets the per-format `:VoiceProfile`.
+ *
+ * Side effects:
+ *   1. Write `(:VoiceEdit)-[:FEEDBACK_FOR]->(:VoiceProfile {format})` if the
+ *      per-format profile exists; otherwise write the :VoiceEdit alone so the
+ *      next distillation back-fills the edge.
+ */
+import { randomUUID } from "node:crypto";
+import { getSession } from "../lib/neo4j.js";
+import type { VoiceFormat } from "../lib/voice-corpus.js";
+
+export interface VoiceRecordFeedbackParams {
+  accountId: string;
+  userId: string;
+  originalText: string;
+  editedText: string;
+  /**
+   * Writing format of the draft being edited. Routes feedback to the
+   * matching per-format :VoiceProfile.
+   */
+  format: VoiceFormat;
+  /**
+   * One sentence describing what changed and what voice preference it reveals.
+   * The calling agent summarises this from `originalText` vs `editedText` in
+   * its own turn before invoking the tool (Task 424). Examples: "shorter and
+   * dropped the apology", "switched to first person", "removed corporate
+   * sign-off", "added a specific date".
+   */
+  intent: string;
+  context?: {
+    skill?: string;
+    brief?: string;
+  };
+}
+
+export interface VoiceRecordFeedbackResult {
+  editId: string;
+  intent: string;
+  occurredAt: string;
+  hadProfile: boolean;
+}
+
+export async function voiceRecordFeedback(
+  params: VoiceRecordFeedbackParams,
+): Promise<VoiceRecordFeedbackResult> {
+  const { accountId, userId, originalText, editedText, format, intent: rawIntent, context } = params;
+  if (!accountId || !userId) {
+    throw new Error("voice-record-feedback: accountId and userId required");
+  }
+  if (!originalText || !editedText) {
+    throw new Error("voice-record-feedback: originalText and editedText required");
+  }
+  if (!format) {
+    throw new Error("voice-record-feedback: format is required");
+  }
+  const intent = (rawIntent ?? "").trim();
+  if (!intent) {
+    throw new Error(
+      "voice-record-feedback: intent is required — summarise what the operator changed in-turn before calling this tool (Task 424).",
+    );
+  }
+
+  const editId = randomUUID();
+  const occurredAt = new Date().toISOString();
+  const cappedIntent = intent.slice(0, 500);
+
+  const session = getSession();
+  try {
+    const result = await session.run(
+      `MATCH (a:AdminUser {accountId: $accountId, userId: $userId})
+       CREATE (e:VoiceEdit {
+         editId: $editId,
+         accountId: $accountId,
+         userId: $userId,
+         format: $format,
+         originalText: $originalText,
+         editedText: $editedText,
+         intent: $intent,
+         occurredAt: $occurredAt,
+         skill: $skill,
+         brief: $brief
+       })
+       CREATE (a)-[:AUTHORED]->(e)
+       WITH e
+       OPTIONAL MATCH (:AdminUser {accountId: $accountId, userId: $userId})-[:HAS_VOICE_PROFILE]->(p:VoiceProfile {accountId: $accountId, userId: $userId, format: $format})
+       FOREACH (_ IN CASE WHEN p IS NULL THEN [] ELSE [1] END |
+         MERGE (e)-[:FEEDBACK_FOR]->(p)
+       )
+       RETURN elementId(e) AS editId, (p IS NOT NULL) AS hadProfile`,
+      {
+        accountId,
+        userId,
+        format,
+        editId,
+        originalText,
+        editedText,
+        intent: cappedIntent,
+        occurredAt,
+        skill: context?.skill ?? null,
+        brief: context?.brief ?? null,
+      },
+    );
+    if (result.records.length === 0) {
+      throw new Error(
+        `voice-mirror: :AdminUser {accountId='${accountId}', userId='${userId}'} not found. Onboarding must promote the operator to :AdminUser before feedback can be recorded.`,
+      );
+    }
+    const hadProfile = result.records[0].get("hadProfile") === true;
+
+    process.stderr.write(
+      `[voice-record-feedback] adminUser=${userId} format=${format} intent="${cappedIntent.replace(/"/g, "'")}" diffBytes=${editedText.length - originalText.length}\n`,
+    );
+
+    return { editId, intent: cappedIntent, occurredAt, hadProfile };
+  } finally {
+    await session.close();
+  }
+}

package/payload/premium-plugins/writer-craft/mcp/src/tools/voice-retrieve-conditioning.ts

@@ -0,0 +1,234 @@
+/**
+ * voice-retrieve-conditioning — return the operator's style card plus K
+ * voice-matched exemplars for a drafting brief.
+ *
+ * Task 462 changes:
+ *   - `brief.format` (K-selector: 'short'|'long') renamed to `brief.length`
+ *     to free the name for the new `brief.format: VoiceFormat` axis.
+ *   - `brief.format: VoiceFormat` (required) — corpus exemplars are filtered
+ *     to this writing format; the `:VoiceProfile` is the per-format profile.
+ *   - All callers updated in the same commit.
+ *
+ * Retrieval order (best to worst):
+ *   1. If brief.topic is provided AND keyword search on the per-format corpus
+ *      returns ≥K matches → use those (ordered by recency).
+ *   2. Otherwise, return the K most-recent per-format corpus nodes.
+ *
+ * Embeddings are not used in v1: the corpus is small (single operator's
+ * personal writing — typically <500 docs), and recency-with-keyword-filter
+ * is both faster and more predictable than vector ANN at that scale.
+ * Vector-search is a Task 365-follow-up if the corpus grows beyond the
+ * 500-doc breakeven point.
+ *
+ * Graceful degradation, discriminated (Task 493): the function never throws.
+ * Missing profile / empty corpus returns status "no-data"; a failed lookup
+ * (blank identity, driver/connection fault, Cypher error) returns status
+ * "error" with the message. The calling drafting skill falls back to its
+ * default register on both, but only "no-data" means "you have no profile".
+ */
+import neo4j, { type Session } from "neo4j-driver";
+import { getSession } from "../lib/neo4j.js";
+import { notTrashed } from "../lib/voice-corpus.js";
+import {
+  VOICE_CORPUS_WHERE,
+  voiceCorpusWhereWithFormat,
+  type VoiceFormat,
+} from "../lib/voice-corpus.js";
+
+const DEFAULT_TOKEN_BUDGET_SHORT = 16_000;
+const DEFAULT_TOKEN_BUDGET_LONG = 96_000;
+const CHARS_PER_TOKEN = 4;
+
+export interface VoiceRetrieveConditioningParams {
+  accountId: string;
+  userId: string;
+  brief: {
+    topic?: string;
+    /**
+     * Writing format for corpus and profile scoping (required, Task 462).
+     * One :VoiceProfile per (accountId, userId, format).
+     */
+    format: VoiceFormat;
+    /**
+     * K-selector: 'short' = K=5 (16k token budget, email/post);
+     *             'long'  = K=15 (96k token budget, brochure/prospectus).
+     * Renamed from `format` in Task 462 to free the name for VoiceFormat.
+     */
+    length?: "short" | "long";
+    register?: string;
+  };
+  tokenBudget?: number;
+}
+
+export interface VoiceExemplar {
+  nodeId: string;
+  label: string;
+  body: string;
+  source: string;
+}
+
+/**
+ * Outcome discriminator (Task 493). Three mutually-exclusive states so the
+ * drafting agent and operator can tell genuine no-data apart from a failed
+ * lookup — both previously collapsed into the same empty payload:
+ *   - "ok"      — query ran; a style card and/or exemplars were returned.
+ *   - "no-data" — query ran; no profile exists and the corpus is empty.
+ *   - "error"   — the lookup failed (blank identity, driver/connection
+ *                 fault, or Cypher error). `error` carries the message.
+ * Drafting degrades gracefully to default register on both "no-data" and
+ * "error"; the caller must only report "no profile exists" on "no-data".
+ */
+export type VoiceRetrieveStatus = "ok" | "no-data" | "error";
+
+export interface VoiceRetrieveConditioningResult {
+  styleCard: string | null;
+  exemplars: VoiceExemplar[];
+  status: VoiceRetrieveStatus;
+  error?: string;
+}
+
+function errorResult(error: string): VoiceRetrieveConditioningResult {
+  return { styleCard: null, exemplars: [], status: "error", error };
+}
+
+export async function voiceRetrieveConditioning(
+  params: VoiceRetrieveConditioningParams,
+): Promise<VoiceRetrieveConditioningResult> {
+  const { accountId, userId, brief } = params;
+  // Blank identity is an error, never genuine no-data — index.ts guards both
+  // accountId and userId before calling, so a blank value reaching here is a
+  // precondition failure, not "you have no profile". Emit a line so this path
+  // is no longer silent (Task 493 — closes the 06:46 path-1 ambiguity).
+  if (!accountId || !userId) {
+    process.stderr.write(
+      `[voice-retrieve] error: missing-identity accountId=${Boolean(accountId)} userId=${Boolean(userId)}\n`,
+    );
+    return errorResult("missing accountId/userId");
+  }
+
+  const length = brief.length ?? "short";
+  const k = length === "long" ? 15 : 5;
+  const tokenBudget =
+    params.tokenBudget ??
+    (length === "long" ? DEFAULT_TOKEN_BUDGET_LONG : DEFAULT_TOKEN_BUDGET_SHORT);
+  const charBudget = tokenBudget * CHARS_PER_TOKEN;
+  const format = brief.format;
+  const corpusWhere = voiceCorpusWhereWithFormat(format);
+
+  // getSession() is inside the try so driver-construction / connection-config
+  // faults (NEO4J_URI unset, password file missing) are caught, logged, and
+  // returned as the error state rather than escaping the function silently
+  // (Task 493).
+  let session: Session | undefined;
+  try {
+    session = getSession();
+    // 1. Style card — per-format profile.
+    const profile = await session.run(
+      `MATCH (a:AdminUser {accountId: $accountId, userId: $userId})
+       OPTIONAL MATCH (a)-[:HAS_VOICE_PROFILE]->(p:VoiceProfile {accountId: $accountId, userId: $userId, format: $format})
+       RETURN p.styleCard AS styleCard`,
+      { accountId, userId, format },
+    );
+    const styleCard = (profile.records[0]?.get("styleCard") as string | null) ?? null;
+
+    // 2. Exemplars — filtered to brief.format. Keyword-aware when topic is set.
+    //
+    // Body resolution (Task 471):
+    //   - For :KnowledgeDocument with HAS_SECTION children, concatenate
+    //     child :Section bodies in `position` order. KD.body is null after
+    //     Task 465 server-slicing.
+    //   - Other labels read n.body directly via the COALESCE fallback chain.
+    //
+    // The topic filter runs against the computed body, so a topic that
+    // appears only in n.summary (LLM abstract) no longer matches — by
+    // design: the corpus surfaces verbatim prose, not the abstract.
+    const topic = (brief.topic ?? "").trim();
+    const usesTopic = topic.length > 0;
+
+    const bodyComputeBlock = `WITH n, coalesce(n.dateSent, n.datePublished, n.firstMessageAt, n.dateCreated, n.createdAt) AS ts
+         OPTIONAL MATCH (n)-[:HAS_SECTION]->(s:Section)
+         WHERE ${notTrashed("s")}
+         WITH n, ts, s ORDER BY s.position
+         WITH n, ts, collect(s.body) AS sectionBodies
+         WITH n, ts, CASE
+           WHEN 'KnowledgeDocument' IN labels(n) AND size(sectionBodies) > 0
+             THEN reduce(acc = '', b IN sectionBodies | acc + b + '\n\n')
+           ELSE coalesce(n.body, n.abstract, n.subject, n.title, n.summary, '')
+         END AS body`;
+
+    const cypher = usesTopic
+      ? `MATCH (n)
+         WHERE ${corpusWhere}
+         ${bodyComputeBlock}
+         WHERE toLower(body) CONTAINS toLower($topic)
+         RETURN elementId(n) AS id,
+                labels(n) AS labels,
+                body,
+                coalesce(n.subject, n.title, n.name, '') AS source,
+                ts
+         ORDER BY ts IS NULL, ts DESC
+         LIMIT $k`
+      : `MATCH (n)
+         WHERE ${corpusWhere}
+         ${bodyComputeBlock}
+         RETURN elementId(n) AS id,
+                labels(n) AS labels,
+                body,
+                coalesce(n.subject, n.title, n.name, '') AS source,
+                ts
+         ORDER BY ts IS NULL, ts DESC
+         LIMIT $k`;
+
+    const result = await session.run(cypher, {
+      accountId,
+      format,
+      topic,
+      // neo4j-driver serializes a plain JS number as a Cypher float (15 → 15.0),
+      // which LIMIT rejects ("not a valid value. Must be a non-negative integer").
+      // Send it as a Neo4j integer.
+      k: neo4j.int(k),
+    });
+
+    let charsUsed = 0;
+    const exemplars: VoiceExemplar[] = [];
+    for (const r of result.records) {
+      const body = (r.get("body") as string | null) ?? "";
+      if (body.length === 0) continue;
+      const labels = (r.get("labels") as string[]) ?? [];
+      const label =
+        labels.find((l) =>
+          ["KnowledgeDocument", "Message", "SocialPost", "Conversation"].includes(l),
+        ) ?? labels[0] ?? "Unknown";
+      const remaining = charBudget - charsUsed;
+      if (remaining <= 0) break;
+      const truncated = body.length > remaining ? body.slice(0, remaining) : body;
+      exemplars.push({
+        nodeId: r.get("id") as string,
+        label,
+        body: truncated,
+        source: ((r.get("source") as string | null) ?? "").slice(0, 200),
+      });
+      charsUsed += truncated.length;
+    }
+
+    process.stderr.write(
+      `[voice-retrieve] task=${brief.topic ?? length} format=${format} styleCardBytes=${
+        styleCard?.length ?? 0
+      } exemplarCount=${exemplars.length} tokenBudget=${tokenBudget}\n`,
+    );
+
+    // An empty-string styleCard with no exemplars is no-data, not ok — a blank
+    // card conditions nothing, so reporting "ok" would be the same lie this
+    // discriminator exists to prevent (Task 493).
+    const hasStyleCard = styleCard !== null && styleCard.length > 0;
+    const status: VoiceRetrieveStatus =
+      hasStyleCard || exemplars.length > 0 ? "ok" : "no-data";
+    return { styleCard, exemplars, status };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[voice-retrieve] error: ${message}\n`);
+    return errorResult(message);
+  } finally {
+    if (session) await session.close();
+  }
+}

package/payload/premium-plugins/writer-craft/mcp/src/tools/voice-tag-content.ts

@@ -0,0 +1,139 @@
+/**
+ * voice-tag-content — set `authorshipMode` and `format` on one or many
+ * content nodes.
+ *
+ * The tool routes through neo4j directly with an account-scoped MERGE so
+ * the operator can only mutate their own nodes. We do not go through
+ * `memory-update` because that tool re-embeds and re-validates on every
+ * call — overkill for a single-property authorship stamp.
+ *
+ * `format` is an editorial classification only the operator can set; it is
+ * therefore required. The sole hard-coded exception lives in
+ * `voice-ingest-session-text`, which stamps `format='text'` on auto-ingested
+ * `:Message` rows where the operator is not in the loop (Task 471).
+ */
+import { getSession } from "../lib/neo4j.js";
+import {
+  TAGGABLE_PRIMARY_LABELS,
+  FORMAT_VALUES,
+  type VoiceFormat,
+} from "../lib/voice-corpus.js";
+
+export type AuthorshipMode =
+  | "human-only"
+  | "human-led-agent-assisted"
+  | "agent-led-human-reviewed"
+  | "agent-only"
+  | "unknown";
+
+export const AUTHORSHIP_MODES: ReadonlySet<AuthorshipMode> = new Set([
+  "human-only",
+  "human-led-agent-assisted",
+  "agent-led-human-reviewed",
+  "agent-only",
+  "unknown",
+]);
+
+export interface VoiceTagContentParams {
+  nodeIds: string[];
+  mode: AuthorshipMode;
+  accountId: string;
+  /** Writing format (required). Editorial classification — operator-supplied. */
+  format: VoiceFormat;
+}
+
+export interface VoiceTagContentResult {
+  updated: number;
+  skipped: number;
+  skippedReasons: Record<string, number>;
+}
+
+export async function voiceTagContent(
+  params: VoiceTagContentParams,
+): Promise<VoiceTagContentResult> {
+  const { nodeIds, mode, accountId, format } = params;
+
+  if (!AUTHORSHIP_MODES.has(mode)) {
+    throw new Error(
+      `voice-tag-content: invalid authorshipMode '${mode}'. Valid values: ${[
+        ...AUTHORSHIP_MODES,
+      ].join(", ")}`,
+    );
+  }
+  if (!accountId) {
+    throw new Error("voice-tag-content: accountId is required");
+  }
+  if (format === undefined || format === null) {
+    throw new Error("voice-tag-content: format is required");
+  }
+  if (!(FORMAT_VALUES as readonly string[]).includes(format)) {
+    throw new Error(
+      `voice-tag-content: invalid format '${format}'. Valid values: ${FORMAT_VALUES.join(", ")}`,
+    );
+  }
+  if (!Array.isArray(nodeIds) || nodeIds.length === 0) {
+    return { updated: 0, skipped: 0, skippedReasons: {} };
+  }
+
+  const session = getSession();
+  const now = new Date().toISOString();
+  const skippedReasons: Record<string, number> = {};
+  let updated = 0;
+
+  try {
+    // Bulk update in batches of 50 to keep transaction latency bounded.
+    const BATCH = 50;
+    for (let i = 0; i < nodeIds.length; i += BATCH) {
+      const batch = nodeIds.slice(i, i + BATCH);
+      const result = await session.run(
+        // Tag any of the three primary content labels, or a conversation-
+        // document :Section chunk (parent :KnowledgeDocument carries
+        // `conversationIdentity`). The EXISTS sub-pattern guards against
+        // accidentally tagging document-path :Section rows AND parent
+        // `:Conversation` / `:AdminConversation` nodes (which are not
+        // body-bearing content).
+        `UNWIND $ids AS id
+         MATCH (n) WHERE elementId(n) = id AND n.accountId = $accountId
+         WITH n
+         WHERE any(lbl IN labels(n) WHERE lbl IN $primaryLabels)
+            OR ('Section' IN labels(n) AND EXISTS {
+                 MATCH (parent:KnowledgeDocument)-[:HAS_SECTION]->(n)
+                 WHERE parent.conversationIdentity IS NOT NULL
+               })
+         SET n.authorshipMode = $mode,
+             n.authorshipTaggedAt = $now,
+             n.format = $format
+         RETURN elementId(n) AS id`,
+        {
+          ids: batch,
+          accountId,
+          mode,
+          now,
+          format,
+          primaryLabels: [...TAGGABLE_PRIMARY_LABELS],
+        },
+      );
+      const matched = new Set(result.records.map((r) => r.get("id") as string));
+      updated += matched.size;
+      for (const id of batch) {
+        if (matched.has(id)) continue;
+        const reason = "not-found-or-not-content-label";
+        skippedReasons[reason] = (skippedReasons[reason] ?? 0) + 1;
+      }
+    }
+  } finally {
+    await session.close();
+  }
+
+  process.stderr.write(
+    `[voice-tag] mode=${mode} format=${format} accountId=${accountId} updated=${updated} skipped=${
+      nodeIds.length - updated
+    }\n`,
+  );
+
+  return {
+    updated,
+    skipped: nodeIds.length - updated,
+    skippedReasons,
+  };
+}

package/payload/premium-plugins/writer-craft/mcp/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../../platform/tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src"]
+}