@rubytech/create-maxy-code 0.1.174 → 0.1.177

package/payload/premium-plugins/writer-craft/mcp/src/tools/voice-distil-profile.ts

@@ -2,21 +2,35 @@
  * voice-distil-profile — walk the operator's `human-only` corpus and
  * persist a `:VoiceProfile` style card.
  *
+ * Task 462: one `:VoiceProfile` per `(accountId, userId, format)`.
+ * `format` ∈ `{text, email, social-post, article, marketing-copy, note}`.
+ *
+ *   - When `format` is supplied, distils that format only.
+ *   - When `format` is omitted, enumerates distinct format values present
+ *     in the corpus (nodes where `n.format IS NOT NULL`) and distils each
+ *     that fires the cadence guard. Returns `skipReason: 'no-format-tagged-content'`
+ *     when enumeration yields zero formats.
+ *
  * Cadence guard: re-runs on ≥20% corpus growth since last profile, OR
  * ≥30 days since `generatedAt`. `force: true` overrides both.
  *
  * Body-text sampling caps at ~120k chars (rough proxy for tokens at
  * 4 chars/token = 30k tokens) — well inside Haiku's 200k context window
  * with headroom for the system prompt + tool schema.
+ *
+ * Task 424 — the Haiku style-card composition moved into the calling agent's
+ * turn. The agent reads the corpus exemplars and feedback intents (this tool
+ * returns them when called with `mode='sample'`), composes the style-card
+ * YAML, then calls this tool again with `mode='write'` + `styleCardYaml` set.
  */
 import neo4j from "neo4j-driver";
 import { getSession } from "../lib/neo4j.js";
-import { VOICE_CORPUS_WHERE } from "../lib/voice-corpus.js";
-
-// Task 424 — the Haiku style-card composition moved into the calling agent's
-// turn. The agent reads the corpus exemplars and feedback intents (this tool
-// returns them when called with `mode='sample'`), composes the style-card YAML,
-// then calls this tool again with `mode='write'` + `styleCardYaml` set.
+import {
+  VOICE_CORPUS_WHERE,
+  voiceCorpusWhereWithFormat,
+  FORMAT_VALUES,
+  type VoiceFormat,
+} from "../lib/voice-corpus.js";
 
 /**
  * Coerce a neo4j cypher RETURN value to a plain JS number.
@@ -46,6 +60,11 @@ export interface VoiceDistilProfileParams {
   accountId: string;
   userId: string;
   force?: boolean;
+  /**
+   * Writing format to distil. When omitted, enumerates distinct format
+   * values in the corpus and distils each that fires the cadence guard.
+   */
+  format?: VoiceFormat;
   /**
    * Operation mode (Task 424):
    *   - `'sample'` (default) — read the corpus + feedback intents and return
@@ -71,7 +90,12 @@ export interface VoiceDistilProfileResult {
   generatedAt: string | null;
   feedbackEntries: number;
   skipped: boolean;
-  skipReason?: "below-threshold" | "recent" | "empty-corpus" | "missing-style-card";
+  skipReason?:
+    | "below-threshold"
+    | "recent"
+    | "empty-corpus"
+    | "missing-style-card"
+    | "no-format-tagged-content";
   errorReason?: string;
   /** Present when `mode='sample'`: corpus exemplars for the agent to read. */
   exemplars?: VoiceCorpusExemplar[];
