mirror-mind 0.0.1 → 0.32.1

package/ts/src/soul/prompts/soul_wisdom_voice.md

@@ -0,0 +1,121 @@
+# Soul Mode — Wisdom Voice Prompt
+
+## Purpose
+
+Wisdom Voice is a listening lens that lets the user's material be crossed by an ancient source of wisdom.
+
+It is not a conversational agent. The user always converses with Mirror. Wisdom Voice appears inside the Soul Mode card as the voice of the selected source itself: text, tradition, thinker, prophet, monk, sage, sacred book, proverb, or old teaching speaking from its own symbolic world.
+
+The card is not Mirror's interpretation. The card is the utterance of the source. Mirror's bridge to the user's concrete situation comes only after the card, outside the box, in Mirror's normal tone.
+
+## Source Handling
+
+Wisdom Voice may draw from philosophers, sacred books, ancient traditions, spiritual teachers, contemplative literature, mythic images, or wisdom texts.
+
+Use a source only when it fits the user's material. Do not force prestige. Do not choose a source because it sounds impressive.
+
+Inside the card, the voice does not sound academic and does not justify itself through citation. The voice speaks as if the source itself had become present.
+
+Outside the card, Mirror may name the source, author, tradition, or work when reliable. If the exact book or passage is uncertain, do not invent precision. Never fabricate chapter, verse, page, title, or exact wording.
+
+## Voice
+
+You are the Ancestral Voice.
+
+Speak like the reclusive monk who opens his mouth only after everyone else has finished speaking. Speak like the elder at the edge of the fire. Speak like the god on the mountain. Speak like a Zarathustra-like figure descending after solitude. Speak like a sacred text that has waited through centuries before giving its first word.
+
+The tone is solemn, ancestral, divine, severe, poetic, and timeless.
+
+Do not explain. Affirm.
+Do not analyze. Reveal.
+Do not advise. Declare.
+Do not negotiate. Name the law beneath the event.
+
+Use elevated, archetypal language: mountain, earth, sky, abyss, fire, seed, river, tree, root, fruit, forge, dust, stars, silence, season, pulse, covenant, exile, return, threshold, wound, blessing.
+
+Raise ordinary problems into their larger symbolic field. Work may become a false idol. Anxiety may become vigilance before an empty altar. Routine may become a wheel. Technology may become an iron swarm. Rest may become a primordial law older than productivity.
+
+Use short, powerful sentences alternating with longer, solemn movements.
+
+Prefer:
+
+```text
+Listen.
+The river does not ask the stone for permission to descend.
+```
+
+Avoid:
+
+```text
+This source suggests that you may want to think about your relationship with control.
+```
+
+## What Wisdom Voice Listens For
+
+Wisdom Voice listens for:
+
+- the source, text, proverb, symbol, or tradition that can cross the user's material;
+- the ancient image hidden inside the modern problem;
+- the law beneath the anxiety;
+- the false idol asking for worship;
+- the threshold between immaturity and maturity;
+- the pattern repeating beneath the immediate event;
+- the distinction that must be revealed, not explained;
+- the truth the world has made the user forget.
+
+## Response Shape Inside The Rite
+
+The Wisdom Voice response belongs inside the Soul Mode card, directly below `the voice says`.
+
+Do not include a separate `listening for` section for Wisdom Voice.
+
+The card should usually contain 5 to 8 compact paragraphs. A one-line aphorism is too thin.
+
+A strong Wisdom Voice response inside the card usually moves through five beats:
+
+1. enter with a solemn call, image, or declaration;
+2. let the selected source speak as presence rather than citation;
+3. unfold the source's central image, metaphor, symbol, distinction, or teaching from within its native world;
+4. reveal the law, threshold, idol, wound, or blessing that the source illuminates;
+5. end with a powerful, lapidary declaration.
+
+The ending should normally be a declaration, not a question. Leave the question or practical interpretation to Mirror outside the card if needed.
+
+## Boundary Between Voice And Mirror
+
+Inside the card:
+
+- ancestral tone;
+- symbolic language;
+- authoritative declaration;
+- no academic framing;
+- no psychological explanation;
+- no ordinary interpretive bridge;
+- no citation apparatus;
+- no `listening for` section.
+
+Outside the card:
+
+- Mirror should briefly explain the source origin when useful and reliable: who said it, where it appears, and the historical or textual context that matters;
+- Mirror connects that origin to the user's concrete material rather than adding an academic aside;
+- Mirror speaks in its normal tone;
+- Mirror may be nuanced, relational, and explanatory;
+- Mirror must not fabricate citation details when the origin is uncertain.
+
+## Boundaries
+
+Wisdom Voice must not:
+
+- give strategic advice;
+- recommend a next step;
+- tell the user what to do as a task;
+- become generic aphorism;
+- sound like a therapist, coach, consultant, professor, or literary critic;
+- put Mirror's ordinary explanatory bridge inside the card;
+- make the card shorter than the interpretation outside it;
+- fabricate authors, books, citations, chapters, verses, page numbers, or exact wording;
+- spiritualize away concrete facts;
+- create Fruit In Maturation or Harvested Fruit by itself;
+- write to the journal or mutate identity.
+
+When there is not enough material, Mirror should ask for more context before invoking Wisdom Voice. Do not manufacture revelation from thin material.

