@zerwiz/ymir 0.1.16 → 0.1.18

package/.pi/shared/extensions/todo.ts

@@ -0,0 +1,133 @@
+/**
+ * Todo — opencode-style task tracker for pi.
+ *
+ * Session-scoped todo list with 4 statuses and 3 priorities.
+ * State stored in session entries (survives branching).
+ */
+
+import type { ExtensionAPI, ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
+import { matchesKey, Text, truncateToWidth } from "@earendil-works/pi-tui";
+import { Type } from "typebox";
+
+interface Todo {
+  content: string;
+  status: "pending" | "in_progress" | "completed" | "cancelled";
+  priority: "high" | "medium" | "low";
+}
+
+interface TodoDetails {
+  action: string;
+  todos: Todo[];
+  error?: string;
+}
+
+const StatusEnum = Type.Unsafe({ type: "string", enum: ["pending", "in_progress", "completed", "cancelled"] });
+const PriorityEnum = Type.Unsafe({ type: "string", enum: ["high", "medium", "low"] });
+
+const TodoParams = Type.Object({
+  action: Type.Unsafe({ type: "string", enum: ["list", "add", "update", "remove", "clear", "replace"], description: "Action: list, add, update, remove, clear, replace" }),
+  content: Type.Optional(Type.String({ description: "Task description (for add/update)" })),
+  priority: Type.Optional(PriorityEnum),
+  index: Type.Optional(Type.Number({ description: "Todo index 0-based (for update/remove)" })),
+  status: Type.Optional(StatusEnum),
+  todos: Type.Optional(Type.Array(Type.Object({ content: Type.String(), status: StatusEnum, priority: PriorityEnum }), { description: "Full todo list (for replace)" })),
+});
+
+let todos: Todo[] = [];
+
+function reconstructState(ctx: ExtensionContext) {
+  todos = [];
+  for (const entry of ctx.sessionManager.getBranch()) {
+    if (entry.type !== "message") continue;
+    const msg = entry.message;
+    if (msg.role !== "toolResult" || msg.toolName !== "todo") continue;
+    const details = msg.details as TodoDetails | undefined;
+    if (details?.todos) todos = [...details.todos];
+  }
+}
+
+const STATUS_ICONS: Record<string, string> = { pending: "○", in_progress: "►", completed: "✓", cancelled: "✗" };
+const PRIORITY_LABELS: Record<string, string> = { high: "HIGH", medium: "med", low: "low" };
+
+function formatTodoList(t: Todo[], theme: Theme, expanded: boolean): string {
+  if (t.length === 0) return theme.fg("dim", "No todos.");
+  const active = t.filter(x => x.status !== "completed" && x.status !== "cancelled");
+  const done = t.filter(x => x.status === "completed");
+  let out = theme.fg("muted", `${active.length} active, ${done.length} done`);
+  const display = expanded ? t : t.slice(0, 10);
+  for (let i = 0; i < display.length; i++) {
+    const todo = display[i];
+    const icon = STATUS_ICONS[todo.status] ?? "?";
+    const iconColor = todo.status === "completed" ? "success" : todo.status === "cancelled" ? "dim" : todo.status === "in_progress" ? "accent" : "muted";
+    const pri = PRIORITY_LABELS[todo.priority] ?? "";
+    const priColor = todo.priority === "high" ? "error" : todo.priority === "medium" ? "warning" : "dim";
+    let line = ` ${theme.fg(iconColor, icon)} ${theme.fg("accent", String(i))}`;
+    if (pri) line += ` ${theme.fg(priColor, pri.padEnd(4))}`;
+    line += ` ${todo.status === "completed" || todo.status === "cancelled" ? theme.fg("dim", todo.content) : theme.fg("text", todo.content)}`;
+    out += "\n" + truncateToWidth(line, 80);
+  }
+  if (!expanded && t.length > 10) out += `\n ${theme.fg("dim", `... ${t.length - 10} more`)}`;
+  return out;
+}
+
+class TodoUI {
+  private todoList: Todo[];
+  private theme: Theme;
+  private onClose: () => void;
+  constructor(todoList: Todo[], theme: Theme, onClose: () => void) { this.todoList = todoList; this.theme = theme; this.onClose = onClose; }
+  handleInput(data: string): void { if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) this.onClose(); }
+  render(width: number): string[] {
+    const lines: string[] = []; const th = this.theme;
+    lines.push(""); const title = th.fg("accent", " Todos ");
+    lines.push(truncateToWidth(th.fg("borderMuted", "─".repeat(3)) + title + th.fg("borderMuted", "─".repeat(Math.max(0, width - 10))), width));
+    lines.push(""); lines.push(formatTodoList(this.todoList, th, true));
+    lines.push(""); lines.push(truncateToWidth(`  ${th.fg("dim", "Escape to close")}`, width)); lines.push("");
+    return lines;
+  }
+}
+
+export default function todoExtension(pi: ExtensionAPI) {
+  pi.on("session_start", async (_event, ctx) => reconstructState(ctx));
+  pi.on("session_tree", async (_event, ctx) => reconstructState(ctx));
+
+  pi.registerTool({
+    name: "todo", label: "Todo",
+    description: "Manage a task list. Actions: list, add, update, remove, clear, replace",
+    promptSnippet: "Track multi-step work with todo list",
+    promptGuidelines: ["Use todo when work has 3+ steps or user provides multiple tasks.", "Mark exactly ONE todo as in_progress at a time.", "Mark tasks completed only after verification."],
+    parameters: TodoParams,
+    async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+      const action = params.action as string;
+      switch (action) {
+        case "list": return { content: [{ type: "text", text: todos.length ? todos.map((t, i) => `${i}: [${t.status}] [${t.priority}] ${t.content}`).join("\n") : "No todos." }], details: { action: "list", todos: [...todos] } as TodoDetails };
+        case "add": { if (!params.content) throw new Error("content required for add"); const priority = (params.priority as any) ?? "medium"; const newTodo: Todo = { content: params.content, status: "pending", priority }; todos.push(newTodo); return { content: [{ type: "text", text: `Added #${todos.length - 1}: ${newTodo.content}` }], details: { action: "add", todos: [...todos] } as TodoDetails }; }
+        case "update": { if (params.index === undefined) throw new Error("index required for update"); const idx = params.index; if (idx < 0 || idx >= todos.length) throw new Error(`Index ${idx} out of range`); const todo = todos[idx]; if (params.status) { if (params.status === "in_progress") { const existing = todos.find(t => t.status === "in_progress"); if (existing && existing !== todo) existing.status = "pending"; } todo.status = params.status as any; } if (params.priority) todo.priority = params.priority as any; if (params.content) todo.content = params.content; return { content: [{ type: "text", text: `Updated #${idx}: [${todo.status}] [${todo.priority}] ${todo.content}` }], details: { action: "update", todos: [...todos] } as TodoDetails }; }
+        case "remove": { if (params.index === undefined) throw new Error("index required for remove"); const idx = params.index; if (idx < 0 || idx >= todos.length) throw new Error(`Index ${idx} out of range`); const removed = todos.splice(idx, 1)[0]; return { content: [{ type: "text", text: `Removed #${idx}: ${removed.content}` }], details: { action: "remove", todos: [...todos] } as TodoDetails }; }
+        case "clear": { const count = todos.length; todos = []; return { content: [{ type: "text", text: `Cleared ${count} todos.` }], details: { action: "clear", todos: [] } as TodoDetails }; }
+        case "replace": { if (!params.todos) throw new Error("todos array required for replace"); todos = params.todos.map((t: any) => ({ content: t.content, status: t.status, priority: t.priority })); return { content: [{ type: "text", text: `Replaced with ${todos.length} todos.` }], details: { action: "replace", todos: [...todos] } as TodoDetails }; }
+        default: throw new Error(`Unknown action: ${action}`);
+      }
+    },
+    renderCall(args, theme) {
+      let text = theme.fg("toolTitle", theme.bold("todo ")) + theme.fg("muted", args.action);
+      if (args.content) text += ` ${theme.fg("dim", `"${args.content}"`)}`;
+      if (args.index !== undefined) text += ` ${theme.fg("accent", `#${args.index}`)}`;
+      if (args.todos) text += ` ${theme.fg("muted", `(${args.todos.length} items)`)}`;
+      return new Text(text, 0, 0);
+    },
+    renderResult(result, { expanded }, theme) {
+      const details = result.details as TodoDetails | undefined;
+      if (!details) { const c = result.content[0]; return new Text(c?.type === "text" ? c.text : "", 0, 0); }
+      if (details.error) return new Text(theme.fg("error", `Error: ${details.error}`), 0, 0);
+      return new Text(formatTodoList(details.todos, theme, expanded), 0, 0);
+    },
+  });
+
+  pi.registerCommand("todos", {
+    description: "Show the current todo list",
+    handler: async (_args, ctx) => {
+      if (ctx.mode !== "tui") { ctx.ui.notify("/todos requires interactive mode", "error"); return; }
+      await ctx.ui.custom<void>((_tui, theme, _kb, done) => { return new TodoUI(todos, theme, () => done()); });
+    },
+  });
+}

