mirror-mind 0.0.1 → 0.33.0

package/ts/src/frontDoor/render/inspectPersona.ts

@@ -0,0 +1,53 @@
+// `inspect persona <id>` rendering — the port of memory.cli.inspect._inspect_persona.
+
+import type { Database } from "#db/database.ts";
+import { getPersonaInspect } from "#identity/personaInspect.ts";
+
+/** Raised when no persona identity row exists for the id. Python prints this to
+ * STDOUT (not stderr) before exit(1) — a deliberate divergence from `identity get`. */
+export class PersonaNotFoundError extends Error {
+  readonly personaId: string;
+  constructor(personaId: string) {
+    super(`persona/${personaId} not found`);
+    this.personaId = personaId;
+  }
+}
+
+/** Fixed key order the Python source iterates, printing only present (non-null) values. */
+const METADATA_KEYS = [
+  "persona_id",
+  "name",
+  "inherits_from",
+  "description",
+  "default_model",
+] as const;
+
+/** Render `inspect persona <id>`, or throw PersonaNotFoundError when absent. */
+export function renderInspectPersona(db: Database, personaId: string): string {
+  const row = getPersonaInspect(db, personaId);
+  if (!row) throw new PersonaNotFoundError(personaId);
+
+  const prints: string[] = [
+    `=== persona/${personaId} ===`,
+    `version: ${row.version}`,
+    `updated_at: ${row.updatedAt}`,
+    "metadata:",
+  ];
+  const metadataKeys = Object.keys(row.metadata);
+  if (metadataKeys.length > 0) {
+    for (const key of METADATA_KEYS) {
+      const value = row.metadata[key];
+      if (value !== undefined && value !== null) prints.push(`  ${key}: ${value}`);
+    }
+    const rawKeywords = row.metadata.routing_keywords;
+    const keywords = Array.isArray(rawKeywords)
+      ? rawKeywords.filter((item): item is string => typeof item === "string")
+      : [];
+    prints.push(`  routing_keywords: ${keywords.length > 0 ? keywords.join(", ") : "(none)"}`);
+  } else {
+    prints.push("  (none)");
+  }
+  prints.push("\ncontent:\n");
+  prints.push(row.content);
+  return prints.map((line) => `${line}\n`).join("");
+}

package/ts/src/frontDoor/render/journeyStatus.ts

@@ -0,0 +1,78 @@
+// `journey status` rendering — the port of memory.cli.journey.cmd_status and
+// main()'s positional-argument dispatch quirk.
+
+import type { Database } from "#db/database.ts";
+import {
+  allJourneyKeys,
+  getJourneyStatusEntries,
+  type JourneyStatusEntry,
+  type ReadTextFile,
+} from "#journey/journeyStatus.ts";
+
+/**
+ * Port of the slug-resolution branch in `journey.main()`. This reproduces a
+ * real, verified Python quirk rather than the "obvious" reading: only
+ * `remaining.length >= 2 && remaining[0] === "status"` treats `remaining[1]`
+ * as the slug. A bare `["status"]` (length 1, nothing after it) falls through
+ * to the generic `remaining[0] if remaining else None` branch — so the
+ * literal token "status" itself becomes the requested journey slug, NOT a
+ * request to show every journey. To see every journey, the caller must pass
+ * no positional tokens at all. Verified against the live oracle.
+ */
+export function resolveJourneyStatusSlug(remaining: readonly string[]): string | null {
+  if (remaining.length >= 2 && remaining[0] === "status") return remaining[1];
+  return remaining.length > 0 ? remaining[0] : null;
+}
+
+/** Render one journey's status block (identity / journey path / memories / conversations). */
+function renderJourneyStatusEntry(entry: JourneyStatusEntry): string[] {
+  const prints: string[] = [`=== journey: ${entry.journeyId} ===`];
+  if (entry.identity) {
+    prints.push("\n--- identity ---");
+    prints.push(entry.identity);
+  }
+  if (entry.journeyPath) {
+    prints.push("\n--- journey path ---");
+    prints.push(entry.journeyPath);
+  }
+  if (entry.recentMemories.length > 0) {
+    prints.push(`\n--- recent memories (${entry.recentMemories.length}) ---`);
+    for (const memory of entry.recentMemories) {
+      prints.push(`  [${memory.created_at.slice(0, 10)}] ${memory.title}`);
+    }
+  } else {
+    prints.push("\n--- recent memories ---");
+    prints.push("  No recent memories.");
+  }
+  if (entry.recentConversations.length > 0) {
+    prints.push(`\n--- recent conversations (${entry.recentConversations.length}) ---`);
+    for (const conversation of entry.recentConversations) {
+      prints.push(
+        `  [${conversation.started_at.slice(0, 10)}] ${conversation.title || "(untitled)"}`,
+      );
+    }
+  } else {
+    prints.push("\n--- recent conversations ---");
+    prints.push("  No recent conversations.");
+  }
+  prints.push("");
+  return prints;
+}
+
+/**
+ * Render `journey status` for a resolved slug (or every journey when `slug`
+ * is null). A non-existent slug is NOT an error — it renders an
+ * identity-less, path-less, empty-history block, matching the Python oracle
+ * (`get_journey_status` never validates the slug exists).
+ */
+export function renderJourneyStatus(
+  db: Database,
+  slug: string | null,
+  readTextFile?: ReadTextFile,
+): string {
+  const keys = slug !== null ? [slug] : allJourneyKeys(db);
+  const entries = getJourneyStatusEntries(db, keys, readTextFile);
+  const prints: string[] = [];
+  for (const entry of entries) prints.push(...renderJourneyStatusEntry(entry));
+  return prints.map((line) => `${line}\n`).join("");
+}