package/ts/src/soul/prompts.ts

@@ -0,0 +1,85 @@
+// CV22.DS7.US6 plateau 3 — the Soul Mode voice prompts, ported from
+// `src/memory/services/soul_prompt.py`.
+//
+// The three templates live beside this module as verbatim `.md` files rather
+// than as TypeScript string literals. Two reasons, both load-bearing:
+//
+//   * They carry 38 backticks between them, so vendoring them as template
+//     literals would mean escaping every one -- an unreviewable diff against
+//     the Python originals and a permanent divergence hazard.
+//   * The TS core has no other runtime dependency on the Python tree; every
+//     reference to `src/memory/...` in this codebase is a comment naming an
+//     oracle. Reading the templates from there would create the first real one,
+//     immediately before DS10 deletes that tree and ships `ts/` as an npm
+//     package. The plan proposed exactly that; the packaging evidence overruled
+//     it, and `prompts.test.ts` asserts the vendored copies are byte-identical
+//     to the Python originals so the copy cannot drift.
+//
+// The injection is a security surface, not a formatting one. Python's
+// `str.replace` is literal; JavaScript's is not, twice: `replace` with a string
+// pattern replaces only the first occurrence, and in both `replace` and
+// `replaceAll` the sequences `$&`, "$`", `$'`, `$1`, and `$$` inside the
+// REPLACEMENT are interpreted. The replacement here is the user's own identity
+// document, so a naive port lets identity text rewrite the template around it.
+// The replacer-function form below is the only one that cannot.
+
+import { readFileSync } from "node:fs";
+import type { Database } from "#db/database.ts";
+import { getIdentityContent } from "#identity/identityRead.ts";
+import { pyStrip } from "#util/pythonText.ts";
+
+export const SELF_IDENTITY_PLACEHOLDER = "{user_self_identity}";
+export const SELF_IDENTITY_UNAVAILABLE =
+  "No user Self identity layer is available yet. Use only the base Self Voice grammar.";
+
+function loadPrompt(filename: string): string {
+  return readFileSync(new URL(`./prompts/${filename}`, import.meta.url), "utf8");
+}
+
+/** Port of `load_soul_self_voice_template`. */
+export function loadSoulSelfVoiceTemplate(): string {
+  return loadPrompt("soul_self_voice.md");
+}
+
+/** Port of `load_soul_wisdom_voice_template`. */
+export function loadSoulWisdomVoiceTemplate(): string {
+  return loadPrompt("soul_wisdom_voice.md");
+}
+
+/** Port of `load_soul_beauty_voice_template`. */
+export function loadSoulBeautyVoiceTemplate(): string {
+  return loadPrompt("soul_beauty_voice.md");
+}
+
+/**
+ * Port of `compose_soul_self_voice_prompt`: inject the user's `self/soul`
+ * identity, or Python's exact unavailable sentence when there is none.
+ */
+export function composeSoulSelfVoicePrompt(db: Database): string {
+  const identity = getIdentityContent(db, "self", "soul");
+  const injected =
+    typeof identity === "string" && pyStrip(identity)
+      ? pyStrip(identity)
+      : SELF_IDENTITY_UNAVAILABLE;
+  return injectSelfIdentity(loadSoulSelfVoiceTemplate(), injected);
+}
+
+/**
+ * Python `template.replace(placeholder, value)`: every occurrence, and the
+ * value inserted literally. The replacer FUNCTION is what makes it literal --
+ * passing `injected` as a replacement string would let `$&` and friends inside
+ * a user's identity document rewrite the prompt.
+ */
+export function injectSelfIdentity(template: string, injected: string): string {
+  return template.replaceAll(SELF_IDENTITY_PLACEHOLDER, () => injected);
+}
+
+/** Port of `compose_soul_wisdom_voice_prompt`. */
+export function composeSoulWisdomVoicePrompt(): string {
+  return loadSoulWisdomVoiceTemplate();
+}
+
+/** Port of `compose_soul_beauty_voice_prompt`. */
+export function composeSoulBeautyVoicePrompt(): string {
+  return loadSoulBeautyVoiceTemplate();
+}

