catherd-cli 1.2.1 → 1.4.0

package/src/services/doctor-checks.ts

@@ -1,6 +1,8 @@
+import type { OrchestrationHost } from "../domain/host.ts";
 import { readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { errorMessage, isCatherdError } from "../domain/errors.ts";
+import type { Profile } from "../domain/profile.ts";
 import { claudeHome, locksDir } from "../infra/paths.ts";
 import { ensurePrivateDir, PRIVATE_FILE } from "../infra/store.ts";
 import { agentLinkState } from "./agent-links.ts";
@@ -130,9 +132,13 @@ export function locksCheck(): Check {
   }
 }
 
-export function agentsCheck(): Check {
+export function agentsCheck(
+  host: OrchestrationHost,
+  selected?: string[],
+  relink = `catherd profile use ${activeName()}`,
+): Check {
   const base = { id: "agents", label: "Claude agents" };
-  const links = agentLinkState();
+  const links = agentLinkState(host, selected);
   const broken = [...links.missing, ...links.stale];
   if (broken.length)
     return {
@@ -140,9 +146,43 @@ export function agentsCheck(): Check {
       state: "fail",
       word: links.missing.length ? "missing" : "stale",
       detail: broken.join(", "),
-      fix: `catherd profile use ${activeName()}`,
+      fix: relink,
     };
   return links.ok.length
     ? { ...base, state: "ok", word: "ready", detail: `${links.ok.length} linked` }
     : { ...base, state: "skip", word: "none", detail: "no profile uses a native Claude rung" };
 }
+
+/**
+ * ` --host <host>` for a fix doctor prints, when it judged on a known host: run from a plain terminal, the fix
+ * must judge the profile the same way (omitted architect/verifier rungs resolve per host).
+ */
+export const hostFlag = (host: OrchestrationHost): string => (host === "unknown" ? "" : ` --host ${host}`);
+
+/** The browser CLI the ui-reviewer's prompt takes its screenshots with. */
+const UI_BROWSER = "agent-browser";
+
+/**
+ * The ui-reviewer takes screenshots with agent-browser: a profile that turns it on, on a machine without it,
+ * dispatches a role that cannot do its job. Nothing to say when it is on PATH or no profile turns the role on.
+ */
+export function uiBrowserCheck(
+  profiles: Profile[],
+  onPath: (bin: string) => string | null,
+  host: OrchestrationHost = "unknown",
+): Check | null {
+  const on = profiles.filter((p) => p.roles["ui-reviewer"].enabled).map((p) => p.name);
+  if (!on.length || onPath(UI_BROWSER)) return null;
+  return {
+    id: "ui-browser",
+    label: UI_BROWSER,
+    state: "warn",
+    word: "missing",
+    detail: `${UI_BROWSER} is not on PATH, so ui-reviewer (${on.join(", ")}) cannot take screenshots`,
+    fix: [
+      `npm i -g ${UI_BROWSER}`,
+      "or turn the role off:",
+      ...on.map((n) => `catherd profile set roles.ui-reviewer.enabled false --profile ${n}${hostFlag(host)}`),
+    ].join("\n"),
+  };
+}

package/src/services/doctor-push.ts

@@ -1,109 +1,88 @@
-import { existsSync, readdirSync, readFileSync } from "node:fs";
-import { join } from "node:path";
+import type { HostContext } from "../domain/host.ts";
 import { envelope } from "../domain/notice.ts";
 import { readSessionEnv, sessionFileFor } from "../infra/claude-session.ts";
-import { claudeHome } from "../infra/paths.ts";
+import { sendToCodexQueue } from "../infra/codex-queue.ts";
 import { sendToInbox } from "../infra/peer-inbox.ts";
 import type { Check } from "./doctor-checks.ts";
 
-/**
- * Spec §3.9 `doctor`'s `push` row: run from inside a Claude Code session (its Bash tool), send that session one
- * `later` message and look for the enqueue line its transcript gets when the message is accepted
- * (docs/research/2026-09-28-cross-session-messaging.md §7).
- */
-
-export type PushOutcome = "ok" | "no-session" | "held" | "unconfirmed" | "failed";
-
+export type PushOutcome = "ok" | "no-session" | "unconfirmed" | "failed";
 export interface PushProbe {
   outcome: PushOutcome;
   detail: string;
+  enqueue: "accepted" | "ambiguous" | "not-submitted" | "no-session";
+  processing: "observed" | "unconfirmed";
+  msgId: string | null;
 }
 
-/** How long the probe looks for the enqueue line; tests shorten it. */
-export const pushLimits = { waitMs: 5_000, pollMs: 100 };
-
-/** The session's transcript, found by globbing `projects/*` (a git worktree logs under its main checkout's slug). */
-function transcriptOf(sessionId: string): string | null {
-  const projects = join(claudeHome(), "projects");
-  if (!existsSync(projects)) return null;
-  for (const d of readdirSync(projects)) {
-    const f = join(projects, d, `${sessionId}.jsonl`);
-    if (existsSync(f)) return f;
-  }
-  return null;
-}
-
-const enqueued = (file: string, nonce: string): boolean => {
-  try {
-    return readFileSync(file, "utf8")
-      .split("\n")
-      .some((l) => l.includes('"operation":"enqueue"') && l.includes(nonce));
-  } catch {
-    return false;
-  }
-};
-
-export async function probePush(env: Record<string, string | undefined> = process.env): Promise<PushProbe> {
-  const s = readSessionEnv(env);
-  if (!s?.socketPath)
-    return { outcome: "no-session", detail: "run catherd doctor from a Claude Code session to test push" };
-  const sessionId = sessionFileFor(s)?.sessionId ?? s.sessionId;
-  const nonce = crypto.randomUUID().slice(0, 8);
-  const r = await sendToInbox(s, envelope(`catherd doctor: push test ${nonce}, no action needed`), "later");
-  // a socket that is gone or refuses is a shell that outlived its session, not a protocol change
-  if (r.outcome === "no-session" || r.outcome === "refused")
+/** Explicit smoke only: native receipts prove acceptance, never model processing or result collection. */
+export async function probePush(
+  host: HostContext,
+  env: Record<string, string | undefined>,
+): Promise<PushProbe> {
+  const target = host.session;
+  if (host.conflict || !target || host.host === "unknown" || target.host !== host.host)
     return {
       outcome: "no-session",
-      detail: `this session's inbox is not reachable (${r.reason ?? r.outcome}); run catherd doctor from a live Claude Code session to test push`,
-    };
-  if (r.outcome !== "sent")
-    return {
-      outcome: "failed",
-      detail: `catherd cannot notify this Claude Code version; peek still works (${r.reason ?? r.outcome})`,
+      enqueue: "no-session",
+      processing: "unconfirmed",
+      msgId: null,
+      detail:
+        "No validated live host session; run doctor --test-push from the original conversation. Terminal --host selects checks only. Use peek/result.",
     };
-  const deadline = Date.now() + pushLimits.waitMs;
-  let file: string | null = null;
-  for (;;) {
-    file = sessionId ? transcriptOf(sessionId) : null;
-    if (file && enqueued(file, nonce))
-      return { outcome: "ok", detail: "a test message reached this session" };
-    if (Date.now() > deadline) break;
-    await Bun.sleep(pushLimits.pollMs);
-  }
-  return file
-    ? {
-        outcome: "held",
-        detail: `the test message was sent but not accepted within ${pushLimits.waitMs / 1000} s: a crossSessionInbound setting holds or refuses it`,
-      }
-    : {
-        outcome: "unconfirmed",
-        detail: "sent; no transcript of this session was found to confirm it arrived",
-      };
-}
-
-/** The probe as a `doctor` row. */
-export function pushCheck(p: PushProbe): Check {
-  const base = { id: "push", label: "push to Claude Code", detail: p.detail };
-  switch (p.outcome) {
-    case "ok":
-      return { ...base, state: "ok", word: "ready" };
-    case "no-session":
-      return { ...base, state: "skip", word: "no session" };
-    case "held":
+  const content = envelope(`catherd doctor: push test ${crypto.randomUUID().slice(0, 8)}, no action needed`);
+  let enqueue: PushProbe["enqueue"];
+  let msgId: string | null = null;
+  if (host.host === "codex") {
+    const sent = await sendToCodexQueue(target, content, env);
+    enqueue = sent.outcome;
+    if (sent.outcome === "accepted") msgId = sent.msgId;
+  } else {
+    const s = readSessionEnv(env);
+    const liveId = s ? (sessionFileFor(s)?.sessionId ?? s.sessionId) : null;
+    if (!s || liveId !== target.sessionId)
       return {
-        ...base,
-        state: "warn",
-        word: "held",
-        fix: `set "crossSessionInbound": "accept" in ${join(claudeHome(), "settings.json")}, or remove a project setting that sets it to hold or refuse`,
+        outcome: "no-session",
+        enqueue: "no-session",
+        processing: "unconfirmed",
+        msgId: null,
+        detail: "Claude inbox identity does not match the validated live session; use peek/result.",
       };
-    case "unconfirmed":
-      return { ...base, state: "warn", word: "not confirmed" };
-    case "failed":
+    const sent = await sendToInbox(s, content, "later");
+    if (sent.outcome === "no-session" || sent.outcome === "refused")
       return {
-        ...base,
-        state: "fail",
-        word: "failed",
-        fix: "update catherd (and Claude Code); meanwhile peek(run) shows each role and each unread record",
+        outcome: "no-session",
+        enqueue: "not-submitted",
+        processing: "unconfirmed",
+        msgId: null,
+        detail:
+          "This session's inbox is not reachable; run doctor --test-push from a live Claude Code session. Use peek/result.",
       };
+    enqueue = sent.outcome === "sent" && sent.msgId ? "accepted" : "ambiguous";
+    if (enqueue === "accepted") msgId = sent.msgId ?? null;
   }
+  return {
+    outcome: enqueue === "accepted" ? "ok" : enqueue === "ambiguous" ? "unconfirmed" : "failed",
+    enqueue,
+    processing: "unconfirmed",
+    msgId,
+    detail:
+      enqueue === "accepted"
+        ? "Smoke enqueue accepted; processing unconfirmed. Unloaded, interrupted or restarted hosts may retain queued input. Use peek/result for durable unread results."
+        : enqueue === "ambiguous"
+          ? "Smoke has no verified queue receipt; processing unconfirmed. Retrying may duplicate input. Use peek/result."
+          : "Smoke was not submitted; check native queue support and the existing endpoint. Use peek/result.",
+  };
+}
+
+export function pushCheck(p: PushProbe): Check {
+  const base = { id: "push", label: "host completion push", detail: p.detail };
+  if (p.enqueue === "accepted") return { ...base, state: "ok", word: "enqueue accepted" };
+  if (p.outcome === "no-session") return { ...base, state: "skip", word: "no session" };
+  if (p.enqueue === "ambiguous") return { ...base, state: "warn", word: "ambiguous" };
+  return {
+    ...base,
+    state: "fail",
+    word: "not submitted",
+    fix: "Check native host transport; peek/result keeps the unread record available.",
+  };
 }

package/src/services/doctor.ts

@@ -1,3 +1,5 @@
+import { queueCapability, type QueueCapability } from "../infra/codex-queue.ts";
+import type { HostContext } from "../domain/host.ts";
 import { existsSync, statSync } from "node:fs";
 import { adapterFor } from "../adapters/registry.ts";
 import "../adapters/all.ts";
@@ -8,10 +10,11 @@ import type { JevTransport } from "../infra/jev-client.ts";
 import { linkedProfiles } from "./agent-links.ts";
 import { accessChecks } from "./doctor-access.ts";
 import { backendChecks, usedBackends } from "./doctor-backends.ts";
-import { type PushProbe, pushCheck } from "./doctor-push.ts";
+import { type PushProbe, pushCheck, probePush } from "./doctor-push.ts";
 import { sourcesCheck, standInsToConfirmIn } from "./doctor-sources.ts";
 import {
   agentsCheck,
+  hostFlag,
   type Check,
   errText,
   fixOf,
@@ -19,6 +22,7 @@ import {
   locksCheck,
   mcpCheck,
   pluginCheck,
+  uiBrowserCheck,
 } from "./doctor-checks.ts";
 import { credentialsPath, jevKey, savedJevKey, testJevKey } from "./jev-service.ts";
 import {
@@ -30,9 +34,13 @@ import {
   readProjects,
   validateNamed,
 } from "./profile-store.ts";
+import { inspectionHost } from "./run-debug.ts";
 import { listRuns } from "./run-store.ts";
 
 export interface DoctorReport {
+  host: HostContext;
+  queue: QueueCapability | null;
+  push: PushProbe | null;
   /** false when any check failed: `catherd doctor` exits 3 */
   ready: boolean;
   version: string;
@@ -48,13 +56,17 @@ export interface Handshake {
 }
 
 export interface DoctorDeps {
+  host: HostContext;
+  repo: string | null;
   bunVersion: string;
   /** the package version, which the Claude Code plugin must pin */
   version: string;
   /** starts the MCP server as the plugin does (its launcher) over stdio and asks it for tools/list */
   handshake: () => Promise<Handshake>;
-  /** spec §3.9: sends this Claude Code session a test message; without it (the dashboard) there is no `push` row */
+  /** Explicit smoke test injection; default doctor never invokes it. */
   push?: () => Promise<PushProbe>;
+  testPush?: boolean;
+  env?: Record<string, string | undefined>;
   jev?: JevTransport;
 }
 
@@ -77,13 +89,15 @@ export async function doctor(d: DoctorDeps): Promise<DoctorReport> {
       : { id: "bun", label: "Bun", state: "ok", word: "ready", detail: d.bunVersion },
   );
 
+  // every fix names the host doctor judged with: run elsewhere (a plain terminal), it must judge the same way
+  const onHost = hostFlag(d.host.host);
   let profiles: Profile[] = [];
   let linked: string[] = [];
   let active: Profile | null = null;
   try {
     readConfig();
     readProjects();
-    active = getProfile(activeName());
+    active = getProfile(activeName(d.repo), d.host.host);
     linked = linkedProfiles();
     checks.push({
       id: "config",
@@ -105,7 +119,7 @@ export async function doctor(d: DoctorDeps): Promise<DoctorReport> {
   // one unreadable linked profile must not hide the others' backends: its own row below reports it
   profiles = linked.flatMap((n) => {
     try {
-      return [getProfile(n)];
+      return [getProfile(n, d.host.host)];
     } catch {
       return [];
     }
@@ -117,7 +131,7 @@ export async function doctor(d: DoctorDeps): Promise<DoctorReport> {
         checks.push({
           id: `binding:${repo}`,
           label: `binding ${repo}`,
-          state: "fail",
+          state: repo === d.repo ? "fail" : "warn",
           word: "missing",
           detail: `bound to profile ${name}, which does not exist`,
           fix: `cd ${repo} && catherd profile use --repo --clear`,
@@ -130,30 +144,32 @@ export async function doctor(d: DoctorDeps): Promise<DoctorReport> {
   const names = active ? [active.name, ...linked.filter((n) => n !== active?.name)] : [];
   for (const name of names) {
     const id = name === active?.name ? "profile" : `profile:${name}`;
-    const validate = `catherd profile validate ${name}`;
+    const validate = `catherd profile validate ${name}${onHost}`;
     const named = (fix: string) =>
-      fix.replaceAll("catherd profile set ", `catherd profile set --profile ${name} `);
-    checks.push(
-      guarded(id, `profile ${name}`, validate, () => {
-        const v = validateNamed(name);
-        const first = v.errors[0] ?? v.warnings[0];
-        return {
-          id,
-          label: `profile ${name}`,
-          state: v.errors.length ? "fail" : v.warnings.length ? "warn" : "ok",
-          word: v.errors.length ? "invalid" : v.warnings.length ? "warning" : "ready",
-          detail: first
-            ? `${first.path}: ${first.message}${v.errors.length + v.warnings.length > 1 ? " (and more)" : ""}`
-            : "valid",
-          ...(first ? { fix: first.fix ? named(first.fix) : validate } : {}),
-        };
-      }),
-    );
+      fix.replaceAll("catherd profile set ", `catherd profile set --profile ${name}${onHost} `);
+    const row = guarded(id, `profile ${name}`, validate, () => {
+      const v = validateNamed(name, d.repo, d.host.host);
+      const first = v.errors[0] ?? v.warnings[0];
+      return {
+        id,
+        label: `profile ${name}`,
+        state: v.errors.length ? "fail" : v.warnings.length ? "warn" : "ok",
+        word: v.errors.length ? "invalid" : v.warnings.length ? "warning" : "ready",
+        detail: first
+          ? `${first.path}: ${first.message}${v.errors.length + v.warnings.length > 1 ? " (and more)" : ""}`
+          : "valid",
+        ...(first ? { fix: first.fix ? named(first.fix) : validate } : {}),
+      };
+    });
+    if (name !== active?.name && row.state === "fail") row.state = "warn";
+    checks.push(row);
   }
 
+  const diagnostics = profiles;
+  profiles = active ? [active] : [];
   const used = usedBackends(profiles);
   const installed = new Set<string>();
-  checks.push(...(await backendChecks(used, profiles, installed)));
+  checks.push(...(await backendChecks(used, profiles, installed, d.host.host)));
 
   if (active && [active, ...profiles].every((p) => p.jev.use === "off"))
     checks.push({
@@ -193,18 +209,44 @@ export async function doctor(d: DoctorDeps): Promise<DoctorReport> {
 
   // spec 1.2 §9: the public sources' ages and errors, the Artificial Analysis key, and the active and linked
   // profiles' stand-ins to confirm
-  const mine = [...(active ? [active] : []), ...profiles.filter((p) => p.name !== active?.name)];
+  const mine = [...(active ? [active] : []), ...diagnostics.filter((p) => p.name !== active?.name)];
   checks.push(
     guarded("sources", "sources", "catherd catalog sync --force", () =>
       sourcesCheck(Date.now(), standInsToConfirmIn(mine)),
     ),
   );
 
-  checks.push(pluginCheck(d.version));
+  const native = used.get("claude");
+  const plugin = pluginCheck(d.version);
+  if (d.host.host !== "claude-code" && native !== "role") {
+    plugin.state = native === "failover" ? "warn" : "skip";
+    plugin.word = native === "failover" ? "optional" : "not required";
+  }
+  checks.push(plugin);
 
+  // relinks the profile doctor checked: this repo's binding when it has one, else the active profile
+  let bound = false;
+  try {
+    bound = d.repo !== null && readProjects().bindings[d.repo] === active?.name;
+  } catch {
+    // the config row above already reports an unreadable projects.json
+  }
+  const relink = active
+    ? `${bound ? `cd ${d.repo} && ` : ""}catherd profile use ${active.name}${bound ? " --repo" : ""}${onHost}`
+    : "";
   checks.push(
     active
-      ? guarded("agents", "Claude agents", `catherd profile use ${activeName()}`, agentsCheck)
+      ? guarded("agents", "Claude agents", relink, () =>
+          native
+            ? agentsCheck(d.host.host, [active!.name], relink)
+            : {
+                id: "agents",
+                label: "Claude agents",
+                state: "skip",
+                word: "not required",
+                detail: "selected profile has no native Claude roles",
+              },
+        )
       : {
           id: "agents",
           label: "Claude agents",
@@ -214,15 +256,39 @@ export async function doctor(d: DoctorDeps): Promise<DoctorReport> {
         },
   );
 
+  const agents = checks.find((c) => c.id === "agents");
+  if (native === "failover" && agents?.state === "fail") agents.state = "warn";
+
   const h = await d
     .handshake()
     .catch((e: unknown): Handshake => ({ ok: false, tools: [], error: errText(e) }));
   checks.push(mcpCheck(h, d.version));
 
-  if (d.push)
-    checks.push(
-      pushCheck(await d.push().catch((e: unknown): PushProbe => ({ outcome: "failed", detail: errText(e) }))),
-    );
+  const queue =
+    d.host.host === "codex" && !d.host.conflict ? await queueCapability(d.env ?? process.env) : null;
+  if (queue)
+    checks.push({
+      id: "push-capability",
+      label: "native Codex queue",
+      state:
+        !queue.cli || queue.server === "unsupported" ? "fail" : queue.server === "unverified" ? "warn" : "ok",
+      word: !queue.cli ? "unavailable" : queue.server,
+      detail: queue.reason ?? "Native server advertises queue support",
+      ...(!queue.cli || queue.server === "unsupported"
+        ? { fix: "Update native Codex/server; use peek/result while push is unavailable." }
+        : {}),
+    });
+  let push: PushProbe | null = null;
+  if (d.testPush) {
+    push = await (d.push ?? (() => probePush(d.host, d.env ?? process.env)))().catch((): PushProbe => ({
+      outcome: "failed",
+      enqueue: "ambiguous",
+      processing: "unconfirmed",
+      msgId: null,
+      detail: "Smoke has no verified receipt; retry may duplicate input. Use peek/result.",
+    }));
+    checks.push(pushCheck(push));
+  }
 
   checks.push(locksCheck());
   // spec §5 and §12: which codex sandbox form runs, and the five access probes per workspace-write backend
@@ -321,6 +387,8 @@ export async function doctor(d: DoctorDeps): Promise<DoctorReport> {
       detail: "the plugin's MCP launcher runs bunx when no global catherd is installed",
       fix: "put Bun's bin folder (~/.bun/bin) on PATH",
     });
+  const browser = uiBrowserCheck(mine, onPath, d.host.host);
+  if (browser) checks.push(browser);
   let corrupt: ReturnType<typeof listRuns>["corrupt"] = [];
   try {
     corrupt = listRuns().corrupt;
@@ -344,5 +412,12 @@ export async function doctor(d: DoctorDeps): Promise<DoctorReport> {
       fix: `fix or delete ${corrupt[0]?.dir}`,
     });
 
-  return { ready: !checks.some((c) => c.state === "fail"), version: d.version, checks };
+  return {
+    host: inspectionHost(d.host),
+    queue,
+    push,
+    ready: !checks.some((c) => c.state === "fail"),
+    version: d.version,
+    checks,
+  };
 }

package/src/services/finalize.ts

@@ -222,10 +222,11 @@ async function compute(run: Run, d: Dispatch): Promise<RunRecord> {
     threadHeavy: o.tokens.input >= THREAD_HEAVY_INPUT,
     access: a.access,
     isolated: a.isolated,
+    ...(a.network === undefined ? {} : { network: a.network }),
     images: o.images,
     error: o.error,
     replyPath: relative(run.dir, p.reply),
-    ...(a.sessionId ? { sessionId: a.sessionId } : {}),
+    ...(a.sessionId ? { sessionId: a.sessionId, host: a.host ?? "claude-code" } : {}),
   };
 }
 

package/src/services/lane-service.ts

@@ -4,6 +4,7 @@ import { CatherdError } from "../domain/errors.ts";
 import { assertId, ID_PATTERN, parseRung } from "../domain/ids.ts";
 import { assertLaneHeader, type Difficulty, type Kind } from "../domain/lane.ts";
 import type { Role } from "../domain/roles.ts";
+import { cell } from "../domain/util.ts";
 import {
   type ClimbReason,
   currentRoute,
@@ -28,11 +29,11 @@ import {
 } from "./milestones.ts";
 import type { Deps, Verdict } from "./ports.ts";
 import {
+  appendKnowledge,
   appendLedger,
   appendOutcome,
   appendRoute,
   findRun,
-  knowledgeFile,
   readRoutes,
   type Run,
   runFile,
@@ -41,7 +42,6 @@ import {
 import { writeDigest } from "./protocol.ts";
 import { openQuestions } from "./questions.ts";
 import { type Notes, type NotesPatch, refreshState } from "./state.ts";
-import { appendPrivate } from "../infra/store.ts";
 
 const withHints = (hints: string[]) => (hints.length ? { hints } : {});
 
@@ -88,6 +88,7 @@ export async function route(
   const lane = i.laneFile === undefined ? null : readLaneFile(run, i.laneFile);
   const profile = deps.profiles.forRepo(run.meta.repo);
   const a = await deps.routing.route({
+    host: deps.host.host,
     runDir: run.dir,
     repo: run.meta.repo,
     profile,
@@ -212,8 +213,6 @@ export async function climb(
   };
 }
 
-const cell = (s: string) => s.replace(/[|\n]/g, "/").replace(/\s+/g, " ").trim();
-
 export const LAND_SKIPS = ["docs-only", "no-code"] as const;
 export type LandSkip = (typeof LAND_SKIPS)[number];
 
@@ -348,12 +347,7 @@ export async function land(
     hints.push(
       `land: no routed lane is in milestone "${i.milestone}" (routed: ${routed.slice(0, 5).join(", ")}${routed.length > 5 ? ", …" : ""}); check its name: no lane outcome was recorded`,
     );
-  if (i.learned) {
-    appendPrivate(
-      knowledgeFile(run.meta.repo),
-      `- ${now.toISOString().slice(0, 10)} ${run.meta.title} ${i.milestone}: ${cell(i.learned)}\n`,
-    );
-  }
+  if (i.learned) appendKnowledge(run.meta.repo, now, `${run.meta.title} ${i.milestone}`, i.learned);
   // spec 1.1 §10: the milestone's digest, which the milestone push links
   const digest = writeDigest(run, {
     milestone: i.milestone,