@rubytech/create-maxy-code 0.1.254 → 0.1.256

package/payload/premium-plugins/writer-craft/mcp/scripts/smoke.mjs

@@ -16,14 +16,13 @@
  *      collapsing a failed lookup into the no-data payload.
  *   9. voice-tag-content validates mode and format enums, requires format,
  *      and returns zero counts on empty nodeIds (with format supplied).
- *  11. voice-ingest-session-text: extractOperatorTurns() extracts real turns
+ *  11. voice-ingest-session-text: filterOperatorText() keeps real turns
  *      and excludes slash commands, paste blocks, and system reminders.
  *
  * Exit code: 0 on pass, 1 on any assertion failure.
  */
 import { strict as assert } from "node:assert";
-import { readFileSync, writeFileSync, mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
+import { readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { readdirSync } from "node:fs";
@@ -132,8 +131,7 @@ await check("voice-record-feedback exports voiceRecordFeedback function", () =>
 });
 await check("voice-ingest-session-text exports required functions", () => {
   assert.equal(typeof ingestMod.voiceIngestSessionText, "function");
-  assert.equal(typeof ingestMod.extractOperatorTurns, "function");
-  assert.equal(typeof ingestMod.extractOperatorText, "function");
+  assert.equal(typeof ingestMod.filterOperatorText, "function");
 });
 
 // ---------------------------------------------------------------------------
@@ -294,127 +292,52 @@ await check("voice-tag-content returns zero counts on empty nodeIds (no DB hit)"
 });
 
 // ---------------------------------------------------------------------------
-// 7. voice-ingest-session-text: JSONL extraction (no DB required).
+// 7. voice-ingest-session-text: operator-turn filter (no DB required).
 // ---------------------------------------------------------------------------
-console.log("\n-- JSONL extraction --");
+console.log("\n-- operator-turn filter --");
 