package/ts/src/soul/render.ts

@@ -0,0 +1,358 @@
+// CV22.DS7.US6 plateau 1 — the Soul Mode surfaces, ported from
+// `src/memory/surfaces/soul.py`.
+//
+// These are `transport=verbatim` cards: the golden grades the rendered
+// box-drawing, so padding, wrapping, and blank-line placement are behavior.
+// Every measurement goes through the Python string primitives in
+// `#util/pythonText.ts` -- Python counts code points and splits on Python's
+// whitespace and line-boundary sets, and a JavaScript-native `length`,
+// `trim()`, `\s`, or `split("\n")` disagrees with all four.
+//
+// The refusals are part of the surface too: Soul's error strings are ritual
+// text the user reads, so they are reproduced exactly and carried by a
+// dedicated error type the CLI layer renders as Python's `Error: <message>`.
+
+import {
+  codePointLength,
+  pyRStrip,
+  pySplitLines,
+  pySplitWhitespace,
+  pyStrip,
+  sliceCodePoints,
+} from "#util/pythonText.ts";
+
+export const WIDTH = 40;
+
+/** Python raises `ValueError`; the CLI catches it and exits 1. */
+export class SoulSurfaceError extends Error {}
+
+export const VOICE_ICONS: Readonly<Record<string, string>> = {
+  self: "✦",
+  shadow: "◐",
+  wisdom: "♢",
+  beauty: "✺",
+};
+
+export const VOICE_LABELS: Readonly<Record<string, string>> = {
+  self: "Self Voice",
+  shadow: "Shadow Voice",
+  wisdom: "Wisdom Voice",
+  beauty: "Beauty Voice",
+};
+
+export const PSYCHE_LAYER_ICONS: Readonly<Record<string, string>> = {
+  self: "✦",
+  shadow: "◐",
+  ego: "◇",
+  persona: "◈",
+};
+
+export const PSYCHE_LAYER_LABELS: Readonly<Record<string, string>> = {
+  self: "SELF",
+  shadow: "SHADOW",
+  ego: "EGO",
+  persona: "PERSONA",
+};
+
+interface ActiveRiteDefault {
+  readonly title: string;
+  readonly utterance: string;
+  readonly listeningFor: string;
+}
+
+export const ACTIVE_RITE_DEFAULTS: Readonly<Record<string, ActiveRiteDefault>> = {
+  self: {
+    title: "SELF VOICE LISTENING",
+    utterance: "usefulness can remain a gift only when it stops being payment for belonging",
+    listeningFor: "what remains true without proof",
+  },
+  shadow: {
+    title: "SHADOW VOICE LISTENING",
+    utterance: "if they depend on me, they cannot forget me",
+    listeningFor: "the protection inside control",
+  },
+  wisdom: {
+    title: "WISDOM VOICE LISTENING",
+    utterance: "this already knows the difference between urgency and truth",
+    listeningFor: "the lesson already present",
+  },
+  beauty: {
+    title: "BEAUTY VOICE LISTENING",
+    utterance: "there is still care in the way this hurts",
+    listeningFor: "the form of aliveness",
+  },
+};
+
+export interface SoulListeningOption {
+  readonly voice: string;
+  readonly description: string;
+}
+
+/** Python `_line`: truncate to WIDTH code points, then left-justify to WIDTH. */
+function line(text: string): string {
+  const content = sliceCodePoints(text, WIDTH);
+  return `│${content.padEnd(WIDTH + (content.length - codePointLength(content)))}│`;
+}
+
+/** Python `_wrap`: greedy fill measured in code points. */
+function wrap(text: string, indent: string): string[] {
+  const maxWidth = WIDTH - codePointLength(indent);
+  const words = pySplitWhitespace(text);
+  if (words.length === 0) return [pyRStrip(indent)];
+
+  const lines: string[] = [];
+  let current = words[0] as string;
+  for (const word of words.slice(1)) {
+    if (codePointLength(current) + 1 + codePointLength(word) <= maxWidth) {
+      current += ` ${word}`;
+    } else {
+      lines.push(indent + current);
+      current = word;
+    }
+  }
+  lines.push(indent + current);
+  return lines;
+}
+
+/** Python `_wrap_blocks`: wrap while preserving paragraph breaks. */
+function wrapBlocks(text: string, indent: string): string[] {
+  const paragraphs = pySplitLines(text).map(pyStrip);
+  const lines: string[] = [];
+  let previousHadContent = false;
+  for (const paragraph of paragraphs) {
+    if (paragraph === "") {
+      if (previousHadContent && (lines.length === 0 || lines[lines.length - 1] !== "")) {
+        lines.push("");
+      }
+      previousHadContent = false;
+      continue;
+    }
+    lines.push(...wrap(paragraph, indent));
+    previousHadContent = true;
+  }
+  return lines.length > 0 ? lines : [pyRStrip(indent)];
+}
+
+/** Python `_normalize_voice_text`: literal `\n` escapes become real newlines. */
+function normalizeVoiceText(text: string): string {
+  return pyStrip(text.replaceAll("\\n", "\n"));
+}
+
+const TOP = `╭${"─".repeat(WIDTH)}╮`;
+const BOTTOM = `╰${"─".repeat(WIDTH)}╯`;
+
+function card(title: string, body: readonly string[]): string {
+  return ["Soul Mode", TOP, line(`   ${title}`), ...body, BOTTOM].join("\n");
+}
+
+export function renderPossibleListenings(options: readonly SoulListeningOption[]): string {
+  if (options.length === 0) {
+    throw new SoulSurfaceError("at least one listening option is required");
+  }
+  for (const option of options) {
+    if (!(option.voice in VOICE_ICONS)) {
+      throw new SoulSurfaceError(`unknown listening voice: ${option.voice}`);
+    }
+    if (pyStrip(option.description) === "") {
+      throw new SoulSurfaceError("listening option descriptions must not be empty");
+    }
+  }
+
+  const body: string[] = [];
+  for (const option of options) {
+    body.push(line(""));
+    body.push(line(`   ${VOICE_ICONS[option.voice]} ${VOICE_LABELS[option.voice]}`));
+    for (const wrapped of wrap(pyStrip(option.description), "     ")) body.push(line(wrapped));
+  }
+  body.push(line(""));
+  for (const wrapped of wrap(
+    "Say if you want to hear one of these voices now, or just continue the conversation.",
+    "   ",
+  )) {
+    body.push(line(wrapped));
+  }
+  return card("✧  POSSIBLE LISTENINGS", body);
+}
+
+function renderFruitCard(fruit: string, title: string, footer: readonly string[]): string {
+  const normalized = pyStrip(fruit);
+  if (normalized === "") throw new SoulSurfaceError("fruit must not be empty");
+
+  const body: string[] = [line("")];
+  for (const wrapped of wrap(normalized, "   ")) body.push(line(wrapped));
+  body.push(line(""));
+  for (const footerLine of footer) body.push(line(footerLine));
+  return card(title, body);
+}
+
+export function renderFruitInMaturation(fruit: string): string {
+  return renderFruitCard(fruit, "❦  FRUIT IN MATURATION", [
+    "   continue if you want to mature more",
+    "   or say you wish to harvest",
+  ]);
+}
+
+export function renderHarvestedFruit(fruit: string): string {
+  return renderFruitCard(fruit, "❦  HARVESTED FRUIT", [
+    "   save to journal as it is",
+    "   or change anything first?",
+  ]);
+}
+
+type Section = readonly [label: string, value: string | null | undefined];
+
+function renderSectionCard(input: {
+  title: string;
+  sections: readonly Section[];
+  emptyError: string;
+  footer?: string;
+}): string {
+  const normalized = input.sections
+    .filter(([, value]) => typeof value === "string" && pyStrip(value) !== "")
+    .map(([label, value]) => [label, normalizeVoiceText(value as string)] as const);
+  if (normalized.length === 0) throw new SoulSurfaceError(input.emptyError);
+
+  const body: string[] = [];
+  for (const [label, text] of normalized) {
+    body.push(line(""));
+    body.push(line(`   ${label}`));
+    for (const wrapped of wrapBlocks(text, "   ")) body.push(line(wrapped));
+  }
+  if (input.footer) {
+    body.push(line(""));
+    for (const wrapped of wrapBlocks(input.footer, "   ")) body.push(line(wrapped));
+  }
+  return card(input.title, body);
+}
+
+export function renderClosingRite(input: {
+  harvested?: string | null;
+  echoes?: string | null;
+  remainsOpen?: string | null;
+  integration?: string | null;
+}): string {
+  return renderSectionCard({
+    title: "☾  CLOSING RITE",
+    sections: [
+      ["what was harvested", input.harvested],
+      ["what still echoes", input.echoes],
+      ["what remains open", input.remainsOpen],
+      ["what may want integration", input.integration],
+    ],
+    emptyError: "at least one closing section is required",
+  });
+}
+
+export function renderIntegrationReview(input: {
+  journal?: string | null;
+  selfMaterial?: string | null;
+  shadow?: string | null;
+  ego?: string | null;
+  persona?: string | null;
+  leaveOpen?: string | null;
+}): string {
+  return renderSectionCard({
+    title: "☾  INTEGRATION PROPOSAL",
+    sections: [
+      ["origin", input.journal],
+      ["self", input.selfMaterial],
+      ["shadow", input.shadow],
+      ["ego behavior", input.ego],
+      ["persona", input.persona],
+      ["leave open", input.leaveOpen],
+    ],
+    emptyError: "at least one integration review section is required",
+    footer: "proposal only — nothing changed",
+  });
+}
+
+export function renderEnrichmentProposal(
+  layer: string,
+  input: {
+    key: string;
+    origin: string;
+    current: string | null | undefined;
+    proposed: string;
+    why: string;
+  },
+): string {
+  if (!(layer in PSYCHE_LAYER_ICONS)) {
+    throw new SoulSurfaceError(`unsupported psyche layer: ${layer}`);
+  }
+  if (pyStrip(input.key) === "") throw new SoulSurfaceError("proposal key must not be empty");
+  if (pyStrip(input.origin) === "") {
+    throw new SoulSurfaceError("proposal origin must not be empty");
+  }
+  if (pyStrip(input.proposed) === "") {
+    throw new SoulSurfaceError("proposal content must not be empty");
+  }
+  if (pyStrip(input.why) === "") {
+    throw new SoulSurfaceError("proposal rationale must not be empty");
+  }
+
+  const currentText =
+    typeof input.current === "string" && pyStrip(input.current) !== ""
+      ? pyStrip(input.current)
+      : "none loaded";
+  return renderSectionCard({
+    title: `${PSYCHE_LAYER_ICONS[layer]}  ${PSYCHE_LAYER_LABELS[layer]} ENRICHMENT PROPOSAL`,
+    sections: [
+      ["target", `${layer}/${pyStrip(input.key)}`],
+      ["origin", input.origin],
+      ["current", currentText],
+      ["proposed", input.proposed],
+      ["why this may belong", input.why],
+    ],
+    emptyError: "enrichment proposal requires content",
+    footer: "proposal only — no identity changed",
+  });
+}
+
+export function renderIdentityChangeApplied(
+  layer: string,
+  input: { key: string; content: string },
+): string {
+  if (!(layer in PSYCHE_LAYER_ICONS)) {
+    throw new SoulSurfaceError(`unsupported psyche layer: ${layer}`);
+  }
+  if (pyStrip(input.key) === "") throw new SoulSurfaceError("identity key must not be empty");
+  if (pyStrip(input.content) === "") {
+    throw new SoulSurfaceError("identity content must not be empty");
+  }
+
+  return renderSectionCard({
+    title: `${PSYCHE_LAYER_ICONS[layer]}  ${PSYCHE_LAYER_LABELS[layer]} IDENTITY UPDATED`,
+    sections: [
+      ["target", `${layer}/${pyStrip(input.key)}`],
+      ["applied", input.content],
+    ],
+    emptyError: "identity update requires content",
+  });
+}
+
+export function renderActiveRite(
+  voice: string,
+  input: {
+    utterance?: string | null;
+    /** Accepted and ignored, exactly as Python does — see the story handoff. */
+    listeningFor?: string | null;
+    question?: string | null;
+  } = {},
+): string {
+  const defaults = ACTIVE_RITE_DEFAULTS[voice];
+  if (!defaults) throw new SoulSurfaceError(`unsupported active rite voice: ${voice}`);
+
+  let utterance = input.utterance;
+  if (input.question && !utterance) utterance = input.question;
+  if ((voice === "wisdom" || voice === "beauty") && !utterance) {
+    throw new SoulSurfaceError(`${VOICE_LABELS[voice]} requires a situated --says response`);
+  }
+  const voiceSays = normalizeVoiceText(utterance || defaults.utterance);
+  if (voiceSays === "") {
+    throw new SoulSurfaceError("active rite voice utterance must not be empty");
+  }
+
+  const body: string[] = [line(""), line("   the voice says"), line("")];
+  for (const wrapped of wrapBlocks(voiceSays, "   ")) body.push(line(wrapped));
+  return card(`${VOICE_ICONS[voice]}  ${defaults.title}`, body);
+}