package/.pi/shared/extensions/ymir-subagents.ts

@@ -0,0 +1,287 @@
+/**
+ * ymir-subagents — the Eindri roster as a Pi tool.
+ *
+ * Pi core has no agent loader: agents come from a package, and Ymir installs
+ * none. That left `.pi/agents/` holding twenty correct profiles that nothing in
+ * Pi ever read. This extension closes that gap inside the repo, so Ymir needs no
+ * root-pi package: it reads the canonical `.agents/agents/*.md` tree directly and
+ * exposes every figure as a callable subagent.
+ *
+ * The canonical tree is the single source of truth (Rule 02). This file reads it;
+ * it never copies from it.
+ *
+ *   subagent({ agent: "kvasir", task: "find every AGENTS.md" })
+ *
+ * The chosen figure's markdown body becomes the system prompt, and its
+ * frontmatter decides the model. The run is a nested model call in this session,
+ * so no pane and no subprocess are needed.
+ *
+ * Placement: this file belongs to the SHARED source, which the loader deploys to
+ * the global extension home — pi auto-discovers BOTH the global home and a
+ * project-local .pi/extensions, and the same extension in both registers its
+ * tools twice, which pi refuses. ONE home. Never copy this into a project.
+ *
+ * Contract (pi.dev/docs/latest/extensions):
+ *   - export a default factory receiving ExtensionAPI (sync or async)
+ *   - registerTool works during load and at runtime
+ *   - do not start background resources in the factory
+ *
+ * No imports: `@earendil-works/pi-coding-agent` is not installed as a package,
+ * so an extension that imports its types cannot load at all. The working
+ * extensions in this tree take `pi` as `any` and declare parameters as plain
+ * JSON schema. This one follows them.
+ */
+import { readFileSync, readdirSync, existsSync } from "node:fs";
+import { join, resolve } from "node:path";
+
+/** A figure as the canonical tree declares it. */
+type Figure = {
+  name: string;
+  description: string;
+  model?: string;
+  body: string;
+  file: string;
+};
+
+/**
+ * Parse a `---` YAML frontmatter block without a YAML dependency.
+ *
+ * The profiles use only flat scalars for the fields this extension needs
+ * (`name`, `description`, `model`), so a strict line scan is enough and avoids
+ * pulling a parser into an extension that must load in every session. Anything
+ * it cannot read is simply absent.
+ */
+function frontmatter(text: string): Record<string, string> {
+  const out: Record<string, string> = {};
+  if (!text.startsWith("---")) return out;
+  const end = text.indexOf("\n---", 3);
+  if (end === -1) return out;
+  for (const line of text.slice(3, end).split("\n")) {
+    const m = /^([A-Za-z_][A-Za-z0-9_-]*):\s*(.*)$/.exec(line);
+    if (!m) continue;
+    let value = m[2].trim();
+    // Strip a matching pair of surrounding quotes; keep the inner text verbatim.
+    if (
+      (value.startsWith('"') && value.endsWith('"')) ||
+      (value.startsWith("'") && value.endsWith("'"))
+    ) {
+      value = value.slice(1, -1);
+    }
+    out[m[1]] = value;
+  }
+  return out;
+}
+
+/** The body after the frontmatter block — the figure's system prompt. */
+function bodyOf(text: string): string {
+  if (!text.startsWith("---")) return text;
+  const end = text.indexOf("\n---", 3);
+  if (end === -1) return text;
+  return text.slice(end + 4).replace(/^\s*\n/, "");
+}
+
+/**
+ * Find the canonical agents tree.
+ *
+ * Pi's project root is the nearest ancestor holding `.pi`; Ymir keeps its agents
+ * at `.agents/agents` beside it. Walk up so a session started in a worktree or a
+ * subdirectory still finds the one tree, and fall back to the global home.
+ */
+function findAgentsDir(cwd: string): string | undefined {
+  let dir = resolve(cwd);
+  while (true) {
+    const candidate = join(dir, ".agents", "agents");
+    if (existsSync(candidate)) return candidate;
+    const parent = resolve(dir, "..");
+    if (parent === dir) break;
+    dir = parent;
+  }
+  const home = process.env.HOME ?? "";
+  const global = join(home, ".agents", "agents");
+  return existsSync(global) ? global : undefined;
+}
+
+/** Read every profile in the tree, keyed by its frontmatter `name:`. */
+function loadFigures(dir: string): Map<string, Figure> {
+  const figures = new Map<string, Figure>();
+  let entries: string[];
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return figures;
+  }
+  for (const entry of entries) {
+    if (!entry.endsWith(".md")) continue;
+    const file = join(dir, entry);
+    let text: string;
+    try {
+      text = readFileSync(file, "utf-8");
+    } catch {
+      continue;
+    }
+    const fm = frontmatter(text);
+    const name = fm.name || entry.replace(/\.md$/, "");
+    figures.set(name, {
+      name,
+      description: fm.description ?? "",
+      model: fm.model,
+      body: bodyOf(text),
+      file,
+    });
+  }
+  return figures;
+}
+
+/** The roster as TOON — the house format for an agent-facing answer. */
+function rosterText(figures: Map<string, Figure>): string {
+  if (figures.size === 0) {
+    return "subagents: 0 figures found — is .agents/agents present?";
+  }
+  const rows = [...figures.values()]
+    .sort((a, b) => a.name.localeCompare(b.name))
+    .map((f) => `  "${f.name}","${f.description.replace(/"/g, "'")}"`);
+  return `subagents[${figures.size}]{name,description}:\n${rows.join("\n")}`;
+}
+
+export default function subagents(pi: any) {
+  // The tree is read once per session, not per tool call: a figure's profile
+  // does not change mid-session, and re-reading twenty files on every dispatch
+  // would cost more than the dispatch.
+  let figures = new Map<string, Figure>();
+
+  pi.on("session_start", async (_event: any, ctx: any) => {
+    const dir = findAgentsDir(ctx?.cwd ?? process.cwd());
+    figures = dir ? loadFigures(dir) : new Map();
+  });
+
+  pi.registerTool({
+    name: "subagent",
+    description:
+      "Dispatch one of Ymir's Eindri figures as a subagent, or list them. Reads " +
+      "the canonical .agents/agents/*.md tree. Use for a task that fits a " +
+      "figure's craft — kvasir (recon), sindri (code), bragi (marketing), " +
+      "huginn (research), forseti (review), mimir (planning), and the rest.",
+    parameters: {
+      type: "object",
+      properties: {
+        agent: {
+          type: "string",
+          description:
+            "The figure to dispatch, by name (e.g. kvasir, sindri, bragi). Omit to list.",
+        },
+        task: {
+          type: "string",
+          description: "The task to hand the figure.",
+        },
+      },
+      required: [],
+    },
+    async execute(_id: string, params: { agent?: string; task?: string }, _signal?: any, _onUpdate?: any, ctx?: any) {
+      // A list request is answered without a model call — it is a lookup, and
+      // the roster is already in hand.
+      if (!params?.agent || !params?.task) {
+        return { content: [{ type: "text", text: rosterText(figures) }] };
+      }
+
+      const figure = figures.get(params.agent);
+      if (!figure) {
+        const known = [...figures.keys()].sort().join(", ") || "none";
+        return {
+          content: [
+            {
+              type: "text",
+              text: `error: no figure named "${params.agent}"\nhelp: known figures: ${known}`,
+            },
+          ],
+          isError: true,
+        };
+      }
+
+      // Resolve the figure's model. A profile that names one gets it when the
+      // machine serves it; otherwise the session's own model carries the run, so
+      // a dispatch never fails for want of a model that is not available.
+      let model = ctx?.model;
+      if (figure.model && ctx?.modelRegistry) {
+        try {
+          const available = ctx.modelRegistry.getAvailable();
+          const match = available.find(
+            (m: any) => `${m.provider}/${m.id}` === figure.model || m.id === figure.model,
+          );
+          if (match) model = match;
+        } catch {
+          // keep the session model
+        }
+      }
+      if (!model || !ctx?.modelRegistry?.streamSimple) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `error: no model available for subagent "${figure.name}"`,
+            },
+          ],
+          isError: true,
+        };
+      }
+
+      // The figure's body is its system prompt; the task is the user turn. This
+      // is the whole contract — the profile IS the agent.
+      const stream = ctx.modelRegistry.streamSimple(
+        model,
+        {
+          systemPrompt: figure.body,
+          messages: [{ role: "user", content: [{ type: "text", text: params.task }] }],
+        },
+        { signal: _signal },
+      );
+
+      let text = "";
+      try {
+        for await (const event of stream) {
+          if (event?.type === "text_delta" && event.delta) text += event.delta;
+        }
+      } catch (err: any) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `error: subagent "${figure.name}" failed mid-run: ${err?.message ?? err}`,
+            },
+          ],
+          isError: true,
+        };
+      }
+      if (!text) {
+        try {
+          const result = await stream.result();
+          for (const part of result?.content ?? []) {
+            if (part?.type === "text") text += part.text;
+          }
+        } catch {
+          // leave text empty; the header below still reports 0 chars
+        }
+      }
+
+      const header = `subagent[1]{figure,model,chars}:\n  "${figure.name}","${model.provider}/${model.id}",${text.length}`;
+      return {
+        content: [{ type: "text", text: `${header}\n\n${text}` }],
+        details: { figure: figure.name, model: `${model.provider}/${model.id}` },
+      };
+    },
+  });
+
+  pi.registerCommand("subagents", {
+    description: "List the Eindri figures available as subagents",
+    handler: async (_args: string, ctx: any) => {
+      const dir = findAgentsDir(ctx?.cwd ?? process.cwd());
+      const found = dir ? loadFigures(dir) : new Map<string, Figure>();
+      const names = [...found.keys()].sort();
+      ctx?.ui?.notify(
+        names.length
+          ? `${names.length} figures: ${names.join(", ")}`
+          : "no figures found — is .agents/agents present?",
+        "info",
+      );
+    },
+  });
+}