package/ts/src/frontDoor/render/journeys.ts

@@ -0,0 +1,79 @@
+// `journeys` rendering: read journey options, enrich with stage/description,
+// format the bounded depth-first hierarchy. Extracted from cli.ts (CR002).
+
+import type { Database } from "#db/database.ts";
+import { optionalString, requireString } from "#db/rowDecode.ts";
+import {
+  type JourneyIdentityRow,
+  type JourneyOption,
+  listJourneyOptions,
+} from "#journey/journeyOptions.ts";
+import { identityRows } from "./identityRows.ts";
+
+/** A journey option enriched with the display-only stage and description. */
+export interface JourneyDisplayRow extends JourneyOption {
+  stage: string;
+  description: string;
+}
+
+const STATUS_ICONS: Record<string, string> = { active: "🚧", completed: "✅", paused: "⏸" };
+
+/** Read the `content` column of an identity layer keyed by identity key. */
+function contentByKey(db: Database, layer: string): Map<string, string> {
+  return new Map(
+    identityRows(db, layer).map((row) => [
+      requireString(row, "key"),
+      optionalString(row, "content") ?? "",
+    ]),
+  );
+}
+
+/**
+ * Read journeys and enrich each with its stage (from journey_path) and
+ * description. Two queries total (journey + journey_path layers), not the
+ * former 1 + 2N: the journey content is loaded once into a map and the stage
+ * layer once, instead of a per-journey pair of lookups.
+ */
+export function journeyRows(db: Database): JourneyDisplayRow[] {
+  const journeyContent = contentByKey(db, "journey");
+  const stageContent = contentByKey(db, "journey_path");
+  const identityForOptions: JourneyIdentityRow[] = identityRows(db, "journey").map((row) => ({
+    key: requireString(row, "key"),
+    content: optionalString(row, "content") ?? "",
+    metadata: optionalString(row, "metadata"),
+    parent_journey: optionalString(row, "parent_journey"),
+  }));
+  return listJourneyOptions(identityForOptions).map((option) => {
+    const desc = (journeyContent.get(option.id) ?? "")
+      .split("\n")
+      .map((line) => line.trim())
+      .find((line) => line && !line.startsWith("#") && !line.startsWith("**"));
+    const stage =
+      (stageContent.get(option.id) ?? "")
+        .match(/\*\*(?:Current stage|Etapa atual):\*\*\s*(.+)/)?.[1]
+        ?.trim() ?? "—";
+    return { ...option, stage, description: (desc ?? "").slice(0, 80) };
+  });
+}
+
+/** Format one journey at its projected depth into display lines. */
+export function renderJourney(row: JourneyDisplayRow): string[] {
+  const icon = STATUS_ICONS[row.status] ?? "•";
+  const connector = "│  ".repeat(row.depth);
+  const prefix = row.depth > 0 ? `${connector}└─ ` : "";
+  const detailIndent = row.depth > 0 ? `${connector}  ` : "  ";
+  const lines = [
+    `${prefix}${icon} **${row.id}** (${row.status})`,
+    `${detailIndent}Stage: ${row.stage}`,
+  ];
+  if (row.description) lines.push(`${detailIndent}${row.description}`);
+  lines.push("");
+  return lines;
+}
+
+/** Render the full bounded depth-first `journeys` listing. */
+export function renderJourneys(db: Database): string {
+  const rows = journeyRows(db);
+  if (rows.length === 0) return "No journeys found.\n";
+  return rows.flatMap((row) => renderJourney(row)).join("\n");
+}

