mirror-mind 0.0.1 → 0.33.0

package/ts/src/mirror/orchestration.ts

@@ -0,0 +1,364 @@
+import type { Database, WritableDatabase } from "#db/database.ts";
+import {
+  type CollectExtensionContextOptions,
+  collectExtensionContext,
+  type ExtensionContextDiagnostic,
+} from "#extensions/contextRuntime.ts";
+import { activateOperatingMode } from "#mode/operatingMode.ts";
+import type { OnProviderCallOutcome } from "#observability/callOutcome.ts";
+import { logLlmCall } from "#observability/llmCalls.ts";
+import { computeCost } from "#providers/cost.ts";
+import type { EmbeddingProvider } from "#providers/embedding.ts";
+import type { LlmProvider } from "#providers/llm.ts";
+import { loadMirrorContext } from "./context.ts";
+import { type ResolvedMirrorDefaults, resolveMirrorDefaults } from "./defaultResolution.ts";
+import { pythonTruthy, sliceCodePoints } from "./reception.ts";
+import {
+  renderJourneyDetected,
+  renderMirrorBanner,
+  renderMirrorJourneys,
+  renderMirrorModeTransition,
+} from "./render.ts";
+import {
+  decodeMetadata,
+  GLOBAL_STICKY_DEFAULTS_SESSION_ID,
+  getRuntimeSession,
+  resolveRuntimeSessionId,
+  upsertRuntimeSession,
+} from "./runtimeSession.ts";
+
+export interface MirrorLoadInput {
+  identity: string;
+  persona?: string | null;
+  journey?: string | null;
+  query?: string | null;
+  org?: boolean;
+  contextOnly?: boolean;
+  sessionId?: string | null;
+  environmentSessionId?: string | null;
+  receptionEnabled: boolean;
+  /**
+   * Reception's outcome, for the front-door log. `mirror load --query` is the
+   * per-activation surface: it swallows every failure into an empty context,
+   * so without this a provider outage, a prompt-layer parse failure, and a
+   * genuinely unclassifiable message all look like "no persona routed".
+   */
+  onReceptionOutcome?: OnProviderCallOutcome;
+  llmProvider?: LlmProvider;
+  embeddingProvider?: EmbeddingProvider;
+  databasePath?: string;
+  mirrorHome?: string;
+  user?: string;
+  extensionRuntime?: Pick<
+    CollectExtensionContextOptions,
+    "timeoutMs" | "maxOutputBytes" | "environment"
+  >;
+  newId: () => string;
+  nowIso: () => string;
+}
+
+export interface RenderedMirrorLoad {
+  stdout: string;
+  stderr: string;
+  resolved: ResolvedMirrorDefaults;
+  extensionDiagnostics: ExtensionContextDiagnostic[];
+}
+
+export async function runMirrorLoad(
+  db: WritableDatabase,
+  input: MirrorLoadInput,
+): Promise<RenderedMirrorLoad> {
+  const resolved = await resolveMirrorDefaults(db, {
+    ...input,
+    onReceptionOutcome: input.onReceptionOutcome,
+    // Priced, as Python's `build_llm_logger(role="reception")` prices it
+    // (CV22.DS8.US3). The row existed before but carried a null cost, so
+    // every Mirror Mode activation with a query would have logged live spend
+    // as free.
+    onReceptionLlmCall: (response, prompt) =>
+      logLlmCall(
+        db,
+        {
+          role: "reception",
+          model: response.model ?? "unknown",
+          prompt,
+          response: response.content,
+          promptTokens: response.promptTokens,
+          completionTokens: response.completionTokens,
+          latencyMs: response.latencyMs,
+          costUsd: computeCost(
+            response.model ?? "unknown",
+            response.promptTokens ?? null,
+            response.completionTokens ?? null,
+          ),
+          sessionId: input.sessionId ?? null,
+        },
+        { id: input.newId, now: input.nowIso },
+      ),
+  });
+  const extensionContext =
+    input.databasePath && input.mirrorHome
+      ? collectExtensionContext(db, {
+          mirrorHome: input.mirrorHome,
+          databasePath: input.databasePath,
+          personaId: resolved.persona,
+          journeyId: resolved.journey,
+          user: input.user ?? "",
+          query: input.query,
+          ...input.extensionRuntime,
+        })
+      : { rendered: "", diagnostics: [] };
+  const context = await loadMirrorContext(db, {
+    persona: resolved.persona,
+    journey: resolved.journey,
+    org: input.org,
+    query: input.query,
+    touchesIdentity: resolved.touchesIdentity,
+    touchesShadow: resolved.touchesShadow,
+    embeddingProvider: input.embeddingProvider,
+    extensionContext: extensionContext.rendered,
+  });
+  persistStickyDefaults(db, resolved.persona, resolved.journey, input.nowIso());
+  activateOperatingMode(db, { mode: "Mirror Mode", journey: resolved.journey }, input.nowIso());
+  writeMirrorState(
+    db,
+    {
+      active: true,
+      persona: resolved.persona,
+      journey: resolved.journey,
+      sessionId: input.sessionId ?? null,
+    },
+    input.nowIso(),
+  );
+  if (!input.contextOnly) {
+    bindConversationContext(
+      db,
+      input.sessionId ?? null,
+      input.environmentSessionId ?? null,
+      resolved.persona,
+      resolved.journey,
+      input.newId,
+      input.nowIso,
+    );
+  }
+  const personas = db
+    .prepare("SELECT key FROM identity WHERE layer = 'persona' ORDER BY key")
+    .all()
+    .map((row) => String(row.key));
+  const transition = renderMirrorModeTransition({
+    identity: input.identity,
+    journey: resolved.journey,
+    personas,
+  });
+  const detected = resolved.detectedJourney?.[0];
+  return {
+    stdout: `${transition}\n${context}\n`,
+    stderr: `${detected ? renderJourneyDetected(detected) : ""}${renderMirrorBanner(resolved.persona)}`,
+    resolved,
+    extensionDiagnostics: extensionContext.diagnostics,
+  };
+}
+
+export function deactivateMirrorState(
+  db: WritableDatabase,
+  sessionId: string,
+  nowIso: string,
+): void {
+  writeMirrorState(db, { active: false, sessionId }, nowIso);
+}
+
+export function logMirrorResponse(
+  db: WritableDatabase,
+  input: {
+    summary: string;
+    sessionId?: string | null;
+    environmentSessionId?: string | null;
+    muted: boolean;
+    newId: () => string;
+    nowIso: () => string;
+  },
+): void {
+  if (input.muted) return;
+  const sessionId = resolveRuntimeSessionId(
+    db,
+    input.sessionId ?? null,
+    input.environmentSessionId ?? null,
+  );
+  if (!sessionId) return;
+  const session = getRuntimeSession(db, sessionId);
+  const discarded = pythonTruthy(
+    decodeMetadata(session?.metadata ?? null).discard_current_conversation,
+  );
+  const conversationId = discarded
+    ? session?.conversationId &&
+      db.prepare("SELECT 1 FROM conversations WHERE id = ?").get(session.conversationId)
+      ? session.conversationId
+      : null
+    : getOrCreateConversation(db, sessionId, input.newId, input.nowIso);
+  if (!conversationId) return;
+  if (!discarded) {
+    db.prepare(
+      `INSERT INTO messages (id, conversation_id, role, content, created_at, token_count, metadata)
+       VALUES (?, ?, 'assistant', ?, ?, NULL, NULL)`,
+    ).run(input.newId(), conversationId, input.summary, input.nowIso());
+  }
+  db.prepare("UPDATE conversations SET title = ? WHERE id = ?").run(
+    titleFromSummary(input.summary),
+    conversationId,
+  );
+}
+
+export function listActiveMirrorJourneys(db: Database): string {
+  const rows = db
+    .prepare("SELECT key, content FROM identity WHERE layer = 'journey' ORDER BY key")
+    .all()
+    .map((row) => journeyDto(String(row.key), typeof row.content === "string" ? row.content : ""))
+    .filter((row) => row.status === "active");
+  return renderMirrorJourneys(rows);
+}
+
+export function titleFromSummary(summary: string): string {
+  let title = summary.split(/[.!?]/, 1)[0]?.trim() ?? "";
+  if ([...title].length > 60) {
+    const prefix = [...title].slice(0, 60).join("");
+    const space = prefix.lastIndexOf(" ");
+    title = `${space >= 0 ? prefix.slice(0, space) : prefix}...`;
+  }
+  return title;
+}
+
+/**
+ * Port of `_persist_global_sticky_defaults`. Exported for `soul load`, which
+ * calls the same writer with `persona=None` (CV22.DS7.US6).
+ */
+export function persistStickyDefaults(
+  db: WritableDatabase,
+  persona: string | null,
+  journey: string | null,
+  nowIso: string,
+): void {
+  if (persona === null && journey === null) return;
+  upsertRuntimeSession(
+    db,
+    GLOBAL_STICKY_DEFAULTS_SESSION_ID,
+    {
+      interface: "global_defaults",
+      mirrorActive: false,
+      ...(persona !== null ? { persona } : {}),
+      ...(journey !== null ? { journey } : {}),
+      hookInjected: true,
+      active: false,
+    },
+    nowIso,
+  );
+}
+
+function writeMirrorState(
+  db: WritableDatabase,
+  input: {
+    active: boolean;
+    persona?: string | null;
+    journey?: string | null;
+    sessionId: string | null;
+  },
+  nowIso: string,
+): void {
+  if (!input.sessionId) return;
+  upsertRuntimeSession(
+    db,
+    input.sessionId,
+    {
+      mirrorActive: input.active,
+      ...(input.persona !== undefined && input.persona !== null ? { persona: input.persona } : {}),
+      ...(input.journey !== undefined && input.journey !== null ? { journey: input.journey } : {}),
+      hookInjected: !input.active,
+    },
+    nowIso,
+  );
+}
+
+function bindConversationContext(
+  db: WritableDatabase,
+  explicitSessionId: string | null,
+  environmentSessionId: string | null,
+  persona: string | null,
+  journey: string | null,
+  newId: () => string,
+  nowIso: () => string,
+): string | null {
+  const sessionId = resolveRuntimeSessionId(db, explicitSessionId, environmentSessionId);
+  if (!sessionId) return null;
+  const session = getRuntimeSession(db, sessionId);
+  const existing = session?.conversationId
+    ? db.prepare("SELECT id, ended_at FROM conversations WHERE id = ?").get(session.conversationId)
+    : undefined;
+  let conversationId: string;
+  if (existing && existing.ended_at === null) {
+    conversationId = String(existing.id);
+    db.prepare("UPDATE conversations SET persona = ?, journey = ? WHERE id = ?").run(
+      persona,
+      journey,
+      conversationId,
+    );
+  } else {
+    conversationId = newId();
+    db.prepare(
+      `INSERT INTO conversations
+        (id, title, started_at, ended_at, interface, persona, journey, summary, tags, metadata)
+       VALUES (?, NULL, ?, NULL, ?, ?, ?, NULL, NULL, NULL)`,
+    ).run(conversationId, nowIso(), session?.interface ?? "claude_code", persona, journey);
+  }
+  upsertRuntimeSession(
+    db,
+    sessionId,
+    {
+      conversationId,
+      interface: session?.interface ?? "claude_code",
+      ...(persona !== null ? { persona } : {}),
+      ...(journey !== null ? { journey } : {}),
+      active: true,
+      closedAt: null,
+    },
+    nowIso(),
+  );
+  return conversationId;
+}
+
+function getOrCreateConversation(
+  db: WritableDatabase,
+  sessionId: string,
+  newId: () => string,
+  nowIso: () => string,
+): string {
+  const session = getRuntimeSession(db, sessionId);
+  if (session?.conversationId) {
+    const existing = db
+      .prepare("SELECT id FROM conversations WHERE id = ?")
+      .get(session.conversationId);
+    if (existing) return String(existing.id);
+  }
+  const id = newId();
+  const now = nowIso();
+  const interfaceName = session?.interface ?? "claude_code";
+  db.prepare(
+    `INSERT INTO conversations
+      (id, title, started_at, ended_at, interface, persona, journey, summary, tags, metadata)
+     VALUES (?, NULL, ?, NULL, ?, ?, ?, NULL, NULL, NULL)`,
+  ).run(id, now, interfaceName, session?.persona ?? null, session?.journey ?? null);
+  upsertRuntimeSession(
+    db,
+    sessionId,
+    { conversationId: id, interface: interfaceName, active: true, closedAt: null },
+    now,
+  );
+  return id;
+}
+
+function journeyDto(id: string, content: string) {
+  const name = (content.split("\n")[0] ?? "").trim().replace(/^[# ]+/, "");
+  const status = content.match(/\*\*Status:\*\*\s*([\p{L}\p{N}_]+)/u)?.[1] ?? "unknown";
+  const description =
+    content.match(/## (?:Description|Descrição)\s*\n+(.+?)(?:\n\n|\n##)/s)?.[1]?.trim() ?? "";
+  const truncatedDescription = sliceCodePoints(description, 150);
+  return { id, name, description: truncatedDescription, status };
+}

package/ts/src/mirror/reception.ts

@@ -0,0 +1,194 @@
+import { parseJsonResponse } from "#extraction/json.ts";
+import { classifyProviderError, type OnProviderCallOutcome } from "#observability/callOutcome.ts";
+import type { LlmProvider, LlmResponse } from "#providers/llm.ts";
+import { pyFormat } from "#util/pythonText.ts";
+
+export interface ReceptionPersona {
+  slug: string;
+  description: string;
+  routingKeywords: readonly string[];
+}
+
+export interface ReceptionJourney {
+  slug: string;
+  description: string;
+}
+
+export interface ReceptionResult {
+  personas: string[];
+  journey: string | null;
+  touchesIdentity: boolean;
+  touchesShadow: boolean;
+}
+
+export const EMPTY_RECEPTION_RESULT: ReceptionResult = Object.freeze({
+  personas: [],
+  journey: null,
+  touchesIdentity: false,
+  touchesShadow: false,
+});
+
+/**
+ * Byte-identical to Python's `RECEPTION_PROMPT`, doubled braces included.
+ *
+ * The braces are not cosmetic. Python substitutes through `str.format`, which
+ * requires `{{` to emit a literal `{`, so the JSON example in the response
+ * format section is doubled at the source. Holding the same bytes here means
+ * the template can be compared to the oracle directly, and it forces assembly
+ * through `pyFormat` -- which is the point: `String.replace()` with a string
+ * pattern treats `$&`, `` $` ``, `$'`, and `$1` in the REPLACEMENT as
+ * substitution directives, so a persona described as "Cost: $& per hour"
+ * assembled as "Cost: {personas} per hour" (CV22.DS8.US3). Python's `format`
+ * has no such behavior, no fixture ever carried a `$` pattern, and replay
+ * never reads a prompt -- so only a live call would have shown it.
+ */
+export const RECEPTION_PROMPT = `You are the reception classifier for Mirror Mind, a Jungian mirror AI.
+
+Your job is to classify a single user message on four axes so the mirror can
+compose the right context for its response. Read the message carefully, then
+return a JSON object — nothing else.
+
+## Available personas
+{personas}
+
+## Active journeys
+{journeys}
+
+## Classification rules
+
+**personas** (array of slugs, ordered most-to-least relevant, or [] if none apply)
+- Return the personas whose domain clearly covers this message.
+- Action verbs dominate topic: "write a post about X" → writer, not the X-domain persona.
+- When a single persona's domain covers the message, return only that one.
+- When genuinely ambiguous, return the most relevant one only.
+- Return [] when the ego should answer alone (open questions, general curiosity,
+  meta questions about the mirror itself).
+
+**journey** (slug string or null)
+- Return the slug whose description best matches the context of this message.
+- Conservative: prefer null over a speculative match.
+- Return null if no journey is clearly relevant.
+
+**touches_identity** (boolean)
+- true ONLY when the message explicitly invites reflection on personal values,
+  life purpose, meaning, or deep self-examination.
+- Operational and technical questions are false even if they involve important decisions.
+- Default false. The cost of missing a touch is a lighter context load;
+  the cost of over-triggering is token waste on every routine turn.
+
+**touches_shadow** (boolean)
+- true ONLY when there is explicit evidence of avoidance, internal contradiction,
+  or a recurring pattern the user is naming or circling around.
+- Requires positive signal. Vague discomfort or uncertainty alone is false.
+- Default false. Conservative by design.
+
+## Response format
+Return ONLY a JSON object, no markdown:
+{{
+  "personas": ["slug", ...],
+  "journey": "slug" or null,
+  "touches_identity": true or false,
+  "touches_shadow": true or false
+}}
+
+## User message
+`;
+
+export async function runReception(
+  query: string,
+  personas: readonly ReceptionPersona[],
+  journeys: readonly ReceptionJourney[],
+  provider: LlmProvider,
+  onLlmCall?: (response: LlmResponse, prompt: string) => void,
+  onOutcome?: OnProviderCallOutcome,
+): Promise<ReceptionResult> {
+  if (!query.trim()) return { ...EMPTY_RECEPTION_RESULT, personas: [] };
+  const prompt = buildReceptionPrompt(query, personas, journeys);
+  try {
+    const response = await provider.complete({ role: "reception", prompt, temperature: 0.1 });
+    onLlmCall?.(response, prompt);
+    const parsed = parseJsonResponse(response.content);
+    if (!isRecord(parsed)) {
+      // The classifier answered with something the parser could not use. The
+      // result is the same empty context as a provider outage, and the cause
+      // is not: this one is prompt-layer, and it was paid for.
+      onOutcome?.({ outcome: "parse_failed" });
+      return { ...EMPTY_RECEPTION_RESULT, personas: [] };
+    }
+    const personasOut = Array.isArray(parsed.personas)
+      ? parsed.personas.filter((item): item is string => typeof item === "string")
+      : [];
+    const result = {
+      personas: personasOut,
+      journey: typeof parsed.journey === "string" ? parsed.journey : null,
+      touchesIdentity: pythonTruthy(parsed.touches_identity),
+      touchesShadow: pythonTruthy(parsed.touches_shadow),
+    };
+    const carriedSignal =
+      result.personas.length > 0 ||
+      result.journey !== null ||
+      result.touchesIdentity ||
+      result.touchesShadow;
+    onOutcome?.({ outcome: carriedSignal ? "answered" : "empty" });
+    return result;
+  } catch (error) {
+    onOutcome?.({ outcome: "transport_failed", kind: classifyProviderError(error) });
+    return { ...EMPTY_RECEPTION_RESULT, personas: [] };
+  }
+}
+
+/**
+ * Python's assembled reception prompt: the formatted template, then the raw
+ * query appended after the `## User message` heading.
+ *
+ * Pure and exported so the assembled BYTES can be graded against the oracle
+ * corpus without a provider (CV22.DS8.US3). Replay resolves a fixture by role
+ * alone and never reads the prompt, so a drift here would have surfaced first
+ * against a real model.
+ */
+export function buildReceptionPrompt(
+  query: string,
+  personas: readonly ReceptionPersona[],
+  journeys: readonly ReceptionJourney[],
+): string {
+  return (
+    pyFormat(RECEPTION_PROMPT, {
+      personas: formatPersonas(personas),
+      journeys: formatJourneys(journeys),
+    }) + query
+  );
+}
+
+export function formatPersonas(personas: readonly ReceptionPersona[]): string {
+  if (personas.length === 0) return "(none available)";
+  return personas
+    .map((persona) => {
+      const keywords = persona.routingKeywords.slice(0, 6);
+      const suffix = keywords.length > 0 ? ` [keywords: ${keywords.join(", ")}]` : "";
+      return `- ${persona.slug}: ${sliceCodePoints(persona.description, 120)}${suffix}`;
+    })
+    .join("\n");
+}
+
+export function formatJourneys(journeys: readonly ReceptionJourney[]): string {
+  if (journeys.length === 0) return "(none available)";
+  return journeys
+    .map((journey) => `- ${journey.slug}: ${sliceCodePoints(journey.description, 120)}`)
+    .join("\n");
+}
+
+export function sliceCodePoints(value: string, limit: number): string {
+  return [...value].slice(0, limit).join("");
+}
+
+export function pythonTruthy(value: unknown): boolean {
+  if (value === null || value === undefined || value === false) return false;
+  if (typeof value === "number") return value !== 0;
+  if (typeof value === "string" || Array.isArray(value)) return value.length > 0;
+  if (typeof value === "object") return Object.keys(value).length > 0;
+  return true;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/ts/src/mirror/render.ts

@@ -0,0 +1,75 @@
+const WIDTH = 56;
+
+export function renderMirrorModeTransition(input: {
+  identity: string;
+  journey?: string | null;
+  personas?: readonly string[];
+}): string {
+  const rows: [string, string][] = [["identity", input.identity]];
+  if (input.journey) rows.push(["active journey", input.journey]);
+  rows.push([
+    "what this mode is",
+    "Identity lens. Mirror reflects from memory, values, journeys, tensions, and personas.",
+  ]);
+  rows.push(["persona routing", personaRoutingLine([...(input.personas ?? [])].sort())]);
+  rows.push(["available lenses", "◌ Mirror Mode · ■ Builder Mode · △ Explorer Mode · ☾ Soul Mode"]);
+  return box("◌  MIRROR MODE ACTIVE", rows);
+}
+
+export function renderMirrorBanner(persona: string | null): string {
+  const first = "\u001b[38;5;183m⏺ Mirror Mode active\u001b[0m\n";
+  return persona
+    ? `${first}\u001b[38;5;183m  ✦ Persona: ${persona}\u001b[0m\n`
+    : `${first}\u001b[38;5;183m  Ego responding without persona\u001b[0m\n`;
+}
+
+export function renderJourneyDetected(match: [string, number, string]): string {
+  return `\u001b[38;5;183m  🧭 Journey detected: ${match[0]} (${match[2]}, score: ${match[1].toFixed(2)})\u001b[0m\n`;
+}
+
+export function renderMirrorJourneys(
+  journeys: readonly { id: string; name: string; description: string }[],
+): string {
+  return journeys
+    .map((journey) => `- **${journey.id}** — ${journey.name}: ${journey.description}\n`)
+    .join("");
+}
+
+function personaRoutingLine(personas: string[]): string {
+  if (personas.length === 0) return "when the topic asks: personas route naturally";
+  const shown = personas.slice(0, 3);
+  const remaining = personas.length - shown.length;
+  return `when the topic asks: ${shown.join(", ")}${remaining > 0 ? ` and ${remaining} more available` : ""}`;
+}
+
+function box(title: string, rows: readonly [string, string][]): string {
+  const lines = ["Mirror", `╭${"─".repeat(WIDTH)}╮`, line(`        ${title}`)];
+  for (const [label, value] of rows) {
+    lines.push(line(""));
+    lines.push(line(`  ${label}`));
+    for (const wrapped of wrap(value)) lines.push(line(`  ${wrapped}`));
+  }
+  lines.push(`╰${"─".repeat(WIDTH)}╯`);
+  return lines.join("\n");
+}
+
+function line(text: string): string {
+  const content = [...text].slice(0, WIDTH).join("");
+  return `│${content}${" ".repeat(Math.max(0, WIDTH - [...content].length))}│`;
+}
+
+function wrap(text: string): string[] {
+  const words = text.split(/\s+/).filter(Boolean);
+  if (words.length === 0) return [""];
+  const lines: string[] = [];
+  let current = words[0] ?? "";
+  for (const word of words.slice(1)) {
+    if ([...current].length + [...word].length + 1 <= WIDTH - 2) current += ` ${word}`;
+    else {
+      lines.push(current);
+      current = word;
+    }
+  }
+  lines.push(current);
+  return lines;
+}