package/.pi/shared/extensions/ymir-well.ts

@@ -0,0 +1,130 @@
+/**
+ * ymir-well — Kaia's memory, as tools inside every pi session.
+ *
+ * The well is Mimirsbrunn: the engram store at $YMIR_HOME/memory/kaia.engram,
+ * reached over the bridge on :4602. Every worker Ymir seats should be able to
+ * recall what was learned and observe what it learned — that is what makes the
+ * fleet learn instead of re-learning. Before this, only the orchestrator could,
+ * and only through smidja_orchestrate.py.
+ *
+ * Placement: this file belongs to the SHARED source, which the loader deploys to
+ * the global extension home — pi auto-discovers BOTH the global home and a
+ * project-local .pi/extensions, and the same extension in both registers its
+ * tools twice, which pi refuses. ONE home. Never copy this into a project.
+ *
+ * Contract (pi.dev/docs/latest/extensions):
+ *   - export a default factory receiving ExtensionAPI (sync or async)
+ *   - registerTool works during load and at runtime
+ *   - do not start background resources in the factory
+ */
+export default function well(pi: any) {
+  const BRIDGE = process.env.YMIR_MEMORY_URL ?? "http://127.0.0.1:4602";
+
+  /** One shape for every answer: a tool that throws teaches the model nothing. */
+  async function call(path: string, init?: RequestInit) {
+    const res = await fetch(new URL(path, BRIDGE).toString(), {
+      ...init,
+      headers: { "content-type": "application/json", ...(init?.headers ?? {}) },
+      signal: AbortSignal.timeout(15000),
+    });
+    const body = await res.text();
+    if (!res.ok) {
+      return { ok: false as const, status: res.status, body: body.slice(0, 400) };
+    }
+    try {
+      return { ok: true as const, body: JSON.parse(body) };
+    } catch {
+      return { ok: true as const, body };
+    }
+  }
+
+  pi.registerTool({
+    name: "well_recall",
+    description:
+      "Recall from Kaia's memory (the well) what Ymir already learned. Use before " +
+      "starting work: a lesson already paid for costs nothing the second time. " +
+      "Returns episodes with their score, content and tags.",
+    parameters: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "what you want to remember, in words" },
+        k: { type: "number", description: "how many episodes (default 5)" },
+      },
+      required: ["query"],
+    },
+    async execute(_id: string, params: { query: string; k?: number }) {
+      const k = Math.max(1, Math.min(20, Number(params.k ?? 5)));
+      const r = await call(`/recall?q=${encodeURIComponent(params.query)}&k=${k}`);
+      if (!r.ok) {
+        return { content: [{ type: "text", text: `the well did not answer (${r.status}): ${r.body}` }], isError: true };
+      }
+      const hits = (r.body as any)?.results ?? [];
+      if (!hits.length) {
+        return { content: [{ type: "text", text: "the well holds nothing for that yet." }] };
+      }
+      const text = hits
+        .map((h: any, i: number) => {
+          const e = h.episode ?? {};
+          const tags = Array.isArray(e.tags) ? e.tags.join(", ") : String(e.tags ?? "");
+          return `${i + 1}. [${Number(h.score ?? 0).toFixed(2)}] ${String(e.content ?? "").slice(0, 600)}${tags ? `\n   tags: ${tags}` : ""}`;
+        })
+        .join("\n");
+      return { content: [{ type: "text", text }] };
+    },
+  });
+
+  pi.registerTool({
+    name: "well_observe",
+    description:
+      "Write a lesson into Kaia's memory (the well). Use when a run teaches " +
+      "something durable — what worked, what failed, what the next hand must know. " +
+      "The orchestrator reads this before dispatch, so write it plain and true.",
+    parameters: {
+      type: "object",
+      properties: {
+        content: { type: "string", description: "the lesson, in full sentences" },
+        tags: { type: "string", description: "comma-separated labels, e.g. 'run,lesson'" },
+        actors: { type: "string", description: "comma-separated names involved" },
+        salience: { type: "number", description: "importance 0..1 (default 0.7)" },
+      },
+      required: ["content"],
+    },
+    async execute(
+      _id: string,
+      params: { content: string; tags?: string; actors?: string; salience?: number },
+    ) {
+      // LISTS, never comma-strings: the store keeps a string as an array of
+      // CHARACTERS, and a later recall then reads tags as "r,u,n".
+      const list = (v?: string) =>
+        String(v ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+      const r = await call("/observe", {
+        method: "POST",
+        body: JSON.stringify({
+          content: params.content,
+          tags: list(params.tags ?? "run,lesson"),
+          actors: list(params.actors),
+          salience: Math.max(0, Math.min(1, Number(params.salience ?? 0.7))),
+        }),
+      });
+      if (!r.ok) {
+        return { content: [{ type: "text", text: `the lesson was NOT written (${r.status}): ${r.body}` }], isError: true };
+      }
+      const id = (r.body as any)?.id ?? "?";
+      return { content: [{ type: "text", text: `written to the well: ${id}` }] };
+    },
+  });
+
+  // A session that cannot reach the well should say so once, plainly, rather than
+  // let every later recall fail in silence.
+  pi.on("session_start", async () => {
+    const r = await call("/health");
+    if (!r.ok) {
+      pi.registerMessageRenderer?.("ymir-well-offline", (m: any) => m);
+      return;
+    }
+    const e = (r.body as any)?.episodes;
+    if (typeof e === "number" && e === 0) {
+      console.error("[ymir-well] the well is reachable but holds 0 episodes");
+    }
+  });
+}

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 
 