package/ts/src/frontDoor/render/list.ts

@@ -0,0 +1,41 @@
+// `list personas` / `list journeys` rendering — the port of the personas/journeys
+// branches of memory.cli.inspect.cmd_list. `list extensions`/`list all` touch the
+// extension catalog and stay on Python (bound to CV22.DS7.TS1).
+
+import type { JourneyListRow } from "#identity/journeyListing.ts";
+import type { PersonaListRow } from "#identity/personaListing.ts";
+
+/** Render `list personas` (and the personas branch of `--verbose`). */
+export function renderListPersonas(rows: PersonaListRow[], verbose: boolean): string {
+  const prints: string[] = ["=== PERSONAS ==="];
+  if (rows.length === 0) {
+    prints.push("  (none)");
+  } else {
+    for (const row of rows) {
+      if (!verbose) {
+        prints.push(`  ${row.key}`);
+        continue;
+      }
+      const keywordsStr =
+        row.routingKeywords.length > 0 ? row.routingKeywords.join(", ") : "(none)";
+      prints.push(`  ${row.key}`);
+      prints.push(`    version: ${row.version}`);
+      prints.push(`    routing_keywords: ${keywordsStr}`);
+    }
+  }
+  return prints.map((line) => `${line}\n`).join("");
+}
+
+/** Render `list journeys`. */
+export function renderListJourneys(rows: JourneyListRow[]): string {
+  const prints: string[] = ["=== JOURNEYS ==="];
+  if (rows.length === 0) {
+    prints.push("  (none)");
+  } else {
+    for (const row of rows) {
+      const suffix = row.description ? `: ${row.description}` : "";
+      prints.push(`  [${row.status}] ${row.key}${suffix}`);
+    }
+  }
+  return prints.map((line) => `${line}\n`).join("");
+}

package/ts/src/frontDoor/render/memories.ts

