app/cli/commands/lane-log.ts

 // `zz lane log <owner/repo>`: a chronological feed of every ASK/ANSWER

 // across every Lane for a repo -- the protocol trail `ladder dump` shows

 // the resulting content for, but not the process that produced it.

 // Remote by default, like work/review/top -- confirmed live this was

 // the one command that never got this treatment (always read the

 // local flat-file store regardless of where the repo actually lived),

 // so this showed nothing at all for any repo only ever touched on the

 // deployed Worker.

 import { resolveRepo } from "../lib/repo.js";

 import { listLanes } from "../../engine/store.js";

 import { callRemoteTool } from "../lib/remoteTools.js";

 import type { HistoryEntry, Lane } from "../../engine/types.js";

 export type LaneLogFormat = "text" | "json";

 export interface LaneLogOptions {

  format?: LaneLogFormat;

  lane?: string;

  out?: string;

  local?: boolean;

 }

 interface LogRow {

  at: string;

  lane: string;

  laneName: string;

  entry: HistoryEntry;

 }

 function flatten(lanes: Lane[]): LogRow[] {

  const rows: LogRow[] = [];

  for (const lane of lanes) {

  for (const entry of lane.history) {

  rows.push({ at: entry.at, lane: lane.id, laneName: lane.name, entry });

  }

  }

  return rows.sort((a, b) => a.at.localeCompare(b.at));

 }

 // A payload can carry a whole Rung (or array of Rungs), a commit, or

 // just a few scalar fields -- print enough to identify what's being

 // asked for/answered without dumping a full diff or Ladder subtree into

 // every line of the log.

 function summarizePayload(payload: unknown): string {

  if (payload === undefined || payload === null) return "";

  if (typeof payload !== "object") return String(payload);

  const p = payload as Record<string, unknown>;

  if (p.target) return `{target: ${p.target}}`;

  if (p.grant) return `{grant: ${p.grant}}`;

  if (p.commit && typeof p.commit === "object") {

  const c = p.commit as { sha?: string; message?: string };

  return `{commit: ${c.sha?.slice(0, 7)} "${c.message}"${p.change ? `, change: ${(p.change as { path?: string }).path}` : ""}}`;

  }

  if (p.path && p.changeSummary) return `{path: ${p.path}}`;

  if (p.ladder) {

  const ladder = p.ladder as { path?: string; kind?: string } | { path?: string; kind?: string }[];

  const rungs = Array.isArray(ladder) ? ladder : [ladder];

  return `{ladder: ${rungs.map((r) => `${r.kind}:${r.path}`).join(", ")}}`;

  }

  if ("path" in p && "kind" in p) return `{${p.kind}:${p.path}}`;

  const json = JSON.stringify(payload);

  return json.length > 80 ? json.slice(0, 77) + "..." : json;

 }

 function renderEntry(entry: HistoryEntry): string {

  if (entry.type === "ASK") {

  const deps = entry.depends_on?.length ? ` deps=[${entry.depends_on.join(",")}]` : "";

  return `ASK ${entry.id.padEnd(14)} ${entry.kind.padEnd(18)} from ${entry.from}${deps} ${summarizePayload(entry.payload)}`;

  }

  if (entry.type === "ANSWER") {

  return `ANSWER ${entry.id.padEnd(14)} -> ${entry.ask.padEnd(14)} ${entry.action.padEnd(9)} from ${entry.from} ${summarizePayload(entry.payload)}`;

  }

  return `INSIGHT ${entry.kind.padEnd(17)} from ${entry.from}: ${entry.text}`;

 }

 function renderText(lanes: Lane[], rows: LogRow[]): string {

  const lines: string[] = [];

  lines.push(`${lanes.length} lanes, ${rows.length} protocol events.`);

  lines.push("");

  for (const row of rows) {

  lines.push(`${row.at} [${row.lane}] ${renderEntry(row.entry)}`);

  }

  lines.push("");

  lines.push("lanes:");

  for (const lane of lanes) {

  lines.push(` [${lane.status}] ${lane.id} -- ${lane.name} (origin: ${lane.origin ? lane.origin.lane : "none"})`);

  }

  return lines.join("\n");

 }

 export async function laneLog(slug: string, options: LaneLogOptions): Promise<void> {

  // allowAnonymous: lane_list is one of the server's own ANON_READ_TOOLS

  // for a public repo (webApp.ts) -- works the same with or without a

  // `zz login` session, same as `zz top`'s own reads.

  let lanes = options.local ? listLanes(resolveRepo(slug).stateDir) : ((await callRemoteTool(slug, "lane_list", {}, true)) as Lane[]);

  if (options.lane) lanes = lanes.filter((l) => l.id === options.lane);

  const rows = flatten(lanes);

  const format = options.format ?? "text";

  const output = format === "json" ? JSON.stringify({ repo: slug, lanes, events: rows }, null, 2) : renderText(lanes, rows);

  if (options.out) {

  await import("node:fs").then((fs) => fs.writeFileSync(options.out!, output));

  console.error(`wrote ${lanes.length} lanes, ${rows.length} events to ${options.out}`);

  } else {

  process.stdout.write(output + "\n");

  }

 }