@@ -84,46 +108,47 @@ export interface VoiceDistilProfileResult {
 //   openingPattern, closingPattern, exemplarSentences
 // Exemplar sentences should be quoted verbatim from the returned corpus.
 
-export async function voiceDistilProfile(
-  params: VoiceDistilProfileParams,
+/**
+ * Single-format distil. Opens a new session for each call.
+ */
+async function distilForFormat(
+  params: Required<Pick<VoiceDistilProfileParams, "accountId" | "userId">> &
+    Pick<VoiceDistilProfileParams, "force" | "mode" | "styleCardYaml"> & {
+      format: VoiceFormat;
+    },
 ): Promise<VoiceDistilProfileResult> {
-  const { accountId, userId, force = false } = params;
-  if (!accountId || !userId) {
-    throw new Error("voice-distil-profile: accountId and userId required");
-  }
+  const { accountId, userId, format, force = false } = params;
   const session = getSession();
   const now = new Date();
   const nowIso = now.toISOString();
 
   try {
-    // 1. Read existing profile (if any) for cadence-guard comparison.
+    // 1. Read existing per-format profile (if any) for cadence-guard comparison.
     const existing = await session.run(
       `MATCH (a:AdminUser {accountId: $accountId, userId: $userId})
-       OPTIONAL MATCH (a)-[:HAS_VOICE_PROFILE]->(p:VoiceProfile)
+       OPTIONAL MATCH (a)-[:HAS_VOICE_PROFILE]->(p:VoiceProfile {accountId: $accountId, userId: $userId, format: $format})
        RETURN elementId(p) AS profileId, p.corpusSize AS corpusSize,
               p.generatedAt AS generatedAt`,
-      { accountId, userId },
+      { accountId, userId, format },
     );
     const existingRow = existing.records[0];
     const prevProfileId = (existingRow?.get("profileId") as string | null) ?? null;
     const prevCorpusSize = toJsNumber(existingRow?.get("corpusSize"));
     const prevGeneratedAt = (existingRow?.get("generatedAt") as string | null) ?? null;
 
-    // 2. Count corpus. Filter matches human-only + human-led-agent-assisted
-    //    across the four primary content labels plus conversation-document
-    //    :Section chunks (chat archives — children of a :KnowledgeDocument
-    //    with `conversationIdentity` set). See VOICE_CORPUS_WHERE above.
+    // 2. Count corpus for this specific format.
+    const corpusWhere = voiceCorpusWhereWithFormat(format);
     const countResult = await session.run(
       `MATCH (n)
-       WHERE ${VOICE_CORPUS_WHERE}
+       WHERE ${corpusWhere}
        RETURN count(n) AS c`,
-      { accountId },
+      { accountId, format },
     );
     const corpusSize = toJsNumber(countResult.records[0]?.get("c")) ?? 0;
 
     if (corpusSize === 0) {
       process.stderr.write(
-        `[voice-distil] adminUser=${userId} skip reason=empty-corpus\n`,
+        `[voice-distil] adminUser=${userId} format=${format} skip reason=empty-corpus\n`,
       );
       return {
         profileId: prevProfileId,
@@ -139,9 +164,6 @@ export async function voiceDistilProfile(
     if (!force && prevProfileId && prevCorpusSize !== null && prevGeneratedAt) {
       const ageMs = now.getTime() - new Date(prevGeneratedAt).getTime();
       const ageDays = ageMs / (24 * 60 * 60 * 1000);
-      // prevCorpusSize is non-null here (the guard above checks). When it's
-      // zero we treat growth as infinite — first real corpus always triggers
-      // a re-run.
       const growth =
         prevCorpusSize > 0
           ? (corpusSize - prevCorpusSize) / prevCorpusSize
@@ -151,7 +173,7 @@ export async function voiceDistilProfile(
       if (!ageTrigger && !growthTrigger) {
         const reason = ageDays < 1 ? "recent" : "below-threshold";
         process.stderr.write(
-          `[voice-distil] adminUser=${userId} skip reason=${reason} corpusSize=${corpusSize} prevCorpus=${prevCorpusSize} ageDays=${ageDays.toFixed(1)}\n`,
+          `[voice-distil] adminUser=${userId} format=${format} skip reason=${reason} corpusSize=${corpusSize} prevCorpus=${prevCorpusSize} ageDays=${ageDays.toFixed(1)}\n`,
         );
         return {
           profileId: prevProfileId,
@@ -165,12 +187,9 @@ export async function voiceDistilProfile(
     }
 
     // 4. Sample corpus bodies up to the char cap. Pick recent first.
-    //    Timestamp coalesces include `firstMessageAt` for conversation-document
-    //    :Section chunks so chat archives sort by when the conversation
-    //    actually happened.
     const sampled = await session.run(
       `MATCH (n)
-       WHERE ${VOICE_CORPUS_WHERE}
+       WHERE ${corpusWhere}
        WITH n, coalesce(n.dateSent, n.datePublished, n.firstMessageAt, n.dateCreated, n.createdAt) AS ts
        OPTIONAL MATCH (parent:KnowledgeDocument)-[:HAS_SECTION]->(n)
        WHERE 'Section' IN labels(n) AND parent.conversationIdentity IS NOT NULL
@@ -181,17 +200,13 @@ export async function voiceDistilProfile(
               ts
        ORDER BY ts IS NULL, ts DESC
        LIMIT 500`,
-      { accountId },
+      { accountId, format },
     );
     const samples: { id: string; label: string; body: string }[] = [];
     let charBudget = SAMPLE_CHAR_CAP;
     for (const r of sampled.records) {
       const body = (r.get("body") as string | null) ?? "";
       const labels = (r.get("labels") as string[]) ?? [];
-      // Conversation-document sections carry `:Section` only after the Task
-      // 324 collapse; surface "Conversation" via the parent's
-      // `conversationIdentity` so the LLM exemplar header still says "this
-      // is chat" rather than the bare base label.
       const isConversationChunk = Boolean(r.get("isConversationChunk"));
       const label = isConversationChunk
         ? "Conversation"
@@ -205,26 +220,21 @@ export async function voiceDistilProfile(
       if (charBudget <= 0) break;
     }
 
-    // 5. Pull feedback intents from existing :VoiceEdit nodes for this operator.
+    // 5. Pull feedback intents from existing :VoiceEdit nodes for this format.
     const feedback = await session.run(
-      `MATCH (a:AdminUser {accountId: $accountId, userId: $userId})
-       MATCH (e:VoiceEdit {userId: $userId, accountId: $accountId})
+      `MATCH (e:VoiceEdit {userId: $userId, accountId: $accountId, format: $format})
        RETURN e.intent AS intent ORDER BY e.occurredAt DESC LIMIT 50`,
-      { accountId, userId },
+      { accountId, userId, format },
     );
     const feedbackIntents = feedback.records
       .map((r) => r.get("intent") as string | null)
       .filter((x): x is string => typeof x === "string" && x.length > 0);
 
     // 6. Mode branch (Task 424).
-    //   - `sample` (default): return the exemplars + feedback intents to the
-    //     calling agent. The agent composes the YAML style card in its own
-    //     turn and re-invokes with mode='write'.
-    //   - `write`: persist the agent-produced style card.
     const mode = params.mode ?? "sample";
     if (mode === "sample") {
       process.stderr.write(
-        `[voice-distil] adminUser=${userId} mode=sample corpusSize=${corpusSize} ` +
+        `[voice-distil] adminUser=${userId} format=${format} mode=sample corpusSize=${corpusSize} ` +
           `exemplars=${samples.length} feedbackEntries=${feedbackIntents.length}\n`,
       );
       return {
@@ -246,16 +256,11 @@ export async function voiceDistilProfile(
       );
     }
 
-    // 7. Write the :VoiceProfile node + LEARNED_FROM edges to every sampled node.
-    //
-    //    The :AdminUser must already exist (onboarding/auth is the only
-    //    legitimate origin for :AdminUser). MATCH not MERGE: a typo in
-    //    userId, an env mismatch, or a dropped credential surfaces
-    //    here as a typed error rather than silently minting an orphan
-    //    AdminUser that bypasses the platform's label-origin protection.
+    // 7. Write the :VoiceProfile node — keyed on (accountId, userId, format) —
+    //    plus LEARNED_FROM edges to every sampled node.
     const writeResult = await session.run(
       `MATCH (a:AdminUser {accountId: $accountId, userId: $userId})
-       MERGE (a)-[:HAS_VOICE_PROFILE]->(p:VoiceProfile {accountId: $accountId, userId: $userId})
+       MERGE (a)-[:HAS_VOICE_PROFILE]->(p:VoiceProfile {accountId: $accountId, userId: $userId, format: $format})
          ON CREATE SET p.createdAt = $now
        SET p.styleCard = $styleCard,
            p.generatedAt = $now,
@@ -270,6 +275,7 @@ export async function voiceDistilProfile(
       {
         accountId,
         userId,
+        format,
         styleCard: styleCardYaml,
         now: nowIso,
         corpusSize,
@@ -277,8 +283,6 @@ export async function voiceDistilProfile(
         sampleIds: samples.map((s) => s.id),
       },
     );
-    // MATCH-on-:AdminUser failure yields zero records. Throw the typed
-    // error here rather than returning a half-baked result.
     if (writeResult.records.length === 0) {
       throw new Error(
         `voice-mirror: :AdminUser {accountId='${accountId}', userId='${userId}'} not found. Onboarding must promote the operator to :AdminUser before distillation.`,
@@ -287,7 +291,7 @@ export async function voiceDistilProfile(
     const profileId = writeResult.records[0].get("profileId") as string;
 
     process.stderr.write(
-      `[voice-distil] adminUser=${userId} mode=write corpusSize=${corpusSize} generatedAt=${nowIso} feedbackEntries=${feedbackIntents.length}\n`,
+      `[voice-distil] adminUser=${userId} format=${format} mode=write corpusSize=${corpusSize} generatedAt=${nowIso} feedbackEntries=${feedbackIntents.length}\n`,
     );
 
     return {
@@ -301,3 +305,58 @@ export async function voiceDistilProfile(
     await session.close();
   }
 }
+
+export async function voiceDistilProfile(
+  params: VoiceDistilProfileParams,
+): Promise<VoiceDistilProfileResult | VoiceDistilProfileResult[]> {
+  const { accountId, userId, force = false } = params;
+  if (!accountId || !userId) {
+    throw new Error("voice-distil-profile: accountId and userId required");
+  }
+
+  // Single-format path.
+  if (params.format !== undefined) {
+    return distilForFormat({ ...params, format: params.format, force });
+  }
+
+  // Multi-format path: enumerate distinct format values present in the corpus.
+  const session = getSession();
+  let formats: VoiceFormat[] = [];
+  try {
+    const enumResult = await session.run(
+      `MATCH (n)
+       WHERE ${VOICE_CORPUS_WHERE} AND n.format IS NOT NULL
+       RETURN DISTINCT n.format AS fmt`,
+      { accountId },
+    );
+    formats = enumResult.records
+      .map((r) => r.get("fmt") as string)
+      .filter((f): f is VoiceFormat =>
+        (FORMAT_VALUES as readonly string[]).includes(f),
+      );
+  } finally {
+    await session.close();
+  }
+
+  if (formats.length === 0) {
+    process.stderr.write(
+      `[voice-distil] adminUser=${userId} skip reason=no-format-tagged-content\n`,
+    );
+    return {
+      profileId: null,
+      corpusSize: 0,
+      generatedAt: null,
+      feedbackEntries: 0,
+      skipped: true,
+      skipReason: "no-format-tagged-content",
+    };
+  }
+
+  // Distil each discovered format sequentially.
+  const results: VoiceDistilProfileResult[] = [];
+  for (const format of formats) {
+    const result = await distilForFormat({ ...params, format, force });
+    results.push(result);
+  }
+  return results;
+}

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

@@ -0,0 +1,229 @@
+/**
+ * voice-ingest-session-text — extract operator turns from a Claude Code
+ * session JSONL and write them as :Message {format:'text', source:'admin-pty'}
+ * corpus nodes.
+ *
+ * Called by the SessionEnd hook (via the CLI wrapper) after each admin PTY
+ * session. Re-running against the same JSONL 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.
+ *
+ * JSONL record shape expected (Claude Code session format):
+ *   { "type": "user" | "assistant", "message": { "role": "...", "content": ... }, ... }
+ *
+ * "Real operator text" extraction rules (excludes):
+ *   - type != "user" or message.role != "user"         → not the operator
+ *   - content is tool_result-only                       → tool reply, not turn
+ *   - text starts with "/"                              → slash command
+ *   - text contains "<system-reminder>"                 → harness injection
+ *   - text.length >= 4096                              → likely pasted content
+ *   - text is empty after trimming                      → nothing to ingest
+ */
+import { createHash } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { createInterface } from "node:readline";
+import { getSession } from "../lib/neo4j.js";
+import { voiceDistilProfile } from "./voice-distil-profile.js";
+
+export interface VoiceIngestSessionTextParams {
+  sessionJsonlPath: string;
+  accountId: string;
+  userId: string;
+  sessionId?: string;
+}
+
+export interface VoiceIngestSessionTextResult {
+  ingestedCount: number;
+  skippedCount: number;
+  sessionId: string | null;
+}
+
+/**
+ * Extracts text content from a "real operator" user record.
+ * Returns null when the record should be skipped.
+ */
+export function extractOperatorText(record: unknown): string | null {
+  if (!record || typeof record !== "object") return null;
+  const rec = record as Record<string, unknown>;
+
+  if (rec["type"] !== "user") return null;
+
+  const msg = rec["message"];
+  if (!msg || typeof msg !== "object") return null;
+  const message = msg as Record<string, unknown>;
+  if (message["role"] !== "user") return null;
+
+  const content = message["content"];
+  let text = "";
+
+  if (typeof content === "string") {
+    text = content;
+  } else if (Array.isArray(content)) {
+    // Must have at least one non-tool_result block to be a real turn.
+    const nonToolResult = content.filter(
+      (b) => typeof b === "object" && b !== null && (b as Record<string, unknown>)["type"] !== "tool_result",
+    );
+    if (nonToolResult.length === 0) return null;
+
+    // Collect text from all text-type content blocks.
+    const parts: string[] = [];
+    for (const block of content) {
+      if (typeof block !== "object" || block === null) continue;
+      const b = block as Record<string, unknown>;
+      if (b["type"] === "text" && typeof b["text"] === "string") {
+        parts.push(b["text"]);
+      }
+    }
+    text = parts.join("");
+  } else {
+    return null;
+  }
+
+  text = text.trim();
+  if (text.length === 0) return null;
+
+  // Exclusions.
+  if (text.startsWith("/")) return null;                          // slash command
+  if (text.includes("<system-reminder>")) return null;           // harness injection
+  if (text.length >= 4096) return null;                          // paste block
+
+  return text;
+}
+
+/**
+ * Parse a session JSONL file and return all real operator turn texts.
+ * Exported for testability (no DB required).
+ */
+export async function extractOperatorTurns(jsonlPath: string): Promise<string[]> {
+  const turns: string[] = [];
+
+  const rl = createInterface({
+    input: createReadStream(jsonlPath, { encoding: "utf-8" }),
+    crlfDelay: Infinity,
+  });
+
+  for await (const line of rl) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    let record: unknown;
+    try {
+      record = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    const text = extractOperatorText(record);
+    if (text !== null) {
+      turns.push(text);
+    }
+  }
+
+  return turns;
+}
+
+export async function voiceIngestSessionText(
+  params: VoiceIngestSessionTextParams,
+): Promise<VoiceIngestSessionTextResult> {
+  const { sessionJsonlPath, accountId, userId, sessionId = null } = params;
+
+  if (!accountId || !userId) {
+    throw new Error("voice-ingest-session-text: accountId and userId required");
+  }
+  if (!sessionJsonlPath) {
+    throw new Error("voice-ingest-session-text: sessionJsonlPath required");
+  }
+
+  // 1. Extract operator turns from the JSONL.
+  let allTurns: string[];
+  try {
+    allTurns = await extractOperatorTurns(sessionJsonlPath);
+  } catch (err) {
+    throw new Error(
+      `voice-ingest-session-text: failed to read JSONL at '${sessionJsonlPath}': ${
+        err instanceof Error ? err.message : String(err)
+      }`,
+    );
+  }
+
+  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

@@ -7,19 +7,28 @@
  * 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)` if the profile
- *      exists; otherwise write the :VoiceEdit alone so the next distillation
- *      back-fills the edge.
+ *   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
@@ -44,13 +53,16 @@ export interface VoiceRecordFeedbackResult {
 export async function voiceRecordFeedback(
   params: VoiceRecordFeedbackParams,
 ): Promise<VoiceRecordFeedbackResult> {
-  const { accountId, userId, originalText, editedText, intent: rawIntent, context } = params;
+  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(
@@ -70,6 +82,7 @@ export async function voiceRecordFeedback(
          editId: $editId,
          accountId: $accountId,
          userId: $userId,
+         format: $format,
          originalText: $originalText,
          editedText: $editedText,
          intent: $intent,
@@ -79,7 +92,7 @@ export async function voiceRecordFeedback(
        })
        CREATE (a)-[:AUTHORED]->(e)
        WITH e
-       OPTIONAL MATCH (:AdminUser {accountId: $accountId, userId: $userId})-[:HAS_VOICE_PROFILE]->(p:VoiceProfile)
+       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)
        )
@@ -87,6 +100,7 @@ export async function voiceRecordFeedback(
       {
         accountId,
         userId,
+        format,
         editId,
         originalText,
         editedText,
@@ -104,7 +118,7 @@ export async function voiceRecordFeedback(
     const hadProfile = result.records[0].get("hadProfile") === true;
 
     process.stderr.write(
-      `[voice-record-feedback] adminUser=${userId} intent="${cappedIntent.replace(/"/g, "'")}" diffBytes=${editedText.length - originalText.length}\n`,
+      `[voice-record-feedback] adminUser=${userId} format=${format} intent="${cappedIntent.replace(/"/g, "'")}" diffBytes=${editedText.length - originalText.length}\n`,
     );
 
     return { editId, intent: cappedIntent, occurredAt, hadProfile };