@@ -0,0 +1,67 @@
+// `memories` rendering: read recent summaries, format rows and the
+// count-by-type header. Extracted from cli.ts (CR002).
+
+import type { Database } from "#db/database.ts";
+import { hasOption, optionValue } from "#frontDoor/args.ts";
+import {
+  countMemoriesByType,
+  type ListRecentFilters,
+  listRecentMemorySummaries,
+  type MemorySummary,
+} from "#memory/listing.ts";
+import { ICONS } from "./icons.ts";
+
+/** Format a JSON tags string into a comma-joined list, or "" when absent/malformed. */
+export function tagsText(tags: string | null): string {
+  if (!tags) return "";
+  try {
+    const parsed = JSON.parse(tags) as unknown;
+    return Array.isArray(parsed)
+      ? parsed.filter((item) => typeof item === "string").join(", ")
+      : "";
+  } catch {
+    return "";
+  }
+}
+
+/** Format one memory summary into display lines. */
+export function renderMemoryRow(memory: MemorySummary): string[] {
+  const icon = ICONS[memory.memory_type] ?? "•";
+  const date = memory.created_at ? memory.created_at.slice(0, 10) : "?";
+  const journey = memory.journey ? ` 🧭 ${memory.journey}` : "";
+  const persona = memory.persona ? ` ◇ ${memory.persona}` : "";
+  const tags = tagsText(memory.tags);
+  const lines = [
+    `${icon} **${memory.title}**`,
+    `  ${date} | \`${memory.id.slice(0, 8)}\` | ${memory.memory_type} [${memory.layer}]${journey}${persona}`,
+    `  ${memory.content.slice(0, 200)}`,
+  ];
+  if (tags) lines.push(`  🏷 ${tags}`);
+  lines.push("");
+  return lines;
+}
+
+/** Render the `memories` listing. Throws on `--search` (that route stays on Python). */
+export function renderMemories(db: Database, args: readonly string[]): string {
+  if (hasOption(args, "--search")) throw new Error("search route must fallback to Python");
+  const filters: ListRecentFilters = {
+    limit: Number(optionValue(args, "--limit") ?? 20),
+    memoryType: optionValue(args, "--type"),
+    layer: optionValue(args, "--layer"),
+    journey: optionValue(args, "--journey"),
+  };
+  const memories = listRecentMemorySummaries(db, filters);
+  if (memories.length === 0) return "No memories found.\n";
+  const filterParts = [];
+  if (filters.memoryType) filterParts.push(`type=${filters.memoryType}`);
+  if (filters.layer) filterParts.push(`layer=${filters.layer}`);
+  if (filters.journey) filterParts.push(`journey=${filters.journey}`);
+  const filterText = filterParts.length ? ` (${filterParts.join(", ")})` : "";
+  const totals = countMemoriesByType(db)
+    .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+    .map(([type, count]) => `${ICONS[type] ?? "•"} ${type}: ${count}`)
+    .join(" | ");
+  const lines = [`📦 Memories${filterText} — ${memories.length} shown`, totals, ""];
+  for (const memory of memories) lines.push(...renderMemoryRow(memory));
+  return lines.join("\n");
+}

package/ts/src/frontDoor/render/recall.ts

@@ -0,0 +1,49 @@
+// `recall <conv_id>` rendering — the port of memory.cli.recall.main.
+
+import {
+  findConversationByIdPrefix,
+  getMessagesForConversation,
+  pythonTailSliceStart,
+} from "#conversation/recall.ts";
+import type { Database } from "#db/database.ts";
+
+/** Raised when no conversation matches the id prefix. Python prints this to stderr, exit 1. */
+export class ConversationNotFoundError extends Error {
+  readonly convId: string;
+  constructor(convId: string) {
+    super(`Conversation '${convId}' not found.`);
+    this.convId = convId;
+  }
+}
+
+/** Render `recall <conv_id> [--limit N]`, or throw ConversationNotFoundError. */
+export function renderRecall(db: Database, convId: string, limit: number): string {
+  const conv = findConversationByIdPrefix(db, convId);
+  if (!conv) throw new ConversationNotFoundError(convId);
+
+  const prints: string[] = [
+    `# Conversation: ${conv.title || "(untitled)"}`,
+    `**Date:** ${conv.started_at ? conv.started_at.slice(0, 10) : "?"}`,
+  ];
+  if (conv.persona) prints.push(`**Persona:** ${conv.persona}`);
+  if (conv.journey) prints.push(`**Journey:** ${conv.journey}`);
+  prints.push(`**ID:** \`${conv.id}\``);
+  if (conv.summary) {
+    prints.push("");
+    prints.push(`**Summary:** ${conv.summary}`);
+  }
+  prints.push("", "---", "");
+
+  const messages = getMessagesForConversation(db, conv.id);
+  if (messages.length === 0) {
+    prints.push("(conversation has no messages)");
+    return prints.map((line) => `${line}\n`).join("");
+  }
+  const start = pythonTailSliceStart(messages.length, limit);
+  for (const msg of messages.slice(start)) {
+    prints.push(msg.role === "user" ? "**User:**" : "**Mirror:**");
+    prints.push(msg.content);
+    prints.push("");
+  }
+  return prints.map((line) => `${line}\n`).join("");
+}

package/ts/src/frontDoor/render/shadow.ts