-function makeJsonlLine(type, role, content) {
-  return JSON.stringify({ type, message: { role, content } });
-}
-
-await check("extractOperatorText: real user turn is extracted", () => {
-  const record = { type: "user", message: { role: "user", content: "Hello world" } };
-  const result = ingestMod.extractOperatorText(record);
-  assert.equal(result, "Hello world");
-});
-await check("extractOperatorText: slash command is excluded", () => {
-  const record = { type: "user", message: { role: "user", content: "/end" } };
-  assert.equal(ingestMod.extractOperatorText(record), null);
+await check("filterOperatorText: real turn is kept (and trimmed)", () => {
+  assert.equal(ingestMod.filterOperatorText("  Hello world  "), "Hello world");
 });
-await check("extractOperatorText: system-reminder is excluded", () => {
-  const record = {
-    type: "user",
-    message: { role: "user", content: "<system-reminder>some injected text</system-reminder>" },
-  };
-  assert.equal(ingestMod.extractOperatorText(record), null);
+await check("filterOperatorText: slash command is excluded", () => {
+  assert.equal(ingestMod.filterOperatorText("/end"), null);
 });
-await check("extractOperatorText: paste block > 4096 chars is excluded", () => {
-  const record = {
-    type: "user",
-    message: { role: "user", content: "x".repeat(4097) },
-  };
-  assert.equal(ingestMod.extractOperatorText(record), null);
+await check("filterOperatorText: system-reminder is excluded", () => {
+  assert.equal(
+    ingestMod.filterOperatorText("<system-reminder>some injected text</system-reminder>"),
+    null,
+  );
 });
-await check("extractOperatorText: paste block = 4096 chars is excluded", () => {
-  const record = {
-    type: "user",
-    message: { role: "user", content: "x".repeat(4096) },
-  };
-  assert.equal(ingestMod.extractOperatorText(record), null);
+await check("filterOperatorText: empty / whitespace-only is excluded", () => {
+  assert.equal(ingestMod.filterOperatorText("   "), null);
 });
-await check("extractOperatorText: paste block = 4095 chars is included", () => {
-  const body = "x".repeat(4095);
-  const record = { type: "user", message: { role: "user", content: body } };
-  assert.equal(ingestMod.extractOperatorText(record), body);
+await check("filterOperatorText: non-string is excluded", () => {
+  assert.equal(ingestMod.filterOperatorText(undefined), null);
+  assert.equal(ingestMod.filterOperatorText(42), null);
 });
-await check("extractOperatorText: assistant turn is excluded", () => {
-  const record = { type: "assistant", message: { role: "assistant", content: "Reply" } };
-  assert.equal(ingestMod.extractOperatorText(record), null);
+await check("filterOperatorText: paste block >= 4096 chars is excluded", () => {
+  assert.equal(ingestMod.filterOperatorText("x".repeat(4096)), null);
+  assert.equal(ingestMod.filterOperatorText("x".repeat(4097)), null);
 });
-await check("extractOperatorText: tool_result-only content is excluded", () => {
-  const record = {
-    type: "user",
-    message: {
-      role: "user",
-      content: [{ type: "tool_result", tool_use_id: "x", content: "ok" }],
-    },
-  };
-  assert.equal(ingestMod.extractOperatorText(record), null);
-});
-await check("extractOperatorText: content array with text block is extracted", () => {
-  const record = {
-    type: "user",
-    message: {
-      role: "user",
-      content: [{ type: "text", text: "Hello from array" }],
-    },
-  };
-  assert.equal(ingestMod.extractOperatorText(record), "Hello from array");
+await check("filterOperatorText: 4095 chars is included", () => {
+  const body = "x".repeat(4095);
+  assert.equal(ingestMod.filterOperatorText(body), body);
 });
 
-// Full JSONL fixture: 3 real turns + 2 assistant + 1 slash + 1 system-reminder.
-// Expected: extractOperatorTurns returns 3 strings.
+// turns-array semantics: a mixed array filters down to the real turns.
 await check(
-  "extractOperatorTurns: fixture with 3 real turns + 4 excluded → 3 results",
-  async () => {
-    const tmp = mkdtempSync(join(tmpdir(), "smoke-ingest-"));
-    const jsonlPath = join(tmp, "session.jsonl");
-    const lines = [
-      // 3 real operator turns
-      makeJsonlLine("user", "user", "First real turn"),
-      makeJsonlLine("user", "user", "Second real turn"),
-      makeJsonlLine("user", "user", "Third real turn"),
-      // 2 assistant turns
-      makeJsonlLine("assistant", "assistant", "Agent reply 1"),
-      makeJsonlLine("assistant", "assistant", "Agent reply 2"),
-      // 1 slash command
-      makeJsonlLine("user", "user", "/end"),
-      // 1 system reminder
-      makeJsonlLine("user", "user", "<system-reminder>injected</system-reminder>"),
+  "turns array: 3 real turns + 3 excluded → filterOperatorText keeps 3",
+  () => {
+    const turns = [
+      "First real turn",
+      "Second real turn",
+      "/end", // slash command
+      "<system-reminder>injected</system-reminder>", // harness injection
+      "Third real turn",
+      "   ", // whitespace only
     ];
-    writeFileSync(jsonlPath, lines.join("\n") + "\n");
-    try {
-      const turns = await ingestMod.extractOperatorTurns(jsonlPath);
-      assert.equal(turns.length, 3, `expected 3 turns, got ${turns.length}`);
-      assert.equal(turns[0], "First real turn");
-      assert.equal(turns[1], "Second real turn");
-      assert.equal(turns[2], "Third real turn");
-    } finally {
-      rmSync(tmp, { recursive: true, force: true });
-    }
-  },
-);
-
-// Second-run fixture: same lines written to same path → same 3 turns extracted.
-// (Actual dedup happens in the DB via contentHash MERGE; extraction is idempotent.)
-await check(
-  "extractOperatorTurns: re-running same JSONL extracts same turns (dedup is in DB)",
-  async () => {
-    const tmp = mkdtempSync(join(tmpdir(), "smoke-ingest-dedup-"));
-    const jsonlPath = join(tmp, "session.jsonl");
-    const lines = [
-      makeJsonlLine("user", "user", "Dedupe turn"),
-      makeJsonlLine("user", "user", "/skip-cmd"),
-    ];
-    writeFileSync(jsonlPath, lines.join("\n") + "\n");
-    try {
-      const turns1 = await ingestMod.extractOperatorTurns(jsonlPath);
-      const turns2 = await ingestMod.extractOperatorTurns(jsonlPath);
-      assert.deepEqual(turns1, turns2, "idempotent: same JSONL gives same turns");
-      assert.equal(turns1.length, 1);
-    } finally {
-      rmSync(tmp, { recursive: true, force: true });
-    }
+    const kept = turns.map((t) => ingestMod.filterOperatorText(t)).filter((t) => t !== null);
+    assert.deepEqual(kept, ["First real turn", "Second real turn", "Third real turn"]);
   },
 );
 

package/payload/premium-plugins/writer-craft/mcp/src/index.ts

@@ -348,13 +348,13 @@ server.tool(
 
 server.tool(
   "voice-ingest-session-text",
-  "Ingest operator PTY turns from a Claude Code session JSONL as :Message {format:'text', source:'admin-pty', authorshipMode:'human-only'} corpus nodes. Deduplication via SHA256 contentHash — re-running against the same JSONL is a no-op. Triggers voice-distil-profile {format:'text'} after ingest (cadence guard decides whether distillation runs). Called automatically by the SessionEnd hook; can also be invoked manually.",
+  "Write operator turns from the current session as :Message {format:'text', source:'admin-pty', authorshipMode:'human-only'} corpus nodes. The admin agent reads its own operator turns from the live conversation context and passes them as `turns`. Deduplication via SHA256 contentHash — re-running with the same turns is a no-op. Triggers voice-distil-profile {format:'text'} after ingest (cadence guard decides whether distillation runs). Invoked on demand by the voice-mirror skill when the operator asks to capture this session's voice.",
   {
-    sessionJsonlPath: z.string().min(1).describe("Absolute path to the Claude Code session JSONL file"),
-    sessionId: z.string().optional().describe("Session ID for provenance; read from the SessionEnd envelope"),
+    turns: z.array(z.string()).describe("Operator turns the agent read from its own session context (one string per operator message). Slash commands, harness injections, and large paste blocks are filtered out by the tool."),
+    sessionId: z.string().optional().describe("Session ID for provenance."),
     userId: z.string().optional().describe("Operator AdminUser identifier. Defaults to ADMIN_USER_ID env."),
   },
-  async ({ sessionJsonlPath, sessionId, userId }) => {
+  async ({ turns, sessionId, userId }) => {
     if (!accountId) return refuseNoAccount("voice-ingest-session-text");
     const resolvedUserId = userId ?? resolveUserId();
     if (!resolvedUserId) {
@@ -370,7 +370,7 @@ server.tool(
     }
     try {
       const result = await voiceIngestSessionText({
-        sessionJsonlPath,
+        turns,
         accountId,
         userId: resolvedUserId,
         sessionId,

package/payload/premium-plugins/writer-craft/mcp/src/lib/voice-corpus.ts

@@ -19,7 +19,7 @@ export function notTrashed(alias: string): string {
  *
  * Imported by `voice-distil-profile` (count + sample walks),
  * `voice-retrieve-conditioning` (exemplar walk), `voice-tag-content` (tag
- * writes), and `voice-ingest-session-text` (SessionEnd ingest). The single
+ * writes), and `voice-ingest-session-text` (on-demand session-text ingest). The single
  * load-bearing filter — when the corpus rules change, this is the only place
  * to edit.
  *

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

@@ -1,34 +1,29 @@
 /**
- * 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.
+ * voice-ingest-session-text — write operator turns the agent read from its
+ * own session context 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.
+ * 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.
  *
- * 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
+ * "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
- *   - 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;
+  turns: string[];
   accountId: string;
   userId: string;
   sessionId?: string;
@@ -41,109 +36,37 @@ export interface VoiceIngestSessionTextResult {
 }
 
 /**
- * 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.
+ * 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 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 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 { sessionJsonlPath, accountId, userId, sessionId = null } = params;
+  const { turns, 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");
+  if (!Array.isArray(turns)) {
+    throw new Error("voice-ingest-session-text: turns array 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)
-      }`,
-    );
+  // 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) {

package/payload/premium-plugins/writer-craft/skills/voice-mirror/SKILL.md

@@ -15,7 +15,7 @@ The skill is built on five deterministic MCP tools served by the `writer-craft`
 | `voice-distil-profile` | Walk the operator's `human-only` corpus for a given `format` and produce a `:VoiceProfile {styleCard, generatedAt, corpusSize, feedbackEntries, format}` node. Without a `format`, enumerates all formats present in the corpus and distils each. |
 | `voice-retrieve-conditioning` | Return `{styleCard, exemplars[]}` for a drafting brief. Requires `brief.format` (one of the six corpus formats). K=5 for short-form, K=15 for long-form. Token-budget bounded. |
 | `voice-record-feedback` | When the operator edits an agent draft, write a `:VoiceEdit {originalText, editedText, intent, occurredAt, format}-[:FEEDBACK_FOR]->(:VoiceProfile {format})` node. The `intent` field is a Haiku-summarised diff. |
-| `voice-ingest-session-text` | (Called by the SessionEnd hook, not directly.) Ingest operator PTY turns from the session transcript as `:Message {format:'text', authorshipMode:'human-only'}` corpus nodes. Deduplicates via `contentHash`. |
+| `voice-ingest-session-text` | Write operator turns from the current session as `:Message {format:'text', authorshipMode:'human-only'}` corpus nodes. The agent reads its own operator turns from context and passes them as `turns`. Deduplicates via `contentHash`. Invoked on demand when the operator asks to capture this session's voice. |
 
 ## Surface — admin only, never delegated
 
@@ -32,6 +32,7 @@ Activate when the operator says any of:
 - **"Read my writing first" / "draft this in my voice" — when the operator is asking for a hand-written-quality draft, not a generic AI reply.** Drives `voice-retrieve-conditioning`; the calling drafting skill is the actual surface, this skill is the conditioning input.
 - **"Use my edit as a teaching example" / "remember how I changed that".** Drives `voice-record-feedback`.
 - **"Review my historical writing and tag it" / "start the backfill".** Drives the interactive backfill flow described below.
+- **"Capture my voice from this chat" / "ingest this session" / "learn how I write from this conversation".** Drives the on-demand session-text capture flow described below.
 
 Do **not** activate for:
 
@@ -45,7 +46,7 @@ Voice profiles are segmented by content format. The closed enum is:
 
 | Format | Operator picks for |
 |--------|--------------------|
-| `text` | `:Message` nodes; the SessionEnd hook stamps this automatically on operator PTY turns (the sole hard-coded path — chat turns are unambiguously text and the operator is not in the loop on session end) |
+| `text` | `:Message` nodes; the operator's session turns, captured on demand via `voice-ingest-session-text` when the operator asks to capture this session's voice |
 | `email` | Email threads stored as `:KnowledgeDocument {source:'email'}` or `:ConversationArchive {source:'email'}` |
 | `social-post` | `:SocialPost` nodes |
 | `article` | Long-form `:KnowledgeDocument` the operator considers an article |
@@ -97,18 +98,17 @@ Authorship at conversation granularity is a deliberate UX trade-off: chunks with
 
 After each backfill batch, check whether the qualifying corpus (`authorshipMode IN ['human-only', 'human-led-agent-assisted']`) for any format has grown ≥20% since the last `:VoiceProfile.corpusSize` for that format (or ≥1 entry if no profile exists for that format). If yes, offer to run `voice-distil-profile` immediately. The operator can defer; the next scheduled distillation will pick it up.
 
-## Automatic text-format capture (SessionEnd hook)
+## On-demand text-format capture (session turns)
 
-Operator PTY turns are automatically ingested into the `text` corpus at the end of every session — no operator action required. The `voice-session-end-text.sh` hook fires when Claude Code terminates the PTY session. It reads the JSONL transcript, filters to genuine operator turns (excludes slash commands, system reminders, and large paste blocks), deduplicates via SHA256 content hash, and writes each new turn as a `:Message {format:'text', authorshipMode:'human-only'}` node.
+Operator turns are captured into the `text` corpus on demand — when the operator asks to capture this session's voice, never automatically. There is no SessionEnd hook; the operator is in the loop.
 
-The hook only runs for admin sessions (role=admin, no specialist flag). Accounts without writer-craft installed skip silently — the hook guards on CLI existence.
+When the operator says "capture my voice from this chat" (or similar):
 
-After ingestion the hook triggers an incremental distillation for the `text` format if the corpus grew ≥20% since the last profile.
+1. Read the operator's own turns from the live conversation context — the user messages already in this session.
+2. Call `voice-ingest-session-text` with those turns as the `turns` array. The tool filters out slash commands, harness injections (`<system-reminder>`), and large paste blocks, deduplicates via SHA256 content hash, and writes each new turn as a `:Message {format:'text', authorshipMode:'human-only'}` node.
+3. The tool triggers an incremental `text`-format distillation if the corpus grew ≥20% since the last profile.
 
-Observe via:
-```
-journalctl -u maxy-code | grep '\[voice-session-end-hook\]'
-```
+This runs only on the admin seat (the tool is admin-allowlisted). Accounts without a voice profile degrade gracefully — capture simply populates the corpus for the first distillation.
 
 ## Flow — drafting-time conditioning
 
@@ -182,7 +182,7 @@ The tool returns `{existingStyleCard, exemplars[], feedbackIntents[], eligible,
 
 When `eligible=0` (every named document failed the predicate) surface the `ineligible[]` payload to the operator naming the per-id reason (`node-not-found`, `wrong-account`, `ineligible-authorship-mode`, `trashed`, `ineligible-label`) rather than silently no-op. Most commonly this means the documents are tagged as `agent-only` and need re-tagging via `voice-tag-content` before they can amend a profile.
 
-Amend mode does not apply to the SessionEnd auto-ingest path. Session-text ingest stays on the full-corpus path; amend is operator-initiated only.
+Amend mode does not apply to the on-demand session-text capture path. Session-text ingest stays on the full-corpus path; amend is operator-initiated only.
 
 ## Per-operator scope
 
@@ -199,18 +199,16 @@ One `:VoiceProfile` per `(accountId, userId, format)`. Multi-author accounts (an
 | `[voice-distil] mode=write userId=<id> format=<format> amended=true amendedFromNodeIds=<count> ...` | Amend-write fired (operator-initiated update persisted). |
 | `[voice-retrieve] task=<topic> format=<format> styleCardBytes=<n> exemplarCount=<k> tokenBudget=<n>` | Each retrieval. |
 | `[voice-record-feedback] userId=<id> format=<format> intent="<haiku-summary>" diffBytes=<n>` | Each feedback write. |
-| `[voice-session-end-hook] trigger sessionId=<id>` | Hook fires for an eligible session. |
-| `[voice-session-end-hook] result=ok sessionId=<id> turns=<n> skipped=<m>` | Successful ingest. |
-| `[voice-session-end-hook] trigger-skipped sessionId=<id> reason=<reason>` | Hook guard fired. |
+| `[voice-ingest-session-text] sessionId=<id> adminUser=<id> turns=<n> bytes=<n> skipped=<m>` | On-demand session-text capture. |
 
-**Confirms working:** `[voice-retrieve] exemplarCount≥1` precedes every drafting-skill prompt assembly when the calling skill has not opted out. `[voice-distil]` appears at least once per 30-day window per active format per operator. `[voice-session-end-hook] result=ok` appears after each admin PTY session.
+**Confirms working:** `[voice-retrieve] exemplarCount≥1` precedes every drafting-skill prompt assembly when the calling skill has not opted out. `[voice-distil]` appears at least once per 30-day window per active format per operator. `[voice-ingest-session-text] turns≥1` appears when the operator asks to capture a session's voice.
 
-**Indicates failure:** `[voice-retrieve] exemplarCount=0` with non-empty corpus → similarity index broken; `[voice-distil] error …` → corpus walk or LLM call failed; absence of `[voice-record-feedback]` after an operator-edit-then-send flow → feedback loop is dead; `[voice-session-end-hook] result=err` → CLI or Neo4j issue.
+**Indicates failure:** `[voice-retrieve] exemplarCount=0` with non-empty corpus → similarity index broken; `[voice-distil] error …` → corpus walk or LLM call failed; absence of `[voice-record-feedback]` after an operator-edit-then-send flow → feedback loop is dead.
 
 **Diagnostic path:**
 
 ```
-journalctl -u maxy-code | grep -E '\[voice-(tag|distil|retrieve|record-feedback|session-end-hook)\]'
+journalctl -u maxy-code | grep -E '\[voice-(tag|distil|retrieve|record-feedback|ingest-session-text)\]'
 ```
 
 Filter by `userId=<id>` for per-operator drill-down.

package/payload/server/{chunk-M6A6EZD4.js → chunk-76HRO7NX.js}

@@ -4107,11 +4107,13 @@ process.on("SIGINT", async () => {
 });
 var OLLAMA_URL = process.env.OLLAMA_URL ?? "http://localhost:11434";
 var EMBED_MODEL = process.env.EMBED_MODEL ?? "nomic-embed-text";
+var EMBED_INPUT_MAX_CHARS = 8e3;
 async function embed(text) {
+  const input = text.length > EMBED_INPUT_MAX_CHARS ? text.slice(0, EMBED_INPUT_MAX_CHARS) : text;
   const res = await fetch(`${OLLAMA_URL}/api/embed`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ model: EMBED_MODEL, input: text }),
+    body: JSON.stringify({ model: EMBED_MODEL, input }),
     signal: AbortSignal.timeout(5e3)
   });
   if (!res.ok) {
@@ -4898,6 +4900,17 @@ async function writeAdminUserAndPerson(params) {
   const givenName = firstSpace === -1 ? trimmed : trimmed.slice(0, firstSpace).trim();
   const familyName = firstSpace === -1 ? null : trimmed.slice(firstSpace + 1).trim() || null;
   const now = (/* @__PURE__ */ new Date()).toISOString();
+  let personEmbedding = null;
+  try {
+    personEmbedding = await embed(
+      `[Person] ${[givenName, familyName].filter(Boolean).join(" ")} role: admin-personal`
+    );
+  } catch (err) {
+    process.stderr.write(
+      `[graph-write] warn reason=embed-failed labels=Person agent=admin-bootstrap detail=${err instanceof Error ? err.message : String(err)}
+`
+    );
+  }
   const session = getSession();
   try {
     const result = await session.run(
@@ -4927,6 +4940,7 @@ async function writeAdminUserAndPerson(params) {
            familyName: $familyName,
            role: 'admin-personal',
            scope: 'admin',
+           embedding: $personEmbedding,
            createdAt: $now
          })
          MERGE (au)-[:OWNS]->(newPerson)
@@ -4934,7 +4948,7 @@ async function writeAdminUserAndPerson(params) {
        }
        RETURN reused, elementId(p) AS personElementId,
               p.givenName AS givenName, p.familyName AS familyName`,
-      { userId, fullName: trimmed, accountId, givenName, familyName, now }
+      { userId, fullName: trimmed, accountId, givenName, familyName, now, personEmbedding }
     );
     if (result.records.length === 0) {
       throw new Error("writeAdminUserAndPerson: no record returned");

package/payload/server/maxy-edge.js

@@ -14,7 +14,7 @@ import {
   sanitizeClientCorrId,
   vncLog,
   websockifyLog
-} from "./chunk-M6A6EZD4.js";
+} from "./chunk-76HRO7NX.js";
 import "./chunk-HYQNUVGO.js";
 
 // server/edge.ts