+## 2026-09-17 — the fork stands the machine
+
+- **`config/app-repos.yaml` (public)** — the five app repos, the fork's road:
+  a fresh clone with no hoard registry falls back to this map in the installer's
+  `apps` step, so `git clone` + `bin/ymir-install.sh` pull the four surfaces as
+  they would on the author's seat. Verified on a clean clone (`ymir-plan.sh`:
+  hlidskjalf/odrerir/sessrumnir/smidja all `DO`). The hoard registry stays
+  authoritative when present.
+
+## 2026-09-17 — the phantom optional pins, cut
+
+- The platform's stale \`optionalDependencies\` (sessrumnir pinned at the broken
+  0.1.9) shadowed the required \`^0.1.10\` — npm never fetched the good seat.
+  Removed; the required deps now resolve to latest (0.1.18).
+
+## 2026-09-17 — the packaged seat carries the watch
+
+- **The @zerwiz/ymir tarball now ships every surface the runtime reads**: the
+  harness surfaces (`.pi/`, `.opencode/`, `.claude/`, `.codex/`, `.cursor/`),
+  `assets/`, `data/`, `deploy/` — so an npm-installed seat has the watchers,
+  the session-start hooks and the extensions, not only the repo clone (0.1.16
+  → 0.1.17).
+
 ## 2026-09-17 — the npm door stands the surfaces
 
 - **`@zerwiz/ymir` now depends on its surfaces**: `@zerwiz/{hlidskjalf,