@@ -0,0 +1,155 @@
+// `shadow` command rendering (CV22.DS7.US3) -- the port of
+// `cli/shadow_cmd.py`'s print statements. See `consolidate.ts`'s module doc
+// for the shared rendering philosophy and blank-line idiom.
+
+import type { ConsolidationRow } from "#cultivation/consolidationStore.ts";
+import type { ShadowScanResult } from "#cultivation/scan.ts";
+import type { RejectOutcome, ShadowApplyRouteOutcome } from "#frontDoor/cultivationRoute.ts";
+import { PROGRAM } from "#util/program.ts";
+import type { RenderedCommand } from "./consolidate.ts";
+import { renderAlreadyReviewed, renderProposalNotFound } from "./cultivationShared.ts";
+
+const STATUS_ICON: Record<string, string> = {
+  pending: "⏳",
+  accepted: "✓",
+  rejected: "✗",
+};
+
+function sourceIds(sourceMemoryIds: string): string[] {
+  const parsed: unknown = sourceMemoryIds ? JSON.parse(sourceMemoryIds) : [];
+  return Array.isArray(parsed) ? parsed.map((value) => String(value)) : [];
+}
+
+/** Port of `shadow list`'s `cmd_list` -- callers pre-filter to `action === 'shadow_observation'`. */
+export function renderShadowList(
+  items: readonly ConsolidationRow[],
+  status: string | null,
+): string {
+  if (items.length === 0) {
+    const label = status ? ` (${status})` : "";
+    return `No shadow observations found${label}.\n`;
+  }
+  const lines: string[] = [];
+  for (const c of items) {
+    const st = STATUS_ICON[c.status] ?? "?";
+    const date = c.created_at.slice(0, 10);
+    const count = sourceIds(c.source_memory_ids).length;
+    lines.push(
+      `${st} [${c.id.slice(0, 8)}] ${date}  🌑 ${c.rationale || "shadow observation"}  (${count} memories)`,
+    );
+  }
+  return lines.map((line) => `${line}\n`).join("");
+}
+
+/** Port of `shadow show`'s `cmd_show`. */
+export function renderShadowShow(entries: readonly { key: string; content: string }[]): string {
+  if (entries.length === 0) {
+    return (
+      "The structural shadow layer is empty.\n" +
+      `Run '${PROGRAM} shadow scan' to surface candidate observations.\n`
+    );
+  }
+  const lines: string[] = [`Shadow layer (${entries.length} entries):`, ""];
+  for (const entry of entries) {
+    lines.push(`=== shadow/${entry.key} ===`);
+    lines.push(entry.content);
+    lines.push("");
+  }
+  return lines.map((line) => `${line}\n`).join("");
+}
+
+/** Port of `shadow reject`'s success message; not-found/already-reviewed are shared. */
+export function renderShadowRejected(consolidation: ConsolidationRow): string {
+  return `Proposal [${consolidation.id.slice(0, 8)}] rejected. Shadow layer unchanged.\n`;
+}
+
+/** Port of `shadow reject`'s full output (not_found/already_reviewed shared, success family-specific). */
+export function renderShadowReject(outcome: RejectOutcome): RenderedCommand {
+  if (outcome.kind === "not_found") {
+    return { text: renderProposalNotFound(outcome.proposalId), stderr: true, exitCode: 1 };
+  }
+  if (outcome.kind === "already_reviewed") {
+    return { text: renderAlreadyReviewed(outcome.consolidation), stderr: false, exitCode: 0 };
+  }
+  return { text: renderShadowRejected(outcome.consolidation), stderr: false, exitCode: 0 };
+}
+
+/** Port of `shadow apply`'s full output. */
+export function renderShadowApply(outcome: ShadowApplyRouteOutcome): RenderedCommand {
+  if (outcome.kind === "not_found") {
+    return { text: renderProposalNotFound(outcome.proposalId), stderr: true, exitCode: 1 };
+  }
+  if (outcome.kind === "already_reviewed") {
+    return { text: renderAlreadyReviewed(outcome.consolidation), stderr: false, exitCode: 0 };
+  }
+  if (outcome.kind === "wrong_action") {
+    const { id, action } = outcome.consolidation;
+    return {
+      text: `Error: [${id.slice(0, 8)}] has action='${action}'. Use mm-consolidate for non-shadow proposals.\n`,
+      stderr: true,
+      exitCode: 1,
+    };
+  }
+  // outcome.kind === "applied"
+  let text = `✓ Shadow layer updated: shadow/${outcome.targetKey}\n`;
+  if (outcome.sourceMemoryIds.length > 0) {
+    text += `  ${outcome.sourceMemoryIds.length} source memories advanced to 'acknowledged'.\n`;
+  }
+  text += `\nProposal [${outcome.consolidation.id.slice(0, 8)}] accepted and recorded with provenance.\n`;
+  return { text, stderr: false, exitCode: 0 };
+}
+
+const BAR = "─".repeat(60);
+
+/** Port of `_print_proposal` in `shadow_cmd.py` (the scan-time observation card) -- DIFFERENT shape from consolidate's. */
+function formatObservationBlock(proposal: ConsolidationRow, index: number, total: number): string {
+  const ids = sourceIds(proposal.source_memory_ids);
+  let out = `\n${BAR}\n`;
+  out += `Observation ${index}/${total}  [${proposal.id.slice(0, 8)}]  🌑 SHADOW_OBSERVATION\n`;
+  out += `${BAR}\n`;
+  if (proposal.rationale) {
+    out += `**Pattern:** ${proposal.rationale}\n`;
+  }
+  if (ids.length > 0) {
+    out += `**Source memories:** ${ids.map((id) => id.slice(0, 8)).join(", ")}\n`;
+  }
+  out += `\n${proposal.proposal}\n`;
+  out += "\n";
+  return out;
+}
+
+/** Port of `shadow scan`'s full output. */
+export function renderShadowScan(result: ShadowScanResult): string {
+  if (result.candidatesConsidered === 0) {
+    return (
+      "No shadow-candidate memories found.\n" +
+      "Shadow candidates come from:\n" +
+      "  \u2022 memories with layer='shadow'\n" +
+      "  \u2022 memories of type 'tension' or 'pattern'\n" +
+      "  \u2022 memories advanced to 'candidate' via mm-consolidate\n" +
+      "\n"
+    );
+  }
+
+  let out = `Found ${result.candidatesConsidered} shadow-candidate memories. Generating observations...\n\n`;
+
+  if (result.proposalsCreated.length === 0) {
+    out +=
+      "No new observations were proposed.\n" +
+      "The LLM found nothing new beyond what is already in the structural shadow layer,\n" +
+      "or the evidence was insufficient to surface an observation.\n";
+    return out;
+  }
+
+  result.proposalsCreated.forEach((proposal, index) => {
+    out += formatObservationBlock(proposal, index + 1, result.proposalsCreated.length);
+  });
+
+  out +=
+    `\n${result.proposalsCreated.length} observation(s) created with status='pending'.\n` +
+    "Review each observation above, then:\n" +
+    `  Accept:  ${PROGRAM} shadow apply <proposal_id>\n` +
+    `  Edit:    ${PROGRAM} shadow apply <proposal_id> --content "revised text"\n` +
+    `  Reject:  ${PROGRAM} shadow reject <proposal_id>\n`;
+  return out;
+}

package/ts/src/frontDoor/render/tasks.ts

@@ -0,0 +1,99 @@
+// `tasks` command rendering — the port of `memory.cli.tasks_cmd`'s print
+// statements. Every function here is a pure string builder over already-decided
+// data (the write route in `tasksWriteRoute.ts` decides WHAT happened; this
+// module decides HOW it is printed), matching Python's exact output including
+// its blank-line quirks (`print(f"...\n")` followed by `print()`'s own newline).
+
+import type { DeleteOutcome, StatusChangeOutcome } from "#frontDoor/tasksWriteRoute.ts";
+import type { Task } from "#tasks/taskStore.ts";
+
+const STATUS_ICONS: Record<string, string> = {
+  todo: "○",
+  doing: "◐",
+  done: "●",
+  blocked: "✖",
+};
+
+/** Options mirroring the CLI flags that decide `tasks list`'s label/open-count. */
+export interface ListTasksRenderOptions {
+  all: boolean;
+  status: string | null;
+}
+
+/**
+ * Render `tasks list` (and the bare `tasks` default). `by_journey` grouping
+ * preserves Python's dict-insertion-order semantics via a `Map`, keyed by
+ * `journey || "(no journey)"`.
+ */
+export function renderTasksList(tasks: readonly Task[], options: ListTasksRenderOptions): string {
+  if (tasks.length === 0) return "No tasks found.\n";
+
+  const byJourney = new Map<string, Task[]>();
+  for (const t of tasks) {
+    const key = t.journey || "(no journey)";
+    const bucket = byJourney.get(key);
+    if (bucket) bucket.push(t);
+    else byJourney.set(key, [t]);
+  }
+
+  const label = options.all ? "all" : (options.status ?? "open");
+  const totalOpen = tasks.filter(
+    (t) => t.status === "todo" || t.status === "doing" || t.status === "blocked",
+  ).length;
+  // Suppressed purely by `status`, independent of `all` -- matches Python's
+  // own independent `if not args.status` check (not nested under the
+  // all/status/else label branch).
+  const openNote = options.status ? "" : ` (${totalOpen} open)`;
+
+  // The header line's trailing "" reproduces `print(f"...\n")` (a literal \n
+  // inside the f-string) immediately followed by `print()`'s own newline.
+  const lines: string[] = [`📋 Tasks ${label}: ${tasks.length}${openNote}`, ""];
+  for (const [journey, journeyTasks] of byJourney) {
+    lines.push(`🧭 ${journey}`);
+    for (const t of journeyTasks) {
+      const icon = STATUS_ICONS[t.status] ?? "?";
+      const due = t.due_date ? ` 📅 ${t.due_date}` : "";
+      const stage = t.stage ? ` [${t.stage}]` : "";
+      lines.push(`  ${icon} \`${t.id}\` ${t.title}${due}${stage}`);
+    }
+    lines.push(""); // the trailing bare `print()` after each journey's tasks
+  }
+  return lines.map((line) => `${line}\n`).join("");
+}
+
+/** Render `tasks add`. */
+export function renderTasksAdd(task: Task): string {
+  const lines = [`✅ Task created: \`${task.id}\` - ${task.title}`];
+  if (task.journey) lines.push(`   Journey: ${task.journey}`);
+  if (task.due_date) lines.push(`   Due: ${task.due_date}`);
+  return lines.map((line) => `${line}\n`).join("");
+}
+
+/**
+ * Render a `tasks done|doing|block` outcome. This is where the resolver's
+ * "ambiguous" fact becomes Python's `cmd_status_change` message -- the
+ * shared resolver stays silent on presentation (taskStore.ts's module doc).
+ */
+export function renderTasksStatusChange(outcome: StatusChangeOutcome): string {
+  if (outcome.kind === "not_found") {
+    return `❌ Task '${outcome.idOrPrefix}' not found.\n`;
+  }
+  if (outcome.kind === "ambiguous") {
+    const ids = outcome.matches.map((t) => t.id).join(", ");
+    return `❌ Ambiguous ID '${outcome.idOrPrefix}'. Matches: ${ids}\n`;
+  }
+  const icon = STATUS_ICONS[outcome.newStatus] ?? "?";
+  return `${icon} Task \`${outcome.task.id}\` → ${outcome.newStatus}: ${outcome.task.title}\n`;
+}
+
+/**
+ * Render a `tasks delete` outcome. This is the ONE place the asymmetry with
+ * status-change shows: an "ambiguous" resolver result is folded into the same
+ * "not found" message Python's `cmd_delete` prints for zero matches.
+ */
+export function renderTasksDelete(outcome: DeleteOutcome): string {
+  if (outcome.kind === "not_found") {
+    return `❌ Task '${outcome.idOrPrefix}' not found.\n`;
+  }
+  return `🗑 Task removed: \`${outcome.task.id}\` - ${outcome.task.title}\n`;
+}